diff --git a/backend/src/middleware/__tests__/validation.test.ts b/backend/src/middleware/__tests__/validation.test.ts
new file mode 100644
index 00000000..9656727c
--- /dev/null
+++ b/backend/src/middleware/__tests__/validation.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import { commonSchemas, validateAndSanitize } from '../validation.js';
+
+function req(overrides: Partial<Request>): Request {
+  return {
+    body: {},
+    query: {},
+    params: {},
+    headers: {},
+    ...overrides,
+  } as Request;
+}
+
+describe('validation middleware', () => {
+  it('sanitizes and validates body, query, and params', () => {
+    const request = req({
+      body: { email: ' USER@EXAMPLE.COM ', note: '<script>alert(1)</script>paid' },
+      query: { page: '2', limit: '10' },
+      params: { id: 'payment_123' },
+    });
+    const next = vi.fn();
+
+    validateAndSanitize({
+      body: z.object({
+        email: commonSchemas.email,
+        note: z.string().max(100),
+      }),
+      query: commonSchemas.pagination,
+      params: z.object({ id: commonSchemas.id }),
+    })(request, {} as Response, next);
+
+    expect(next).toHaveBeenCalledWith();
+    expect(request.body.email).toBe('user@example.com');
+    expect(request.body.note).not.toContain('<script>');
+    expect(request.query.page).toBe(2);
+    expect(request.params.id).toBe('payment_123');
+  });
+
+  it('passes formatted validation errors to error middleware', () => {
+    const request = req({ body: { amount: '-1' } });
+    const next = vi.fn();
+
+    validateAndSanitize({
+      body: z.object({ amount: commonSchemas.amount }),
+    })(request, {} as Response, next);
+
+    expect(next).toHaveBeenCalledWith(expect.objectContaining({
+      statusCode: 400,
+      code: 'ERR_VALIDATION_FAILED',
+    }));
+  });
+});
diff --git a/backend/src/middleware/index.ts b/backend/src/middleware/index.ts
index cea57224..fe84d8f4 100644
--- a/backend/src/middleware/index.ts
+++ b/backend/src/middleware/index.ts
@@ -16,6 +16,14 @@ export { slaTrackingMiddleware } from './slaTracking.js';
 export { traceMiddleware, TRACE_ID_HEADER } from './trace.js';
 export { cacheControlNoStore, CACHE_NOSTORE_HEADER, VARY_HEADER } from './cache-control.js';
 export { validate } from './validate.js';
+export {
+  validateAndSanitize,
+  validateRequest as validateRequestWithSanitization,
+  validateBody,
+  commonSchemas,
+  type ValidationOptions,
+  type ValidationSchemas,
+} from './validation.js';
 export { versionMiddleware } from './versioning.js';
 export { verifyWebhook, webhookVerifiers, rawBodyCapture, type WebhookVerificationConfig } from './webhookVerification.js';
 export { composeMiddleware, type MiddlewareFunction, type MiddlewareChain } from './compose.js';
diff --git a/backend/src/middleware/sanitize.js b/backend/src/middleware/sanitize.js
index 8d9005cf..bbd7c35b 100644
--- a/backend/src/middleware/sanitize.js
+++ b/backend/src/middleware/sanitize.js
@@ -67,7 +67,7 @@ var InputSanitizer = /** @class */ (function () {
         }
         // XSS Protection
         if (options.xssProtection) {
-            sanitized = (0, xss_1.default)(sanitized);
+            sanitized = (typeof xss_1 === 'function' ? xss_1 : xss_1.default)(sanitized);
         }
         // HTML Sanitization
         if (options.htmlSanitization) {
diff --git a/backend/src/middleware/validate.js b/backend/src/middleware/validate.js
index 1920c2d5..7d00a085 100644
--- a/backend/src/middleware/validate.js
+++ b/backend/src/middleware/validate.js
@@ -1,29 +1,48 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-var zod_1 = require("zod");
-/**
- * Reusable middleware to validate the request body against a Zod schema.
- * Returns a 400 Bad Request with detailed errors if validation fails.
- */
-var validate = function (schema) {
-    return function validateMiddleware(req, res, next) {
-        try {
-            schema.parse(req.body);
-            next();
-        }
-        catch (error) {
-            if (error instanceof zod_1.ZodError) {
-                return res.status(400).json({
-                    message: 'Validation failed',
-                    errors: error.errors.map(function (err) { return ({
-                        path: err.path.join('.'),
-                        message: err.message,
-                    }); }),
-                });
-            }
-            next(error);
-        }
-    };
+exports.validate = exports.validateRequest = void 0;
+
+const zod_1 = require("zod");
+const errors_js_1 = require("../types/errors.js");
+
+function formatIssues(issues) {
+  return issues.map((err) => ({
+    path: err.path.join(".") || "root",
+    message: err.message,
+  }));
+}
+
+function isZodError(error) {
+  return error instanceof zod_1.ZodError ||
+    (typeof error === "object" &&
+      error !== null &&
+      error.name === "ZodError" &&
+      Array.isArray(error.errors));
+}
+
+const validateRequest = (targets) => {
+  return function validateRequestMiddleware(req, _res, next) {
+    try {
+      if (targets.body) req.body = targets.body.parse(req.body ?? {});
+      if (targets.query) req.query = targets.query.parse(req.query ?? {});
+      if (targets.params) req.params = targets.params.parse(req.params ?? {});
+      next();
+    } catch (error) {
+      if (isZodError(error)) {
+        return next(new errors_js_1.AppError(
+          400,
+          "Request validation failed",
+          "ERR_VALIDATION_FAILED",
+          formatIssues(error.errors)
+        ));
+      }
+      next(error);
+    }
+  };
 };
+
+exports.validateRequest = validateRequest;
+const validate = (schema) => (0, exports.validateRequest)({ body: schema });
 exports.validate = validate;
+exports.default = validate;
diff --git a/backend/src/middleware/validate.ts b/backend/src/middleware/validate.ts
index a6ed3824..9d25d1cc 100644
--- a/backend/src/middleware/validate.ts
+++ b/backend/src/middleware/validate.ts
@@ -1,6 +1,6 @@
 import { Request, Response, NextFunction } from 'express';
 import { ZodSchema, ZodError, ZodIssue } from 'zod';
-import { AppError } from './errorHandler.js';
+import { AppError } from '../types/errors.js';
 
 export interface ValidationTargets {
   body?: ZodSchema;
@@ -15,6 +15,15 @@ function formatIssues(issues: ZodIssue[]) {
   }));
 }
 
+function isZodError(error: unknown): error is ZodError {
+  return error instanceof ZodError || (
+    typeof error === 'object' &&
+    error !== null &&
+    (error as { name?: string }).name === 'ZodError' &&
+    Array.isArray((error as { errors?: unknown }).errors)
+  );
+}
+
 /**
  * Validate request body, query, and params against Zod schemas.
  * Returns generic 400 responses without leaking internal details.
@@ -33,7 +42,7 @@ export const validateRequest = (targets: ValidationTargets) => {
       }
       next();
     } catch (error) {
-      if (error instanceof ZodError) {
+      if (isZodError(error)) {
         return next(new AppError(400, 'Request validation failed', 'ERR_VALIDATION_FAILED', formatIssues(error.errors)));
       }
       next(error);
diff --git a/backend/src/middleware/validation.js b/backend/src/middleware/validation.js
new file mode 100644
index 00000000..47641fd0
--- /dev/null
+++ b/backend/src/middleware/validation.js
@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBody = exports.validateRequest = exports.validateAndSanitize = exports.commonSchemas = void 0;
+
+const zod_1 = require("zod");
+const errors_js_1 = require("../types/errors.js");
+const sanitize_js_1 = require("./sanitize.js");
+
+exports.commonSchemas = {
+  uuid: zod_1.z.string().uuid(),
+  id: zod_1.z.string().trim().min(1).max(128).regex(/^[a-zA-Z0-9._:-]+$/),
+  email: zod_1.z.string().trim().email().max(255).transform((value) => value.toLowerCase()),
+  pagination: zod_1.z.object({
+    page: zod_1.z.coerce.number().int().min(1).max(1000).default(1),
+    limit: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+  }),
+  stellarAddress: zod_1.z.string().regex(/^G[A-Z0-9]{55}$/, "Invalid Stellar address format"),
+  amount: zod_1.z.coerce.number().positive().finite().max(1_000_000_000),
+};
+
+function sanitizeValue(value, options) {
+  return sanitize_js_1.InputSanitizer.getInstance().sanitize(value, {
+    sqlEscape: false,
+    htmlSanitization: false,
+    escapeHtml: false,
+    ...options,
+  });
+}
+
+function parseSchema(schema, value, stripUnknown) {
+  if (stripUnknown && schema instanceof zod_1.z.ZodObject) {
+    return schema.strip().parse(value ?? {});
+  }
+  return schema.parse(value ?? {});
+}
+
+function formatZodError(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join(".") || "root",
+    message: issue.message,
+    code: issue.code,
+  }));
+}
+
+function isZodError(error) {
+  return error instanceof zod_1.ZodError ||
+    (typeof error === "object" &&
+      error !== null &&
+      error.name === "ZodError" &&
+      Array.isArray(error.errors));
+}
+
+function validateAndSanitize(schemas, options = {}) {
+  return function validationMiddleware(req, _res, next) {
+    try {
+      const shouldSanitize = options.sanitize ?? true;
+
+      if (schemas.body) {
+        const value = shouldSanitize ? sanitizeValue(req.body ?? {}, options.sanitizer) : req.body;
+        req.body = parseSchema(schemas.body, value, options.stripUnknown);
+      }
+
+      if (schemas.query) {
+        const value = shouldSanitize ? sanitizeValue(req.query ?? {}, options.sanitizer) : req.query;
+        req.query = parseSchema(schemas.query, value, options.stripUnknown);
+      }
+
+      if (schemas.params) {
+        const value = shouldSanitize ? sanitizeValue(req.params ?? {}, options.sanitizer) : req.params;
+        req.params = parseSchema(schemas.params, value, options.stripUnknown);
+      }
+
+      if (schemas.headers) {
+        const headers = Object.fromEntries(
+          Object.entries(req.headers).map(([key, value]) => [key.toLowerCase(), value])
+        );
+        parseSchema(schemas.headers, headers, options.stripUnknown);
+      }
+
+      next();
+    } catch (error) {
+      if (isZodError(error)) {
+        return next(new errors_js_1.AppError(
+          400,
+          "Request validation failed",
+          "ERR_VALIDATION_FAILED",
+          formatZodError(error)
+        ));
+      }
+
+      next(error);
+    }
+  };
+}
+
+exports.validateAndSanitize = validateAndSanitize;
+exports.validateRequest = validateAndSanitize;
+const validateBody = (schema, options) => validateAndSanitize({ body: schema }, options);
+exports.validateBody = validateBody;
+exports.default = validateAndSanitize;
diff --git a/backend/src/middleware/validation.ts b/backend/src/middleware/validation.ts
new file mode 100644
index 00000000..5932a4f5
--- /dev/null
+++ b/backend/src/middleware/validation.ts
@@ -0,0 +1,117 @@
+import { Request, Response, NextFunction } from 'express';
+import { AnyZodObject, ZodError, ZodSchema, z } from 'zod';
+import { AppError } from '../types/errors.js';
+import { InputSanitizer, SanitizeOptions } from './sanitize.js';
+
+export interface ValidationSchemas {
+  body?: ZodSchema;
+  query?: ZodSchema;
+  params?: ZodSchema;
+  headers?: ZodSchema;
+}
+
+export interface ValidationOptions {
+  sanitize?: boolean;
+  sanitizer?: SanitizeOptions;
+  stripUnknown?: boolean;
+}
+
+export const commonSchemas = {
+  uuid: z.string().uuid(),
+  id: z.string().trim().min(1).max(128).regex(/^[a-zA-Z0-9._:-]+$/),
+  email: z.string().trim().email().max(255).transform((value) => value.toLowerCase()),
+  pagination: z.object({
+    page: z.coerce.number().int().min(1).max(1000).default(1),
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+  }),
+  stellarAddress: z.string().regex(/^G[A-Z0-9]{55}$/, 'Invalid Stellar address format'),
+  amount: z.coerce.number().positive().finite().max(1_000_000_000),
+};
+
+function sanitizeValue(value: unknown, options?: SanitizeOptions): unknown {
+  return InputSanitizer.getInstance().sanitize(value, {
+    sqlEscape: false,
+    htmlSanitization: false,
+    escapeHtml: false,
+    ...options,
+  });
+}
+
+function parseSchema(schema: ZodSchema, value: unknown, stripUnknown?: boolean): unknown {
+  if (stripUnknown && schema instanceof z.ZodObject) {
+    return (schema as AnyZodObject).strip().parse(value ?? {});
+  }
+
+  return schema.parse(value ?? {});
+}
+
+function formatZodError(error: ZodError) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join('.') || 'root',
+    message: issue.message,
+    code: issue.code,
+  }));
+}
+
+function isZodError(error: unknown): error is ZodError {
+  return error instanceof ZodError || (
+    typeof error === 'object' &&
+    error !== null &&
+    (error as { name?: string }).name === 'ZodError' &&
+    Array.isArray((error as { errors?: unknown }).errors)
+  );
+}
+
+export function validateAndSanitize(
+  schemas: ValidationSchemas,
+  options: ValidationOptions = {}
+) {
+  return function validationMiddleware(req: Request, _res: Response, next: NextFunction) {
+    try {
+      const shouldSanitize = options.sanitize ?? true;
+
+      if (schemas.body) {
+        const value = shouldSanitize ? sanitizeValue(req.body ?? {}, options.sanitizer) : req.body;
+        req.body = parseSchema(schemas.body, value, options.stripUnknown);
+      }
+
+      if (schemas.query) {
+        const value = shouldSanitize ? sanitizeValue(req.query ?? {}, options.sanitizer) : req.query;
+        req.query = parseSchema(schemas.query, value, options.stripUnknown) as typeof req.query;
+      }
+
+      if (schemas.params) {
+        const value = shouldSanitize ? sanitizeValue(req.params ?? {}, options.sanitizer) : req.params;
+        req.params = parseSchema(schemas.params, value, options.stripUnknown) as typeof req.params;
+      }
+
+      if (schemas.headers) {
+        const headers = Object.fromEntries(
+          Object.entries(req.headers).map(([key, value]) => [key.toLowerCase(), value])
+        );
+        parseSchema(schemas.headers, headers, options.stripUnknown);
+      }
+
+      next();
+    } catch (error) {
+      if (isZodError(error)) {
+        return next(
+          new AppError(
+            400,
+            'Request validation failed',
+            'ERR_VALIDATION_FAILED',
+            formatZodError(error)
+          )
+        );
+      }
+
+      next(error);
+    }
+  };
+}
+
+export const validateRequest = validateAndSanitize;
+export const validateBody = (schema: ZodSchema, options?: ValidationOptions) =>
+  validateAndSanitize({ body: schema }, options);
+
+export default validateAndSanitize;
diff --git a/backend/src/services/queue-producers.js b/backend/src/services/queue-producers.js
index fec75567..60692140 100644
--- a/backend/src/services/queue-producers.js
+++ b/backend/src/services/queue-producers.js
@@ -51,6 +51,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageQueue = void 0;
 exports.queueEmail = queueEmail;
 exports.queueNotification = queueNotification;
 exports.queueWebhook = queueWebhook;
@@ -59,6 +60,7 @@ exports.processNotificationJob = processNotificationJob;
 exports.processWebhookJob = processWebhookJob;
 exports.registerDefaultProcessors = registerDefaultProcessors;
 var queue_js_1 = require("./queue.js");
+Object.defineProperty(exports, "messageQueue", { enumerable: true, get: function () { return queue_js_1.messageQueue; } });
 /**
  * Queue an email to be sent asynchronously
  */
diff --git a/backend/src/services/queue-producers.ts b/backend/src/services/queue-producers.ts
index d9f333a2..45642b19 100644
--- a/backend/src/services/queue-producers.ts
+++ b/backend/src/services/queue-producers.ts
@@ -5,6 +5,8 @@
 
 import { messageQueue, QueueJob, JobPriority } from './queue.js';
 
+export { messageQueue };
+
 export interface EmailJobData {
   to: string;
   subject: string;
diff --git a/backend/src/services/queue.js b/backend/src/services/queue.js
index d7b522cd..1b940abc 100644
--- a/backend/src/services/queue.js
+++ b/backend/src/services/queue.js
@@ -1,321 +1,373 @@
 "use strict";
-/**
- * Message Queue Service
- * Manages async task processing with retry logic and state management
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
+
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.messageQueue = void 0;
-var DEFAULT_CONFIG = {
-    maxAttempts: 3,
-    retryDelayMs: 1000, // 1 second
-    retryBackoffMultiplier: 2, // exponential backoff
-    maxRetryDelayMs: 60 * 1000, // 1 minute max
-    pollIntervalMs: 1000, // 1 second
-    batchSize: 10,
+exports.MessageQueue = exports.messageQueue = void 0;
+
+const crypto = require("node:crypto");
+
+const PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  normal: 2,
+  low: 3,
 };
-/**
- * In-memory message queue implementation
- * Suitable for single-instance deployments; use Redis for distributed systems
- */
-var MessageQueue = /** @class */ (function () {
-    function MessageQueue(config) {
-        if (config === void 0) { config = {}; }
-        this.jobs = new Map();
-        this.processors = new Map();
-        this.isRunning = false;
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+
+const DEFAULT_CONFIG = {
+  maxAttempts: 3,
+  retryDelayMs: 1000,
+  retryBackoffMultiplier: 2,
+  maxRetryDelayMs: 60 * 1000,
+  pollIntervalMs: 1000,
+  batchSize: 10,
+  rateLimits: {
+    email: { maxPerSecond: 10, maxBurst: 20 },
+    notifications: { maxPerSecond: 50, maxBurst: 100 },
+    webhooks: { maxPerSecond: 30, maxBurst: 60 },
+    "external-api": { maxPerSecond: 5, maxBurst: 10 },
+  },
+  enableDlq: true,
+  dlqMaxRetentionMs: 7 * 24 * 60 * 60 * 1000,
+};
+
+class TokenBucket {
+  constructor(maxTokens, refillRate) {
+    this.maxTokens = maxTokens;
+    this.refillRate = refillRate;
+    this.tokens = maxTokens;
+    this.lastRefill = Date.now();
+  }
+
+  tryConsume(count) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
     }
-    /**
-     * Register a job processor for a queue
-     */
-    MessageQueue.prototype.registerProcessor = function (queue, processor) {
-        this.processors.set(queue, processor);
-    };
-    /**
-     * Queue a new job
-     */
-    MessageQueue.prototype.enqueue = function (queue, data, maxAttempts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var job;
-            return __generator(this, function (_a) {
-                job = {
-                    id: this.generateJobId(),
-                    queue: queue,
-                    data: data,
-                    status: 'pending',
-                    attempts: 0,
-                    maxAttempts: maxAttempts || this.config.maxAttempts,
-                    createdAt: new Date(),
-                };
-                this.jobs.set(job.id, job);
-                console.log("Job enqueued: ".concat(JSON.stringify(job)));
-                return [2 /*return*/, job];
-            });
-        });
-    };
-    /**
-     * Get a job by ID
-     */
-    MessageQueue.prototype.getJob = function (jobId) {
-        return this.jobs.get(jobId);
-    };
-    /**
-     * Get all jobs
-     */
-    MessageQueue.prototype.getAllJobs = function () {
-        return Array.from(this.jobs.values());
-    };
-    /**
-     * Get jobs by queue
-     */
-    MessageQueue.prototype.getJobsByQueue = function (queue) {
-        return Array.from(this.jobs.values()).filter(function (job) { return job.queue === queue; });
-    };
-    /**
-     * Get jobs by status
-     */
-    MessageQueue.prototype.getJobsByStatus = function (status) {
-        return Array.from(this.jobs.values()).filter(function (job) { return job.status === status; });
-    };
-    /**
-     * Start processing jobs
-     */
-    MessageQueue.prototype.start = function () {
-        var _this = this;
-        if (this.isRunning) {
-            console.warn('Queue processor already running');
-            return;
-        }
-        this.isRunning = true;
-        console.log('Message queue processor started');
-        this.processingInterval = setInterval(function () {
-            _this.processJobs();
-        }, this.config.pollIntervalMs);
-    };
-    /**
-     * Stop processing jobs
-     */
-    MessageQueue.prototype.stop = function () {
-        if (!this.isRunning) {
-            return;
-        }
-        this.isRunning = false;
-        if (this.processingInterval) {
-            clearInterval(this.processingInterval);
-        }
-        console.log('Message queue processor stopped');
-    };
-    /**
-     * Process pending and retryable jobs
-     */
-    MessageQueue.prototype.processJobs = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var now_1, jobsToProcess, _i, jobsToProcess_1, job, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isRunning) {
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, , 7]);
-                        now_1 = new Date();
-                        jobsToProcess = Array.from(this.jobs.values())
-                            .filter(function (job) {
-                            return (job.status === 'pending' ||
-                                (job.status === 'retrying' && job.nextRetryAt && job.nextRetryAt <= now_1)) &&
-                                job.attempts < job.maxAttempts;
-                        })
-                            .slice(0, this.config.batchSize);
-                        _i = 0, jobsToProcess_1 = jobsToProcess;
-                        _a.label = 2;
-                    case 2:
-                        if (!(_i < jobsToProcess_1.length)) return [3 /*break*/, 5];
-                        job = jobsToProcess_1[_i];
-                        return [4 /*yield*/, this.processJob(job)];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        error_1 = _a.sent();
-                        console.error('Error in job processing loop:', error_1);
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Process a single job
-     */
-    MessageQueue.prototype.processJob = function (job) {
-        return __awaiter(this, void 0, void 0, function () {
-            var processor, error_2, delayMs;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        processor = this.processors.get(job.queue);
-                        if (!processor) {
-                            console.warn("No processor registered for queue: ".concat(job.queue));
-                            job.status = 'failed';
-                            job.lastError = "No processor found for queue: ".concat(job.queue);
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        job.status = 'processing';
-                        job.attempts += 1;
-                        return [4 /*yield*/, processor(job)];
-                    case 2:
-                        _a.sent();
-                        job.status = 'completed';
-                        job.completedAt = new Date();
-                        job.processedAt = new Date();
-                        console.log("Job completed: ".concat(job.id));
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _a.sent();
-                        job.lastError = error_2 instanceof Error ? error_2.message : String(error_2);
-                        job.processedAt = new Date();
-                        if (job.attempts < job.maxAttempts) {
-                            delayMs = Math.min(this.config.retryDelayMs * Math.pow(this.config.retryBackoffMultiplier, job.attempts - 1), this.config.maxRetryDelayMs);
-                            job.status = 'retrying';
-                            job.nextRetryAt = new Date(Date.now() + delayMs);
-                            console.log("Job scheduled for retry: ".concat(job.id, " in ").concat(delayMs, "ms"));
-                        }
-                        else {
-                            // Max retries exceeded
-                            job.status = 'failed';
-                            console.error("Job failed after ".concat(job.attempts, " attempts: ").concat(job.id), job.lastError);
-                        }
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
+    return false;
+  }
+
+  refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1000;
+    this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);
+    this.lastRefill = now;
+  }
+
+  get usage() {
+    this.refill();
+    return this.maxTokens - this.tokens;
+  }
+
+  get remaining() {
+    this.refill();
+    return this.tokens;
+  }
+}
+
+class MessageQueue {
+  constructor(config = {}) {
+    this.jobs = new Map();
+    this.processors = new Map();
+    this.isRunning = false;
+    this.dlq = [];
+    this.rateLimiters = new Map();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.metrics = {
+      totalEnqueued: 0,
+      totalCompleted: 0,
+      totalFailed: 0,
+      totalDlq: 0,
+      totalRetried: 0,
+      avgProcessingTimeMs: 0,
+      processingTimeSamples: 0,
+      priorityDistribution: { critical: 0, high: 0, normal: 0, low: 0 },
+      perQueueLatency: {},
     };
-    /**
-     * Retry a failed job
-     */
-    MessageQueue.prototype.retryJob = function (jobId) {
-        var job = this.jobs.get(jobId);
-        if (!job) {
-            return false;
-        }
-        if (job.status !== 'failed') {
-            return false;
-        }
-        job.status = 'pending';
-        job.attempts = 0;
-        job.nextRetryAt = undefined;
-        return true;
-    };
-    /**
-     * Delete a job
-     */
-    MessageQueue.prototype.deleteJob = function (jobId) {
-        return this.jobs.delete(jobId);
-    };
-    /**
-     * Clear jobs by status
-     */
-    MessageQueue.prototype.clearByStatus = function (status) {
-        var count = 0;
-        for (var _i = 0, _a = this.jobs.entries(); _i < _a.length; _i++) {
-            var _b = _a[_i], jobId = _b[0], job = _b[1];
-            if (job.status === status) {
-                this.jobs.delete(jobId);
-                count++;
-            }
-        }
-        return count;
-    };
-    /**
-     * Get queue statistics
-     */
-    MessageQueue.prototype.getStats = function () {
-        var jobs = Array.from(this.jobs.values());
-        return {
-            total: jobs.length,
-            pending: jobs.filter(function (j) { return j.status === 'pending'; }).length,
-            processing: jobs.filter(function (j) { return j.status === 'processing'; }).length,
-            completed: jobs.filter(function (j) { return j.status === 'completed'; }).length,
-            failed: jobs.filter(function (j) { return j.status === 'failed'; }).length,
-            retrying: jobs.filter(function (j) { return j.status === 'retrying'; }).length,
-        };
-    };
-    /**
-     * Generate a unique job ID
-     */
-    MessageQueue.prototype.generateJobId = function () {
-        return "job-".concat(Date.now(), "-").concat(Math.random().toString(36).substr(2, 9));
-    };
-    /**
-     * Get configuration
-     */
-    MessageQueue.prototype.getConfig = function () {
-        return __assign({}, this.config);
+    this.configureRateLimiters(this.config.rateLimits);
+  }
+
+  configureRateLimiters(rateLimits = {}) {
+    for (const [queue, rl] of Object.entries(rateLimits)) {
+      if (rl) this.rateLimiters.set(queue, new TokenBucket(rl.maxBurst, rl.maxPerSecond));
+    }
+  }
+
+  registerProcessor(queue, processor) {
+    this.processors.set(queue, processor);
+  }
+
+  async enqueue(queue, data, options = {}) {
+    if (typeof options === "number") options = { maxAttempts: options };
+    const scheduledAt = options.delayMs && options.delayMs > 0 ? new Date(Date.now() + options.delayMs) : undefined;
+    const job = {
+      id: options.jobId || this.generateJobId(),
+      queue,
+      data,
+      status: scheduledAt ? "retrying" : "pending",
+      priority: options.priority || "normal",
+      attempts: 0,
+      maxAttempts: options.maxAttempts || this.config.maxAttempts,
+      createdAt: new Date(),
+      scheduledAt,
+      nextRetryAt: scheduledAt,
+      enqueuedBy: options.enqueuedBy,
+      tags: options.tags,
     };
-    /**
-     * Update configuration
-     */
-    MessageQueue.prototype.updateConfig = function (config) {
-        this.config = __assign(__assign({}, this.config), config);
+    this.jobs.set(job.id, job);
+    this.metrics.totalEnqueued++;
+    this.metrics.priorityDistribution[job.priority]++;
+    return job;
+  }
+
+  getJob(jobId) {
+    return this.jobs.get(jobId);
+  }
+
+  getAllJobs() {
+    return Array.from(this.jobs.values());
+  }
+
+  getJobsByQueue(queue) {
+    return Array.from(this.jobs.values()).filter((job) => job.queue === queue);
+  }
+
+  getJobsByStatus(status) {
+    return Array.from(this.jobs.values()).filter((job) => job.status === status);
+  }
+
+  getJobsByPriority(priority) {
+    return Array.from(this.jobs.values()).filter((job) => job.priority === priority);
+  }
+
+  start() {
+    if (this.isRunning) {
+      console.warn("Queue processor already running");
+      return;
+    }
+    this.isRunning = true;
+    this.processingInterval = setInterval(() => {
+      this.processJobs();
+    }, this.config.pollIntervalMs);
+  }
+
+  stop() {
+    this.isRunning = false;
+    if (this.processingInterval) clearInterval(this.processingInterval);
+  }
+
+  async processJobs() {
+    if (!this.isRunning) return;
+    const now = new Date();
+    const candidates = Array.from(this.jobs.values()).filter((job) =>
+      (job.status === "pending" || (job.status === "retrying" && job.nextRetryAt && job.nextRetryAt <= now)) &&
+      job.attempts < job.maxAttempts
+    );
+    candidates.sort((a, b) => {
+      const priority = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+      return priority !== 0 ? priority : a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    for (const job of candidates.slice(0, this.config.batchSize)) {
+      const limiter = this.rateLimiters.get(job.queue);
+      if (limiter && !limiter.tryConsume(1)) continue;
+      await this.processJob(job);
+    }
+  }
+
+  async processNextBatch() {
+    const wasRunning = this.isRunning;
+    this.isRunning = true;
+    await this.processJobs();
+    this.isRunning = wasRunning;
+  }
+
+  async processJob(job) {
+    const processor = this.processors.get(job.queue);
+    if (!processor) {
+      job.status = "failed";
+      job.lastError = `No processor found for queue: ${job.queue}`;
+      this.metrics.totalFailed++;
+      return;
+    }
+    const startTime = Date.now();
+    try {
+      job.status = "processing";
+      job.attempts += 1;
+      await processor(job);
+      job.status = "completed";
+      job.completedAt = new Date();
+      job.processedAt = new Date();
+      this.metrics.totalCompleted++;
+      this.recordLatency(job.queue, Date.now() - startTime);
+    } catch (error) {
+      job.lastError = error instanceof Error ? error.message : String(error);
+      job.processedAt = new Date();
+      this.recordLatency(job.queue, Date.now() - startTime);
+      if (job.attempts < job.maxAttempts) {
+        const delayMs = this.calculateRetryDelay(job.attempts);
+        job.status = "retrying";
+        job.nextRetryAt = new Date(Date.now() + delayMs);
+        this.metrics.totalRetried++;
+      } else if (this.config.enableDlq) {
+        this.moveToDlq(job);
+      } else {
+        job.status = "failed";
+        this.metrics.totalFailed++;
+      }
+    }
+  }
+
+  calculateRetryDelay(attempt) {
+    const base = this.config.retryDelayMs * Math.pow(this.config.retryBackoffMultiplier, attempt - 1);
+    const capped = Math.min(base, this.config.maxRetryDelayMs);
+    const jitter = capped * 0.1 * (Math.random() * 2 - 1);
+    return Math.max(100, Math.round(capped + jitter));
+  }
+
+  moveToDlq(job) {
+    job.status = "dlq";
+    this.dlq.push({
+      job: { ...job },
+      failedAt: new Date(),
+      failureReason: job.lastError || "Unknown error",
+      originalQueue: job.queue,
+    });
+    this.metrics.totalDlq++;
+    this.pruneDlq();
+  }
+
+  pruneDlq() {
+    const cutoff = Date.now() - this.config.dlqMaxRetentionMs;
+    this.dlq = this.dlq.filter((entry) => entry.failedAt.getTime() > cutoff);
+  }
+
+  recordLatency(queue, durationMs) {
+    if (!this.metrics.perQueueLatency[queue]) this.metrics.perQueueLatency[queue] = { count: 0, totalMs: 0 };
+    const entry = this.metrics.perQueueLatency[queue];
+    entry.count++;
+    entry.totalMs += durationMs;
+    this.metrics.processingTimeSamples++;
+    const total = this.metrics.avgProcessingTimeMs * (this.metrics.processingTimeSamples - 1) + durationMs;
+    this.metrics.avgProcessingTimeMs = total / this.metrics.processingTimeSamples;
+  }
+
+  retryJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job || (job.status !== "failed" && job.status !== "dlq")) return false;
+    job.status = "pending";
+    job.attempts = 0;
+    job.nextRetryAt = undefined;
+    job.scheduledAt = undefined;
+    job.lastError = undefined;
+    return true;
+  }
+
+  replayFromDlq(jobId) {
+    const idx = this.dlq.findIndex((entry) => entry.job.id === jobId);
+    if (idx === -1) return false;
+    const entry = this.dlq[idx];
+    this.dlq.splice(idx, 1);
+    this.jobs.set(jobId, {
+      ...entry.job,
+      status: "pending",
+      attempts: 0,
+      nextRetryAt: undefined,
+      scheduledAt: undefined,
+      lastError: undefined,
+      createdAt: new Date(),
+    });
+    return true;
+  }
+
+  replayAllFromDlq(queue) {
+    let count = 0;
+    for (const entry of [...this.dlq]) {
+      if (queue && entry.originalQueue !== queue) continue;
+      if (this.replayFromDlq(entry.job.id)) count++;
+    }
+    return count;
+  }
+
+  deleteJob(jobId) {
+    return this.jobs.delete(jobId);
+  }
+
+  deleteFromDlq(jobId) {
+    const idx = this.dlq.findIndex((entry) => entry.job.id === jobId);
+    if (idx === -1) return false;
+    this.dlq.splice(idx, 1);
+    return true;
+  }
+
+  clearDlq() {
+    const count = this.dlq.length;
+    this.dlq = [];
+    return count;
+  }
+
+  clearByStatus(status) {
+    let count = 0;
+    for (const [jobId, job] of this.jobs.entries()) {
+      if (job.status === status) {
+        this.jobs.delete(jobId);
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getDlq() {
+    this.pruneDlq();
+    return [...this.dlq];
+  }
+
+  getRateLimitStatus() {
+    const status = {};
+    for (const [queue, limiter] of this.rateLimiters.entries()) {
+      status[queue] = {
+        maxTokens: limiter.remaining + limiter.usage,
+        remaining: limiter.remaining,
+        usage: limiter.usage,
+      };
+    }
+    return status;
+  }
+
+  getStats() {
+    const jobs = Array.from(this.jobs.values());
+    return {
+      total: jobs.length,
+      pending: jobs.filter((job) => job.status === "pending").length,
+      processing: jobs.filter((job) => job.status === "processing").length,
+      completed: jobs.filter((job) => job.status === "completed").length,
+      failed: jobs.filter((job) => job.status === "failed").length,
+      retrying: jobs.filter((job) => job.status === "retrying").length,
+      dlq: jobs.filter((job) => job.status === "dlq").length,
+      priorityBreakdown: {
+        critical: jobs.filter((job) => job.priority === "critical").length,
+        high: jobs.filter((job) => job.priority === "high").length,
+        normal: jobs.filter((job) => job.priority === "normal").length,
+        low: jobs.filter((job) => job.priority === "low").length,
+      },
     };
-    return MessageQueue;
-}());
-// Export singleton instance
+  }
+
+  getMetrics() {
+    return { ...this.metrics };
+  }
+
+  getConfig() {
+    return { ...this.config };
+  }
+
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.rateLimits) this.configureRateLimiters(config.rateLimits);
+  }
+
+  generateJobId() {
+    return `job-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+  }
+}
+
+exports.MessageQueue = MessageQueue;
 exports.messageQueue = new MessageQueue();
diff --git a/backend/src/services/queue.test.ts b/backend/src/services/queue.test.ts
index 92b5098c..bff9649f 100644
--- a/backend/src/services/queue.test.ts
+++ b/backend/src/services/queue.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { messageQueue, QueueJob } from './queue.js';
+import { MessageQueue, QueueJob } from './queue.js';
 import {
+  messageQueue,
   queueEmail,
   queueNotification,
   queueWebhook,
@@ -13,6 +14,15 @@ import {
 describe('Message Queue', () => {
   beforeEach(() => {
     messageQueue.stop();
+    messageQueue.updateConfig({
+      maxAttempts: 3,
+      retryDelayMs: 1000,
+      retryBackoffMultiplier: 2,
+      maxRetryDelayMs: 60 * 1000,
+      pollIntervalMs: 1000,
+      batchSize: 10,
+      enableDlq: true,
+    });
     // Clear all jobs
     const jobs = messageQueue.getAllJobs();
     jobs.forEach((job) => {
@@ -160,7 +170,7 @@ describe('Message Queue', () => {
       const failingProcessor = vi.fn().mockRejectedValue(new Error('Processing failed'));
       messageQueue.registerProcessor('test-queue', failingProcessor);
 
-      const job = await messageQueue.enqueue('test-queue', { test: true }, 3);
+      const job = await messageQueue.enqueue('test-queue', { test: true }, { maxAttempts: 3 });
 
       messageQueue.start();
 
@@ -176,9 +186,9 @@ describe('Message Queue', () => {
     it('should fail after max attempts', async () => {
       const failingProcessor = vi.fn().mockRejectedValue(new Error('Processing failed'));
       messageQueue.registerProcessor('test-queue', failingProcessor);
-      messageQueue.updateConfig({ maxAttempts: 2, retryDelayMs: 100 });
+      messageQueue.updateConfig({ maxAttempts: 2, retryDelayMs: 100, enableDlq: false });
 
-      const job = await messageQueue.enqueue('test-queue', { test: true }, 2);
+      const job = await messageQueue.enqueue('test-queue', { test: true }, { maxAttempts: 2 });
 
       messageQueue.start();
 
@@ -253,6 +263,37 @@ describe('Message Queue', () => {
   });
 
   describe('Job Management', () => {
+    it('processes higher priority jobs first within a batch', async () => {
+      const queue = new MessageQueue({ batchSize: 2 });
+      const processed: string[] = [];
+      queue.registerProcessor('priority-test', async (job) => {
+        processed.push(String((job.data as { label: string }).label));
+      });
+
+      await queue.enqueue('priority-test', { label: 'low' }, { priority: 'low' });
+      await queue.enqueue('priority-test', { label: 'critical' }, { priority: 'critical' });
+
+      await queue.processNextBatch();
+
+      expect(processed).toEqual(['critical', 'low']);
+    });
+
+    it('does not process delayed jobs before their scheduled time', async () => {
+      vi.useFakeTimers();
+      const queue = new MessageQueue({ batchSize: 1 });
+      const processor = vi.fn();
+      queue.registerProcessor('delayed', processor);
+
+      await queue.enqueue('delayed', { ok: true }, { delayMs: 1000 });
+      await queue.processNextBatch();
+      expect(processor).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(1000);
+      await queue.processNextBatch();
+      expect(processor).toHaveBeenCalledOnce();
+      vi.useRealTimers();
+    });
+
     it('should retry a failed job', async () => {
       const job = await messageQueue.enqueue('test-queue', { test: true });
       const updatedJob = messageQueue.getJob(job.id)!;
diff --git a/backend/src/services/queue.ts b/backend/src/services/queue.ts
index 66bd947d..af40e8a7 100644
--- a/backend/src/services/queue.ts
+++ b/backend/src/services/queue.ts
@@ -25,6 +25,7 @@ export interface QueueJob {
   createdAt: Date;
   processedAt?: Date;
   nextRetryAt?: Date;
+  scheduledAt?: Date;
   completedAt?: Date;
   enqueuedBy?: string;
   tags?: string[];
@@ -164,17 +165,25 @@ class MessageQueue {
       priority?: JobPriority;
       enqueuedBy?: string;
       tags?: string[];
+      delayMs?: number;
+      jobId?: string;
     }
   ): Promise<QueueJob> {
+    const scheduledAt = options?.delayMs && options.delayMs > 0
+      ? new Date(Date.now() + options.delayMs)
+      : undefined;
+
     const job: QueueJob = {
-      id: this.generateJobId(),
+      id: options?.jobId ?? this.generateJobId(),
       queue,
       data,
-      status: 'pending',
+      status: scheduledAt ? 'retrying' : 'pending',
       priority: options?.priority ?? 'normal',
       attempts: 0,
       maxAttempts: options?.maxAttempts ?? this.config.maxAttempts,
       createdAt: new Date(),
+      scheduledAt,
+      nextRetryAt: scheduledAt,
       enqueuedBy: options?.enqueuedBy,
       tags: options?.tags,
     };
@@ -207,7 +216,10 @@ class MessageQueue {
   }
 
   start(): void {
-    if (this.isRunning) return;
+    if (this.isRunning) {
+      console.warn('Queue processor already running');
+      return;
+    }
     this.isRunning = true;
     this.processingInterval = setInterval(() => {
       this.processJobs();
@@ -254,12 +266,20 @@ class MessageQueue {
     }
   }
 
+  async processNextBatch(): Promise<void> {
+    const wasRunning = this.isRunning;
+    this.isRunning = true;
+    await this.processJobs();
+    this.isRunning = wasRunning;
+  }
+
   private async processJob(job: QueueJob): Promise<void> {
     const processor = this.processors.get(job.queue);
 
     if (!processor) {
       job.status = 'failed';
       job.lastError = `No processor found for queue: ${job.queue}`;
+      this.metrics.totalFailed++;
       return;
     }
 
@@ -345,6 +365,7 @@ class MessageQueue {
     job.status = 'pending';
     job.attempts = 0;
     job.nextRetryAt = undefined;
+    job.scheduledAt = undefined;
     job.lastError = undefined;
     return true;
   }
@@ -361,6 +382,7 @@ class MessageQueue {
       status: 'pending',
       attempts: 0,
       nextRetryAt: undefined,
+      scheduledAt: undefined,
       lastError: undefined,
       createdAt: new Date(),
     };
@@ -475,4 +497,5 @@ class MessageQueue {
   }
 }
 
-export const messageQueue = new MessageQueue();
\ No newline at end of file
+export const messageQueue = new MessageQueue();
+export { MessageQueue };
diff --git a/backend/src/types/validation.ts b/backend/src/types/validation.ts
new file mode 100644
index 00000000..7e676706
--- /dev/null
+++ b/backend/src/types/validation.ts
@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export type ValidatedBody<T extends z.ZodTypeAny> = z.infer<T>;
+export type ValidatedQuery<T extends z.ZodTypeAny> = z.infer<T>;
+export type ValidatedParams<T extends z.ZodTypeAny> = z.infer<T>;
+
+export interface ValidationErrorDetail {
+  path: string;
+  message: string;
+  code: string;
+}
diff --git a/contracts/src/lib.rs b/contracts/src/lib.rs
index 4727966e..aa2f2a00 100644
--- a/contracts/src/lib.rs
+++ b/contracts/src/lib.rs
@@ -3,18 +3,18 @@
 #[cfg(test)]
 extern crate std;
 
-use soroban_sdk::{contract, contractimpl, contracttype, symbol_short, Address, BytesN, Env, String, Vec};
+use soroban_sdk::{contract, contractimpl, symbol_short, Address, BytesN, Env, String, Vec};
 
 pub mod common;
-pub mod escrow;
 pub mod dispute;
-pub mod multisig;
+pub mod escrow;
 pub mod htlc;
+pub mod multisig;
 pub mod storage;
 
 pub use common::*;
 pub use storage::{
-    ApprovalBitmap, LazyKey, LazyValue, ProjectV2, ProjectStatusV2, StorageKey,
+    ApprovalBitmap, LazyKey, LazyValue, PackedProjectHeader, ProjectStatusV2, ProjectV2, StorageKey,
 };
 
 #[contract]
@@ -104,10 +104,8 @@ impl AgenticPayContract {
         // Acquire lock so pause cannot be called re-entrantly.
         Self::_acquire_lock(&env);
         env.storage().instance().set(&DataKey::Paused, &true);
-        env.events().publish(
-            (symbol_short!("circuit"), symbol_short!("paused")),
-            true,
-        );
+        env.events()
+            .publish((symbol_short!("circuit"), symbol_short!("paused")), true);
         Self::_release_lock(&env);
     }
 
@@ -119,10 +117,8 @@ impl AgenticPayContract {
         // Acquire lock so unpause cannot be called re-entrantly.
         Self::_acquire_lock(&env);
         env.storage().instance().set(&DataKey::Paused, &false);
-        env.events().publish(
-            (symbol_short!("circuit"), symbol_short!("paused")),
-            false,
-        );
+        env.events()
+            .publish((symbol_short!("circuit"), symbol_short!("paused")), false);
         Self::_release_lock(&env);
     }
 
@@ -424,7 +420,9 @@ impl AgenticPayContract {
             timestamp: env.ledger().timestamp(),
         };
 
-        env.storage().persistent().set(&DataKey::Receipt(count), &receipt);
+        env.storage()
+            .persistent()
+            .set(&DataKey::Receipt(count), &receipt);
         env.storage().instance().set(&DataKey::ReceiptCount, &count);
         env.events().publish(
             (symbol_short!("receipt"), symbol_short!("issued")),
@@ -557,10 +555,8 @@ impl AgenticPayContract {
             .persistent()
             .set(&DataKey::Metadata(key.clone()), &value);
 
-        env.events().publish(
-            (symbol_short!("meta"), symbol_short!("set")),
-            (key, value),
-        );
+        env.events()
+            .publish((symbol_short!("meta"), symbol_short!("set")), (key, value));
 
         Self::_release_lock(&env);
     }
@@ -578,12 +574,12 @@ impl AgenticPayContract {
         let stored_admin = Self::get_admin(&env);
         assert!(admin == stored_admin, "Only admin can remove metadata");
 
-        env.storage().persistent().remove(&DataKey::Metadata(key.clone()));
+        env.storage()
+            .persistent()
+            .remove(&DataKey::Metadata(key.clone()));
 
-        env.events().publish(
-            (symbol_short!("meta"), symbol_short!("del")),
-            key,
-        );
+        env.events()
+            .publish((symbol_short!("meta"), symbol_short!("del")), key);
 
         Self::_release_lock(&env);
     }
@@ -648,20 +644,22 @@ impl AgenticPayContract {
                     freelancer: old.freelancer,
                     amount: old.amount,
                     deposited: old.deposited,
-                    status: match old.status {
-                        crate::ProjectStatus::Created => ProjectStatusV2::Created,
-                        crate::ProjectStatus::Funded => ProjectStatusV2::Funded,
-                        crate::ProjectStatus::InProgress => ProjectStatusV2::InProgress,
-                        crate::ProjectStatus::WorkSubmitted => ProjectStatusV2::WorkSubmitted,
-                        crate::ProjectStatus::Verified => ProjectStatusV2::Verified,
-                        crate::ProjectStatus::Completed => ProjectStatusV2::Completed,
-                        crate::ProjectStatus::Disputed => ProjectStatusV2::Disputed,
-                        crate::ProjectStatus::Cancelled => ProjectStatusV2::Cancelled,
-                    },
+                    header: PackedProjectHeader::new(
+                        match old.status {
+                            crate::ProjectStatus::Created => ProjectStatusV2::Created,
+                            crate::ProjectStatus::Funded => ProjectStatusV2::Funded,
+                            crate::ProjectStatus::InProgress => ProjectStatusV2::InProgress,
+                            crate::ProjectStatus::WorkSubmitted => ProjectStatusV2::WorkSubmitted,
+                            crate::ProjectStatus::Verified => ProjectStatusV2::Verified,
+                            crate::ProjectStatus::Completed => ProjectStatusV2::Completed,
+                            crate::ProjectStatus::Disputed => ProjectStatusV2::Disputed,
+                            crate::ProjectStatus::Cancelled => ProjectStatusV2::Cancelled,
+                        },
+                        old.created_at,
+                        old.deadline,
+                    ),
                     github_repo: old.github_repo,
                     description: old.description,
-                    created_at: old.created_at,
-                    deadline: old.deadline,
                 };
 
                 env.storage()
@@ -713,12 +711,7 @@ impl AgenticPayContract {
     /// Requires the caller to already be a signer (one-of-N consensus is
     /// enforced off-chain via the proposal flow; this entry-point is for
     /// direct admin-level additions authorized by the wallet creator).
-    pub fn add_multisig_signer(
-        env: Env,
-        authorizer: Address,
-        wallet_id: u64,
-        new_signer: Address,
-    ) {
+    pub fn add_multisig_signer(env: Env, authorizer: Address, wallet_id: u64, new_signer: Address) {
         multisig::add_signer(&env, authorizer, wallet_id, new_signer)
     }
 
@@ -845,7 +838,6 @@ impl AgenticPayContract {
     pub fn get_bridge_config(env: Env) -> BridgeConfigData {
         htlc::get_bridge_config(&env)
     }
-
 }
 
 // Bring in the property-based security tests (proptest suite).
diff --git a/contracts/src/storage.rs b/contracts/src/storage.rs
index c979ee53..57756503 100644
--- a/contracts/src/storage.rs
+++ b/contracts/src/storage.rs
@@ -1,4 +1,4 @@
-use soroban_sdk::{contracttype, Address, BytesN, Env, String, Vec};
+use soroban_sdk::{contracttype, Address, Env, String};
 
 // ---------------------------------------------------------------------------
 // Gas-optimized storage utilities for AgenticPay contracts.
@@ -29,12 +29,19 @@ pub enum LazyKey {
     Paused,
 }
 
-pub struct LazyValue<T: soroban_sdk::IntoVal<Env, soroban_sdk::Val> + soroban_sdk::TryFromVal<Env, soroban_sdk::Val>> {
+pub struct LazyValue<
+    T: soroban_sdk::IntoVal<Env, soroban_sdk::Val> + soroban_sdk::TryFromVal<Env, soroban_sdk::Val>,
+> {
     key: LazyKey,
     default: T,
 }
 
-impl<T: soroban_sdk::IntoVal<Env, soroban_sdk::Val> + soroban_sdk::TryFromVal<Env, soroban_sdk::Val> + Clone> LazyValue<T> {
+impl<
+        T: soroban_sdk::IntoVal<Env, soroban_sdk::Val>
+            + soroban_sdk::TryFromVal<Env, soroban_sdk::Val>
+            + Clone,
+    > LazyValue<T>
+{
     pub fn new(key: LazyKey, default: T) -> Self {
         LazyValue { key, default }
     }
@@ -78,16 +85,23 @@ pub struct ApprovalBitmap {
 
 impl ApprovalBitmap {
     pub fn new() -> Self {
-        ApprovalBitmap { approvals: 0, rejections: 0 }
+        ApprovalBitmap {
+            approvals: 0,
+            rejections: 0,
+        }
     }
 
     pub fn has_approved(&self, signer_index: u32) -> bool {
-        if signer_index >= 128 { return false; }
+        if signer_index >= 128 {
+            return false;
+        }
         (self.approvals >> signer_index) & 1 == 1
     }
 
     pub fn has_rejected(&self, signer_index: u32) -> bool {
-        if signer_index >= 128 { return false; }
+        if signer_index >= 128 {
+            return false;
+        }
         (self.rejections >> signer_index) & 1 == 1
     }
 
@@ -137,14 +151,79 @@ pub struct ProjectV2 {
     pub freelancer: Address,
     pub amount: i128,
     pub deposited: i128,
-    pub status: ProjectStatusV2,
+    pub header: PackedProjectHeader,
     pub github_repo: String,
     pub description: String,
+}
+
+const PROJECT_FLAG_HAS_DEADLINE: u32 = 1;
+
+#[contracttype]
+#[derive(Clone, Debug, PartialEq)]
+pub struct PackedProjectHeader {
+    pub status: u32,
+    pub flags: u32,
     pub created_at: u64,
-    /// Unix timestamp deadline. 0 means no deadline.
     pub deadline: u64,
 }
 
+impl PackedProjectHeader {
+    pub fn new(status: ProjectStatusV2, created_at: u64, deadline: u64) -> Self {
+        let flags = if deadline > 0 {
+            PROJECT_FLAG_HAS_DEADLINE
+        } else {
+            0
+        };
+        Self {
+            status: status.to_u32(),
+            flags,
+            created_at,
+            deadline,
+        }
+    }
+
+    pub fn status(&self) -> ProjectStatusV2 {
+        ProjectStatusV2::from_u32(self.status)
+    }
+
+    pub fn set_status(&mut self, status: ProjectStatusV2) {
+        self.status = status.to_u32();
+    }
+
+    pub fn has_deadline(&self) -> bool {
+        self.flags & PROJECT_FLAG_HAS_DEADLINE != 0
+    }
+}
+
+impl ProjectStatusV2 {
+    pub fn to_u32(&self) -> u32 {
+        match self {
+            ProjectStatusV2::Created => 0,
+            ProjectStatusV2::Funded => 1,
+            ProjectStatusV2::InProgress => 2,
+            ProjectStatusV2::WorkSubmitted => 3,
+            ProjectStatusV2::Verified => 4,
+            ProjectStatusV2::Completed => 5,
+            ProjectStatusV2::Disputed => 6,
+            ProjectStatusV2::Cancelled => 7,
+        }
+    }
+
+    pub fn from_u32(value: u32) -> Self {
+        match value {
+            0 => ProjectStatusV2::Created,
+            1 => ProjectStatusV2::Funded,
+            2 => ProjectStatusV2::InProgress,
+            3 => ProjectStatusV2::WorkSubmitted,
+            4 => ProjectStatusV2::Verified,
+            5 => ProjectStatusV2::Completed,
+            6 => ProjectStatusV2::Disputed,
+            7 => ProjectStatusV2::Cancelled,
+            _ => panic!("Invalid project status"),
+        }
+    }
+}
+
 // ── Gas-optimised storage key layout ────────────────────────────────────────
 // Uses a flat enum to minimise XDR key size. Counter keys share a single
 // storage slot with their entity keys to reduce the total number of
@@ -169,9 +248,9 @@ pub enum StorageKey {
     Receipt(u64),
     Wallet(u64),
     Proposal(u64),
-    ApprovalBitmap(u64),   // proposal_id → bitmap (instead of Vec in Proposal)
+    ApprovalBitmap(u64), // proposal_id → bitmap (instead of Vec in Proposal)
     HtlcLock(u64),
-    Signer(u64, u32),      // (wallet_id, index) → Address
+    Signer(u64, u32), // (wallet_id, index) → Address
     Metadata(String),
 }
 
@@ -196,24 +275,30 @@ pub mod migration {
             freelancer: old.freelancer,
             amount: old.amount,
             deposited: old.deposited,
-            status: match old.status {
-                crate::ProjectStatus::Created => ProjectStatusV2::Created,
-                crate::ProjectStatus::Funded => ProjectStatusV2::Funded,
-                crate::ProjectStatus::InProgress => ProjectStatusV2::InProgress,
-                crate::ProjectStatus::WorkSubmitted => ProjectStatusV2::WorkSubmitted,
-                crate::ProjectStatus::Verified => ProjectStatusV2::Verified,
-                crate::ProjectStatus::Completed => ProjectStatusV2::Completed,
-                crate::ProjectStatus::Disputed => ProjectStatusV2::Disputed,
-                crate::ProjectStatus::Cancelled => ProjectStatusV2::Cancelled,
-            },
+            header: PackedProjectHeader::new(
+                match old.status {
+                    crate::ProjectStatus::Created => ProjectStatusV2::Created,
+                    crate::ProjectStatus::Funded => ProjectStatusV2::Funded,
+                    crate::ProjectStatus::InProgress => ProjectStatusV2::InProgress,
+                    crate::ProjectStatus::WorkSubmitted => ProjectStatusV2::WorkSubmitted,
+                    crate::ProjectStatus::Verified => ProjectStatusV2::Verified,
+                    crate::ProjectStatus::Completed => ProjectStatusV2::Completed,
+                    crate::ProjectStatus::Disputed => ProjectStatusV2::Disputed,
+                    crate::ProjectStatus::Cancelled => ProjectStatusV2::Cancelled,
+                },
+                old.created_at,
+                old.deadline,
+            ),
             github_repo: old.github_repo,
             description: old.description,
-            created_at: old.created_at,
-            deadline: old.deadline,
         };
 
-        env.storage().persistent().set(&StorageKey::Project(project_id), &new);
-        env.storage().persistent().remove(&DataKey::Project(project_id));
+        env.storage()
+            .persistent()
+            .set(&StorageKey::Project(project_id), &new);
+        env.storage()
+            .persistent()
+            .remove(&DataKey::Project(project_id));
     }
 
     pub fn migrate_all(env: &Env, count: u64) {
@@ -258,4 +343,17 @@ pub mod migration {
         assert_eq!(bitmap.has_rejected(2), true);
         assert_eq!(bitmap.has_rejected(0), false);
     }
-}
\ No newline at end of file
+
+    #[test]
+    fn test_packed_project_header_round_trip() {
+        let mut header = PackedProjectHeader::new(ProjectStatusV2::Created, 123, 456);
+
+        assert_eq!(header.status(), ProjectStatusV2::Created);
+        assert_eq!(header.created_at, 123);
+        assert_eq!(header.deadline, 456);
+        assert_eq!(header.has_deadline(), true);
+
+        header.set_status(ProjectStatusV2::Completed);
+        assert_eq!(header.status(), ProjectStatusV2::Completed);
+    }
+}
diff --git a/docs/gas-optimization-guide.md b/docs/gas-optimization-guide.md
index ce9b06a6..ab4360eb 100644
--- a/docs/gas-optimization-guide.md
+++ b/docs/gas-optimization-guide.md
@@ -46,6 +46,16 @@ State variables arranged to minimize slot usage:
 - `uint16` for basis points (never exceeds 10,000)
 - `bool` for flags (packed with adjacent variables)
 - `uint256` for timestamps (avoids unnecessary casting)
+- Soroban project metadata packs `status`, flags, `created_at`, and `deadline`
+  into `PackedProjectHeader`. The public `Project` compatibility type remains
+  unchanged, while migrated `ProjectV2` records store small metadata together
+  and keep larger strings at the end of the XDR payload.
+
+**Example - Soroban ProjectV2:**
+```rust
+let header = PackedProjectHeader::new(ProjectStatusV2::Created, created_at, deadline);
+assert!(header.has_deadline());
+```
 
 ### 5. Storage Pointer (Reference) Usage
 
diff --git a/infra/main.tf b/infra/main.tf
index b6f8c383..629622e0 100644
--- a/infra/main.tf
+++ b/infra/main.tf
@@ -411,6 +411,43 @@ resource "aws_cloudfront_origin_access_control" "default" {
   signing_protocol                  = "sigv4"
 }
 
+resource "aws_cloudfront_response_headers_policy" "static_assets" {
+  name    = "agenticpay-${var.environment}-static-assets-headers"
+  comment = "Long-lived static asset caching and safe cross-origin loading"
+
+  cors_config {
+    access_control_allow_credentials = false
+
+    access_control_allow_headers {
+      items = ["*"]
+    }
+
+    access_control_allow_methods {
+      items = ["GET", "HEAD", "OPTIONS"]
+    }
+
+    access_control_allow_origins {
+      items = ["*"]
+    }
+
+    origin_override = true
+  }
+
+  custom_headers_config {
+    items {
+      header   = "X-CDN"
+      value    = "cloudfront"
+      override = true
+    }
+  }
+
+  security_headers_config {
+    content_type_options {
+      override = true
+    }
+  }
+}
+
 # Frontend CloudFront distribution with HTTP/3 support
 resource "aws_cloudfront_distribution" "frontend" {
   enabled         = true
@@ -450,6 +487,66 @@ resource "aws_cloudfront_distribution" "frontend" {
     max_ttl                = 86400
   }
 
+  ordered_cache_behavior {
+    path_pattern               = "/_next/static/*"
+    allowed_methods            = ["GET", "HEAD", "OPTIONS"]
+    cached_methods             = ["GET", "HEAD", "OPTIONS"]
+    target_origin_id           = "amplify-frontend"
+    compress                   = true
+    viewer_protocol_policy     = "redirect-to-https"
+    min_ttl                    = 86400
+    default_ttl                = 31536000
+    max_ttl                    = 31536000
+    response_headers_policy_id = aws_cloudfront_response_headers_policy.static_assets.id
+
+    forwarded_values {
+      query_string = false
+      cookies {
+        forward = "none"
+      }
+    }
+  }
+
+  ordered_cache_behavior {
+    path_pattern               = "/images/*"
+    allowed_methods            = ["GET", "HEAD", "OPTIONS"]
+    cached_methods             = ["GET", "HEAD", "OPTIONS"]
+    target_origin_id           = "amplify-frontend"
+    compress                   = true
+    viewer_protocol_policy     = "redirect-to-https"
+    min_ttl                    = 3600
+    default_ttl                = 604800
+    max_ttl                    = 31536000
+    response_headers_policy_id = aws_cloudfront_response_headers_policy.static_assets.id
+
+    forwarded_values {
+      query_string = false
+      cookies {
+        forward = "none"
+      }
+    }
+  }
+
+  ordered_cache_behavior {
+    path_pattern               = "/fonts/*"
+    allowed_methods            = ["GET", "HEAD", "OPTIONS"]
+    cached_methods             = ["GET", "HEAD", "OPTIONS"]
+    target_origin_id           = "amplify-frontend"
+    compress                   = true
+    viewer_protocol_policy     = "redirect-to-https"
+    min_ttl                    = 86400
+    default_ttl                = 31536000
+    max_ttl                    = 31536000
+    response_headers_policy_id = aws_cloudfront_response_headers_policy.static_assets.id
+
+    forwarded_values {
+      query_string = false
+      cookies {
+        forward = "none"
+      }
+    }
+  }
+
   restrictions {
     geo_restriction {
       restriction_type = "none"
diff --git a/workers/src/index.ts b/workers/src/index.ts
index a835a448..e48c96ff 100644
--- a/workers/src/index.ts
+++ b/workers/src/index.ts
@@ -219,6 +219,22 @@ function getContentType(path: string): string {
   return 'application/octet-stream';
 }
 
+function getStaticAssetRule(path: string) {
+  return STATIC_ASSET_PATTERNS.find((rule) => rule.pattern.test(path));
+}
+
+function staticAssetHeaders(path: string, ttl: number, immutable: boolean, cacheStatus: 'HIT' | 'MISS') {
+  const cacheControl = immutable ? CACHE_CONTROL.staticImmutable : `public, max-age=${ttl}, s-maxage=${ttl}`;
+
+  return {
+    'Content-Type': getContentType(path),
+    'Cache-Control': cacheControl,
+    'X-Cache': cacheStatus,
+    'X-CDN': 'cloudflare',
+    'Access-Control-Allow-Origin': '*',
+  };
+}
+
 // ── Main request handler ──────────────────────────────────────────────────────
 
 async function handleRequest(request: Request, env: Env): Promise<Response> {
@@ -250,24 +266,32 @@ async function handleRequest(request: Request, env: Env): Promise<Response> {
   // Serve immutable assets (Next.js build output, fonts, images) with long
   // cache lifetimes at the edge. Bypasses backend entirely for cached assets.
   if (method === 'GET') {
-    for (const rule of STATIC_ASSET_PATTERNS) {
-      if (rule.pattern.test(path)) {
-        const cacheKey = `static:${path}`;
-        const cached = await cacheGet(cacheKey, env);
-        if (cached) {
-          const cc = rule.immutable ? CACHE_CONTROL.staticImmutable : `public, max-age=${rule.ttl}, s-maxage=${rule.ttl}`;
-          return new Response(cached, {
-            status: 200,
-            headers: {
-              'Content-Type': getContentType(path),
-              'Cache-Control': cc,
-              'X-Cache': 'HIT',
-              'X-CDN': 'cloudflare',
-              'Access-Control-Allow-Origin': '*',
-            },
-          });
-        }
-        break;
+    const rule = getStaticAssetRule(path);
+    if (rule) {
+      const cacheKey = `static:${path}`;
+      const cached = await cacheGet(cacheKey, env);
+      if (cached) {
+        return new Response(cached, {
+          status: 200,
+          headers: staticAssetHeaders(path, rule.ttl, rule.immutable, 'HIT'),
+        });
+      }
+
+      const originResponse = await fetch(`${env.API_BASE_URL}${path}${url.search}`, {
+        headers: {
+          'Accept': request.headers.get('accept') ?? '*/*',
+          'Accept-Encoding': request.headers.get('accept-encoding') ?? 'br, gzip',
+          'X-Route-Key': 'static-asset',
+        },
+      });
+
+      if (originResponse.ok) {
+        const body = await originResponse.text();
+        await cacheSet(cacheKey, body, rule.ttl, env);
+        return new Response(body, {
+          status: originResponse.status,
+          headers: staticAssetHeaders(path, rule.ttl, rule.immutable, 'MISS'),
+        });
       }
     }
   }