@p2pdotme/sdk 1.0.5 → 1.1.1

package/dist/react.cjs

@@ -33,10 +33,11 @@ __export(react_exports, {
   SdkProvider: () => SdkProvider,
   useFingerprint: () => useFingerprint,
   useFraudEngine: () => useFraudEngine,
-  useOrderRouter: () => useOrderRouter,
-  usePayloadGenerator: () => usePayloadGenerator,
+  useOrders: () => useOrders,
+  usePrices: () => usePrices,
   useProfile: () => useProfile,
   useSdk: () => useSdk,
+  useWatchOrders: () => useWatchOrders,
   useZkkyc: () => useZkkyc
 });
 module.exports = __toCommonJS(react_exports);
@@ -45,7 +46,7 @@ module.exports = __toCommonJS(react_exports);
 var import_react = require("react");
 
 // src/fraud-engine/client.ts
-var import_neverthrow3 = require("neverthrow");
+var import_neverthrow4 = require("neverthrow");
 
 // src/lib/encoding.ts
 function hexToBytes(hex) {
@@ -78,48 +79,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/fraud-engine/device.ts
-function getBasicDeviceDetails() {
-  const nav = typeof navigator !== "undefined" ? navigator : void 0;
-  const win = typeof window !== "undefined" ? window : void 0;
-  return {
-    userAgent: nav?.userAgent ?? "",
-    platform: nav?.platform ?? "",
-    language: nav?.language ?? "",
-    languages: nav ? Array.from(nav.languages) : [],
-    screenWidth: win?.screen?.width ?? 0,
-    screenHeight: win?.screen?.height ?? 0,
-    devicePixelRatio: win?.devicePixelRatio ?? 1,
-    timezone: Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.timeZone ?? "",
-    timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
-    cookiesEnabled: nav?.cookieEnabled ?? false,
-    doNotTrack: nav?.doNotTrack ?? null,
-    online: nav?.onLine ?? true,
-    connectionType: nav?.connection?.effectiveType,
-    deviceMemory: nav?.deviceMemory,
-    hardwareConcurrency: nav?.hardwareConcurrency,
-    touchSupport: nav ? "ontouchstart" in window : false,
-    maxTouchPoints: nav?.maxTouchPoints ?? 0,
-    vendor: nav?.vendor ?? "",
-    appVersion: nav?.appVersion ?? "",
-    colorDepth: win?.screen?.colorDepth ?? 0,
-    pixelDepth: win?.screen?.pixelDepth ?? 0
-  };
-}
-async function fetchIpAddress() {
-  try {
-    const response = await fetch("https://api.ipify.org?format=json");
-    const data = await response.json();
-    return data.ip;
-  } catch {
-    return void 0;
-  }
-}
-async function getDeviceDetails(seonSession) {
-  const basic = getBasicDeviceDetails();
-  const ip = await fetchIpAddress();
-  return { ...basic, ip, seonSession };
-}
+// src/lib/subgraph.ts
+var import_neverthrow2 = require("neverthrow");
 
 // src/validation/errors.validation.ts
 var SdkError = class extends Error {
@@ -140,7 +101,7 @@ var import_neverthrow = require("neverthrow");
 var import_viem = require("viem");
 var import_zod = require("zod");
 
-// src/constants/currencies.constant.ts
+// src/country/currency.ts
 var CURRENCY = {
   IDR: "IDR",
   INR: "INR",
@@ -153,17 +114,11 @@ var CURRENCY = {
   USD: "USD",
   COP: "COP"
 };
-
-// src/constants/orders.constant.ts
-var ORDER_TYPE = {
-  BUY: 0,
-  SELL: 1,
-  PAY: 2
-};
+var CURRENCY_CODES = Object.values(CURRENCY);
 
 // src/validation/schemas.validation.ts
 var ZodAddressSchema = import_zod.z.string().refine((s) => (0, import_viem.isAddress)(s), { message: "Invalid Ethereum address" });
-var ZodCurrencySchema = import_zod.z.enum(Object.values(CURRENCY));
+var ZodCurrencySchema = import_zod.z.enum(CURRENCY_CODES);
 function validate(schema, data, toError) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -172,6 +127,132 @@ function validate(schema, data, toError) {
   return (0, import_neverthrow.err)(toError(import_zod.z.prettifyError(result.error), result.error, data));
 }
 
+// src/lib/subgraph.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_RETRIES = 3;
+var BACKOFF_MS = 500;
+var SubgraphError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SubgraphError";
+  }
+};
+function isTransient(error) {
+  if (error instanceof SubgraphError) {
+    if (error.code !== "HTTP_ERROR") return false;
+    const status = error.context?.status;
+    return typeof status === "number" && status >= 500;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") return true;
+  if (error instanceof TypeError) return true;
+  return false;
+}
+function querySubgraph(url, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchOnce = async () => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: params.query,
+          variables: params.variables
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new SubgraphError(`Subgraph request failed (status: ${response.status})`, {
+          code: "HTTP_ERROR",
+          cause: response,
+          context: { status: response.status }
+        });
+      }
+      const json = await response.json();
+      if (json.errors?.length > 0) {
+        throw new SubgraphError("Subgraph returned GraphQL errors", {
+          code: "GRAPHQL_ERROR",
+          cause: json.errors,
+          context: { errors: json.errors }
+        });
+      }
+      if (!json.data) {
+        throw new SubgraphError("Subgraph returned no data", {
+          code: "NO_DATA",
+          cause: "Missing data field in GraphQL response",
+          context: { response: json }
+        });
+      }
+      return json.data;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const fetchWithRetry = async () => {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        return await fetchOnce();
+      } catch (error) {
+        const lastAttempt = attempt === MAX_RETRIES;
+        if (lastAttempt || !isTransient(error)) throw error;
+        await sleep(BACKOFF_MS * (attempt + 1));
+      }
+    }
+    throw new SubgraphError("Subgraph query exhausted retries", { code: "TRANSPORT_ERROR" });
+  };
+  return import_neverthrow2.ResultAsync.fromPromise(
+    fetchWithRetry(),
+    (error) => error instanceof SubgraphError ? error : new SubgraphError("Subgraph query failed", {
+      code: "TRANSPORT_ERROR",
+      cause: error
+    })
+  );
+}
+
+// src/fraud-engine/device.ts
+function getBasicDeviceDetails() {
+  const nav = typeof navigator !== "undefined" ? navigator : void 0;
+  const win = typeof window !== "undefined" ? window : void 0;
+  return {
+    userAgent: nav?.userAgent ?? "",
+    platform: nav?.platform ?? "",
+    language: nav?.language ?? "",
+    languages: nav ? Array.from(nav.languages) : [],
+    screenWidth: win?.screen?.width ?? 0,
+    screenHeight: win?.screen?.height ?? 0,
+    devicePixelRatio: win?.devicePixelRatio ?? 1,
+    timezone: Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.timeZone ?? "",
+    timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    cookiesEnabled: nav?.cookieEnabled ?? false,
+    doNotTrack: nav?.doNotTrack ?? null,
+    online: nav?.onLine ?? true,
+    connectionType: nav?.connection?.effectiveType,
+    deviceMemory: nav?.deviceMemory,
+    hardwareConcurrency: nav?.hardwareConcurrency,
+    touchSupport: nav ? "ontouchstart" in window : false,
+    maxTouchPoints: nav?.maxTouchPoints ?? 0,
+    vendor: nav?.vendor ?? "",
+    appVersion: nav?.appVersion ?? "",
+    colorDepth: win?.screen?.colorDepth ?? 0,
+    pixelDepth: win?.screen?.pixelDepth ?? 0
+  };
+}
+async function fetchIpAddress() {
+  try {
+    const response = await fetch("https://api.ipify.org?format=json");
+    const data = await response.json();
+    return data.ip;
+  } catch {
+    return void 0;
+  }
+}
+async function getDeviceDetails(seonSession) {
+  const basic = getBasicDeviceDetails();
+  const ip = await fetchIpAddress();
+  return { ...basic, ip, seonSession };
+}
+
 // src/fraud-engine/errors.ts
 var FraudEngineError = class extends SdkError {
   constructor(message, options) {
@@ -302,7 +383,7 @@ async function getSignedHeaders(signer, action) {
 }
 
 // src/fraud-engine/validation.ts
-var import_neverthrow2 = require("neverthrow");
+var import_neverthrow3 = require("neverthrow");
 var import_zod2 = require("zod");
 var ZodFraudEngineConfigSchema = import_zod2.z.object({
   apiUrl: import_zod2.z.url(),
@@ -334,9 +415,9 @@ var ZodLinkOrderParamsSchema = import_zod2.z.object({
 function validate2(schema, data) {
   const result = schema.safeParse(data);
   if (result.success) {
-    return (0, import_neverthrow2.ok)(result.data);
+    return (0, import_neverthrow3.ok)(result.data);
   }
-  return (0, import_neverthrow2.err)(
+  return (0, import_neverthrow3.err)(
     new FraudEngineError(import_zod2.z.prettifyError(result.error), {
       code: "VALIDATION_ERROR",
       cause: result.error,
@@ -363,7 +444,7 @@ function createFraudEngine(config) {
     );
   }
   function linkOrderInternal(signer, activityLogId, orderId) {
-    return import_neverthrow3.ResultAsync.fromPromise(
+    return import_neverthrow4.ResultAsync.fromPromise(
       (async () => {
         logger.info("Linking order to activity log", { activityLogId, orderId });
         const signedHeaders = await getSignedHeaders(signer, "link-order");
@@ -480,8 +561,8 @@ function createFraudEngine(config) {
       logger.info("Fraud engine initialized");
     },
     checkBuyOrder(params) {
-      if (configError) return (0, import_neverthrow3.errAsync)(configError);
-      return import_neverthrow3.ResultAsync.fromPromise(
+      if (configError) return (0, import_neverthrow4.errAsync)(configError);
+      return import_neverthrow4.ResultAsync.fromPromise(
         checkBuyOrderInternal(params).then((data) => ({
           approved: data.approved,
           activityLogId: data.activity_log_id,
@@ -498,8 +579,8 @@ function createFraudEngine(config) {
       );
     },
     processBuyOrder(params) {
-      if (configError) return (0, import_neverthrow3.errAsync)(configError);
-      return import_neverthrow3.ResultAsync.fromPromise(
+      if (configError) return (0, import_neverthrow4.errAsync)(configError);
+      return import_neverthrow4.ResultAsync.fromPromise(
         (async () => {
           let activityLogId = null;
           try {
@@ -543,8 +624,8 @@ function createFraudEngine(config) {
       );
     },
     logFingerprint(params) {
-      if (configError) return (0, import_neverthrow3.errAsync)(configError);
-      return import_neverthrow3.ResultAsync.fromPromise(
+      if (configError) return (0, import_neverthrow4.errAsync)(configError);
+      return import_neverthrow4.ResultAsync.fromPromise(
         (async () => {
           logger.info("Logging fingerprint");
           const fingerprintResult = await getFingerprint(5e3);
@@ -603,8 +684,12 @@ function createFraudEngine(config) {
   };
 }
 
-// src/order-routing/client.ts
-var import_viem6 = require("viem");
+// src/orders/client.ts
+var import_neverthrow17 = require("neverthrow");
+
+// src/contracts/order-processor/index.ts
+var import_neverthrow5 = require("neverthrow");
+var import_viem3 = require("viem");
 
 // src/contracts/abis/index.ts
 var import_viem2 = require("viem");
@@ -639,67 +724,442 @@ var orderFlowFacetAbi = [
     ],
     stateMutability: "view",
     type: "function"
-  }
-];
-
-// src/contracts/abis/p2p-config-facet.ts
-var p2pConfigFacetAbi = [
+  },
   {
     inputs: [
-      {
-        internalType: "bytes32",
-        name: "_currency",
-        type: "bytes32"
-      }
+      { internalType: "string", name: "_pubKey", type: "string" },
+      { internalType: "uint256", name: "_amount", type: "uint256" },
+      { internalType: "address", name: "_recipientAddr", type: "address" },
+      { internalType: "uint8", name: "_orderType", type: "uint8" },
+      { internalType: "string", name: "_userUpi", type: "string" },
+      { internalType: "string", name: "_userPubKey", type: "string" },
+      { internalType: "bytes32", name: "_currency", type: "bytes32" },
+      { internalType: "uint256", name: "preferredPaymentChannelConfigId", type: "uint256" },
+      { internalType: "uint256", name: "_circleId", type: "uint256" },
+      { internalType: "uint256", name: "_fiatAmountLimit", type: "uint256" }
     ],
-    name: "getPriceConfig",
-    outputs: [
+    name: "placeOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_orderId", type: "uint256" }],
+    name: "cancelOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "_orderId", type: "uint256" },
+      { internalType: "string", name: "_userEncUpi", type: "string" },
+      { internalType: "uint256", name: "_updatedAmount", type: "uint256" }
+    ],
+    name: "setSellOrderUpi",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    type: "event",
+    name: "OrderPlaced",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      { indexed: true, name: "merchant", type: "address" },
+      { indexed: false, name: "amount", type: "uint256" },
+      { indexed: false, name: "orderType", type: "uint8" },
+      { indexed: false, name: "placedTimestamp", type: "uint256" },
       {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
         components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
           {
-            internalType: "uint256",
-            name: "buyPrice",
-            type: "uint256"
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
           },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "OrderAccepted",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "merchant", type: "address" },
+      { indexed: false, name: "pubKey", type: "string" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
           {
-            internalType: "uint256",
-            name: "sellPrice",
-            type: "uint256"
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
           },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "BuyOrderPaid",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
           {
-            internalType: "int256",
-            name: "buyPriceOffset",
-            type: "int256"
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
           },
-          {
-            internalType: "uint256",
-            name: "baseSpread",
-            type: "uint256"
-          }
-        ],
-        internalType: "struct P2pConfigStorage.PriceConfig",
-        name: "",
-        type: "tuple"
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
       }
-    ],
-    stateMutability: "view",
-    type: "function"
+    ]
   },
   {
+    type: "event",
+    name: "OrderCompleted",
+    anonymous: false,
     inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      { indexed: false, name: "completedTimestamp", type: "uint256" },
       {
-        internalType: "bytes32",
-        name: "_nativeCurrency",
-        type: "bytes32"
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
       }
-    ],
-    name: "getRpPerUsdtLimitRational",
-    outputs: [
+    ]
+  },
+  {
+    type: "event",
+    name: "CancelledOrders",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
       {
-        internalType: "uint256",
-        name: "numerator",
-        type: "uint256"
-      },
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  }
+];
+
+// src/contracts/abis/order-processor-facet.ts
+var orderProcessorFacetAbi = [
+  {
+    type: "function",
+    name: "getOrdersById",
+    stateMutability: "view",
+    inputs: [{ name: "orderId", type: "uint256" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getAdditionalOrderDetails",
+    stateMutability: "view",
+    inputs: [{ name: "orderId", type: "uint256" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "fixedFeePaid", type: "uint64" },
+          { name: "tipsPaid", type: "uint64" },
+          { name: "acceptedTimestamp", type: "uint128" },
+          { name: "paidTimestamp", type: "uint128" },
+          { name: "reserved2", type: "uint128" },
+          { name: "actualUsdtAmount", type: "uint256" },
+          { name: "actualFiatAmount", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getSmallOrderThreshold",
+    stateMutability: "view",
+    inputs: [{ name: "currency", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "getSmallOrderFixedFee",
+    stateMutability: "view",
+    inputs: [{ name: "currency", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "raiseDispute",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_orderId", type: "uint256" },
+      { name: "redactTransId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "paidBuyOrder",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "_orderId", type: "uint256" }],
+    outputs: []
+  }
+];
+
+// src/contracts/abis/p2p-config-facet.ts
+var p2pConfigFacetAbi = [
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_currency",
+        type: "bytes32"
+      }
+    ],
+    name: "getPriceConfig",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "buyPrice",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "sellPrice",
+            type: "uint256"
+          },
+          {
+            internalType: "int256",
+            name: "buyPriceOffset",
+            type: "int256"
+          },
+          {
+            internalType: "uint256",
+            name: "baseSpread",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct P2pConfigStorage.PriceConfig",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_nativeCurrency",
+        type: "bytes32"
+      }
+    ],
+    name: "getRpPerUsdtLimitRational",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "numerator",
+        type: "uint256"
+      },
       {
         internalType: "uint256",
         name: "denominator",
@@ -914,11 +1374,16 @@ var reputationManagerAbi = [
 ];
 
 // src/contracts/abis/index.ts
-var DIAMOND_ABI = [...orderFlowFacetAbi, ...p2pConfigFacetAbi];
+var DIAMOND_ABI = [
+  ...orderFlowFacetAbi,
+  ...orderProcessorFacetAbi,
+  ...p2pConfigFacetAbi
+];
 var ABIS = {
   DIAMOND: DIAMOND_ABI,
   FACETS: {
     ORDER_FLOW: orderFlowFacetAbi,
+    ORDER_PROCESSOR: orderProcessorFacetAbi,
     CONFIG: p2pConfigFacetAbi
   },
   EXTERNAL: {
@@ -927,817 +1392,663 @@ var ABIS = {
   }
 };
 
-// src/contracts/order-flow/index.ts
-var import_neverthrow4 = require("neverthrow");
+// src/contracts/order-processor/index.ts
+function readOrderMulticall(publicClient, diamondAddress, orderId) {
+  const calls = [
+    {
+      address: diamondAddress,
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "getOrdersById",
+      args: [orderId]
+    },
+    {
+      address: diamondAddress,
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "getAdditionalOrderDetails",
+      args: [orderId]
+    }
+  ];
+  const toError = (error) => new Error("Order contract read failed", { cause: error });
+  const exec = async () => {
+    if (publicClient.multicall) {
+      const [order2, details2] = await publicClient.multicall({
+        contracts: calls,
+        allowFailure: false
+      });
+      return { order: order2, details: details2 };
+    }
+    const [order, details] = await Promise.all(
+      calls.map((c) => publicClient.readContract(c))
+    );
+    return { order, details };
+  };
+  return import_neverthrow5.ResultAsync.fromPromise(exec(), toError);
+}
+function readFeeConfigMulticall(publicClient, diamondAddress, currency) {
+  const currencyHex = (0, import_viem3.stringToHex)(currency, { size: 32 });
+  const calls = [
+    {
+      address: diamondAddress,
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "getSmallOrderThreshold",
+      args: [currencyHex]
+    },
+    {
+      address: diamondAddress,
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "getSmallOrderFixedFee",
+      args: [currencyHex]
+    }
+  ];
+  const toError = (error) => new Error("Fee config contract read failed", { cause: error });
+  const exec = async () => {
+    if (publicClient.multicall) {
+      const [smallOrderThreshold2, smallOrderFixedFee2] = await publicClient.multicall({
+        contracts: calls,
+        allowFailure: false
+      });
+      return { smallOrderThreshold: smallOrderThreshold2, smallOrderFixedFee: smallOrderFixedFee2 };
+    }
+    const [smallOrderThreshold, smallOrderFixedFee] = await Promise.all(
+      calls.map((c) => publicClient.readContract(c))
+    );
+    return { smallOrderThreshold, smallOrderFixedFee };
+  };
+  return import_neverthrow5.ResultAsync.fromPromise(exec(), toError);
+}
 
-// src/order-routing/errors.ts
-var OrderRoutingError = class extends SdkError {
+// src/orders/actions/approve-usdc.ts
+var import_viem4 = require("viem");
+
+// src/orders/errors.ts
+var OrdersError = class extends SdkError {
   constructor(message, options) {
     super(message, options);
-    this.name = "OrderRoutingError";
+    this.name = "OrdersError";
   }
 };
 
-// src/order-routing/validation.ts
+// src/orders/tx.ts
+var import_neverthrow6 = require("neverthrow");
+function submitPreparedTx(input) {
+  const { prepared, walletClient, publicClient, waitForReceipt, extraMeta } = input;
+  const account = walletClient.account;
+  if (!account) {
+    return (0, import_neverthrow6.errAsync)(
+      new OrdersError("WalletClient is missing an account", {
+        code: "TX_SUBMISSION_FAILED"
+      })
+    );
+  }
+  const chain = walletClient.chain;
+  return import_neverthrow6.ResultAsync.fromPromise(
+    walletClient.sendTransaction({
+      account,
+      chain,
+      to: prepared.to,
+      data: prepared.data,
+      value: prepared.value
+    }),
+    (cause) => new OrdersError("walletClient.sendTransaction rejected", {
+      code: "TX_SUBMISSION_FAILED",
+      cause
+    })
+  ).andThen((hash) => {
+    const combinedMeta = prepared.meta || extraMeta ? { ...prepared.meta, ...extraMeta } : void 0;
+    if (!waitForReceipt) {
+      return (0, import_neverthrow6.okAsync)({ hash, meta: combinedMeta });
+    }
+    return import_neverthrow6.ResultAsync.fromPromise(
+      publicClient.waitForTransactionReceipt({ hash }),
+      (cause) => new OrdersError("waitForTransactionReceipt failed", {
+        code: "RECEIPT_TIMEOUT",
+        cause
+      })
+    ).andThen((receipt) => {
+      if (receipt.status !== "success") {
+        return (0, import_neverthrow6.errAsync)(
+          new OrdersError("Transaction reverted", {
+            code: "TX_REVERTED",
+            context: { hash, blockNumber: receipt.blockNumber.toString() }
+          })
+        );
+      }
+      return (0, import_neverthrow6.okAsync)({ hash, receipt, meta: combinedMeta });
+    });
+  });
+}
+
+// src/orders/validation.ts
 var import_zod3 = require("zod");
-var ZodCircleScoreStateSchema = import_zod3.z.object({
-  activeMerchantsCount: import_zod3.z.coerce.number()
-});
-var ZodCircleMetricsForRoutingSchema = import_zod3.z.object({
-  circleScore: import_zod3.z.coerce.number(),
-  circleStatus: import_zod3.z.string(),
-  scoreState: ZodCircleScoreStateSchema
+var ZodGetOrderParamsSchema = import_zod3.z.object({
+  orderId: import_zod3.z.bigint().positive()
 });
-var ZodCircleForRoutingSchema = import_zod3.z.object({
-  circleId: import_zod3.z.string(),
-  currency: import_zod3.z.string(),
-  metrics: ZodCircleMetricsForRoutingSchema
+var ZodGetFeeConfigParamsSchema = import_zod3.z.object({
+  currency: ZodCurrencySchema
 });
-var ZodCirclesForRoutingResponseSchema = import_zod3.z.object({
-  circles: import_zod3.z.array(ZodCircleForRoutingSchema)
+var ZodGetOrdersParamsSchema = import_zod3.z.object({
+  userAddress: ZodAddressSchema,
+  skip: import_zod3.z.number().int().min(0).default(0),
+  limit: import_zod3.z.number().int().min(1).max(100).default(20)
 });
-var ZodCheckCircleEligibilityParamsSchema = import_zod3.z.object({
-  circleId: import_zod3.z.bigint(),
-  currency: import_zod3.z.string(),
+var ZodPlaceOrderParamsSchema = import_zod3.z.object({
+  orderType: import_zod3.z.number().int().min(0).max(2),
+  currency: ZodCurrencySchema,
   user: ZodAddressSchema,
-  usdtAmount: import_zod3.z.bigint(),
+  amount: import_zod3.z.bigint(),
   fiatAmount: import_zod3.z.bigint(),
-  orderType: import_zod3.z.bigint(),
-  preferredPCConfigId: import_zod3.z.bigint()
+  fiatAmountLimit: import_zod3.z.bigint().optional().default(0n),
+  recipientAddr: ZodAddressSchema,
+  preferredPaymentChannelConfigId: import_zod3.z.bigint().optional(),
+  pubKey: import_zod3.z.string().optional()
 });
-var ZodSelectCircleParamsSchema = import_zod3.z.object({
-  currency: import_zod3.z.string().min(1),
-  user: ZodAddressSchema,
-  usdtAmount: import_zod3.z.bigint(),
-  fiatAmount: import_zod3.z.bigint(),
-  orderType: import_zod3.z.bigint(),
-  preferredPCConfigId: import_zod3.z.bigint()
+var ZodCancelOrderParamsSchema = import_zod3.z.object({
+  orderId: import_zod3.z.bigint().nonnegative()
 });
-
-// src/contracts/order-flow/index.ts
-function checkCircleEligibility(publicClient, contractAddress, params, logger = noopLogger) {
-  return validate(
-    ZodCheckCircleEligibilityParamsSchema,
-    params,
-    (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-  ).asyncAndThen((validated) => {
-    logger.debug("checking on-chain eligibility", {
-      circleId: String(validated.circleId),
-      contractAddress
-    });
-    return import_neverthrow4.ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: contractAddress,
-        abi: ABIS.FACETS.ORDER_FLOW,
-        functionName: "getAssignableMerchantsFromCircle",
-        args: [
-          validated.circleId,
-          1n,
-          validated.currency,
-          validated.user,
-          validated.usdtAmount,
-          validated.fiatAmount,
-          validated.orderType,
-          validated.preferredPCConfigId
-        ]
-      }),
-      (error) => new OrderRoutingError("Eligibility check failed", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { circleId: String(params.circleId) }
-      })
-    );
-  }).map((merchants) => {
-    const arr = merchants;
-    const eligible = arr.length >= 1;
-    logger.debug("eligibility check result", {
-      circleId: String(params.circleId),
-      assignableMerchants: arr.length,
-      eligible
-    });
-    return eligible;
-  });
-}
-
-// src/contracts/p2p-config/index.ts
-var import_neverthrow5 = require("neverthrow");
-var import_viem3 = require("viem");
-
-// src/profile/errors.ts
-var ProfileError = class extends SdkError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ProfileError";
-  }
-};
-
-// src/profile/validation.ts
-var import_zod4 = require("zod");
-var ZodUsdcBalanceParamsSchema = import_zod4.z.object({
-  address: ZodAddressSchema
+var ZodSetSellOrderUpiParamsSchema = import_zod3.z.object({
+  orderId: import_zod3.z.bigint().nonnegative(),
+  paymentAddress: import_zod3.z.string().min(1),
+  merchantPublicKey: import_zod3.z.string().min(1),
+  updatedAmount: import_zod3.z.bigint()
 });
-var ZodGetBalancesParamsSchema = import_zod4.z.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
+var ZodRaiseDisputeParamsSchema = import_zod3.z.object({
+  orderId: import_zod3.z.bigint().nonnegative(),
+  redactTransId: import_zod3.z.bigint().nonnegative()
 });
-var ZodTxLimitsParamsSchema = import_zod4.z.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
+var ZodApproveUsdcParamsSchema = import_zod3.z.object({
+  amount: import_zod3.z.bigint().nonnegative()
 });
-var ZodPriceConfigParamsSchema = import_zod4.z.object({
-  currency: ZodCurrencySchema
+var ZodPaidBuyOrderParamsSchema = import_zod3.z.object({
+  orderId: import_zod3.z.bigint().nonnegative()
+});
+var HexString = import_zod3.z.string().regex(/^0x[0-9a-fA-F]*$/, "Expected 0x-prefixed hex");
+var ZodSubgraphOrderSchema = import_zod3.z.object({
+  orderId: import_zod3.z.string(),
+  type: import_zod3.z.number().int().min(0),
+  status: import_zod3.z.number().int().min(0),
+  circleId: import_zod3.z.string(),
+  userAddress: HexString,
+  usdcRecipientAddress: HexString,
+  acceptedMerchantAddress: HexString,
+  usdcAmount: import_zod3.z.string(),
+  fiatAmount: import_zod3.z.string(),
+  actualUsdcAmount: import_zod3.z.string(),
+  actualFiatAmount: import_zod3.z.string(),
+  currency: HexString,
+  placedAt: import_zod3.z.string(),
+  acceptedAt: import_zod3.z.string(),
+  paidAt: import_zod3.z.string(),
+  completedAt: import_zod3.z.string(),
+  fixedFeePaid: import_zod3.z.string(),
+  tipsPaid: import_zod3.z.string(),
+  disputeStatus: import_zod3.z.number().int().min(0)
+});
+var ZodSubgraphOrdersResponseSchema = import_zod3.z.object({
+  orders_collection: import_zod3.z.array(ZodSubgraphOrderSchema)
 });
 
-// src/contracts/p2p-config/index.ts
-function getPriceConfig(publicClient, diamondAddress, params) {
-  return validate(
-    ZodPriceConfigParamsSchema,
+// src/orders/actions/approve-usdc.ts
+function createApproveUsdcAction(input) {
+  const { publicClient, diamondAddress, usdcAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodApproveUsdcParamsSchema,
     params,
-    (message, cause, data) => new ProfileError(message, {
+    (message, cause, data) => new OrdersError(message, {
       code: "VALIDATION_ERROR",
       cause,
-      context: { params: data }
+      context: { data }
     })
-  ).asyncAndThen(
-    (validated) => import_neverthrow5.ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: diamondAddress,
-        abi: ABIS.FACETS.CONFIG,
-        functionName: "getPriceConfig",
-        args: [(0, import_viem3.stringToHex)(validated.currency, { size: 32 })]
-      }),
-      (error) => new ProfileError("Failed to read price config", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { currency: validated.currency, diamondAddress }
-      })
-    )
-  );
+  ).map(({ amount }) => ({
+    to: usdcAddress,
+    data: (0, import_viem4.encodeFunctionData)({
+      abi: import_viem4.erc20Abi,
+      functionName: "approve",
+      args: [diamondAddress, amount]
+    }),
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
 }
 
-// src/contracts/reputation-manager/writes.ts
-var import_neverthrow6 = require("neverthrow");
-var import_viem4 = require("viem");
-
-// src/zkkyc/errors.ts
-var ZkkycError = class extends SdkError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ZkkycError";
-  }
-};
-
-// src/zkkyc/validation.ts
-var import_zod5 = require("zod");
-var ZodAnonAadharProofParamsSchema = import_zod5.z.object({
-  nullifierSeed: import_zod5.z.bigint(),
-  nullifier: import_zod5.z.bigint(),
-  timestamp: import_zod5.z.bigint(),
-  signal: import_zod5.z.bigint(),
-  revealArray: import_zod5.z.tuple([import_zod5.z.bigint(), import_zod5.z.bigint(), import_zod5.z.bigint(), import_zod5.z.bigint()]),
-  packedGroth16Proof: import_zod5.z.tuple([
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint(),
-    import_zod5.z.bigint()
-  ])
-});
-var ZodSocialVerifyParamsSchema = import_zod5.z.object({
-  _socialName: import_zod5.z.string(),
-  proofs: import_zod5.z.array(
-    import_zod5.z.object({
-      claimInfo: import_zod5.z.object({
-        provider: import_zod5.z.string(),
-        parameters: import_zod5.z.string(),
-        context: import_zod5.z.string()
-      }),
-      signedClaim: import_zod5.z.object({
-        claim: import_zod5.z.object({
-          identifier: import_zod5.z.string(),
-          owner: ZodAddressSchema,
-          timestampS: import_zod5.z.number(),
-          epoch: import_zod5.z.number()
-        }),
-        signatures: import_zod5.z.array(import_zod5.z.string())
-      })
+// src/orders/actions/cancel-order.ts
+var import_viem5 = require("viem");
+function createCancelOrderAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodCancelOrderParamsSchema,
+    params,
+    (message, cause, data) => new OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
     })
-  )
-});
-var ZodSolidityVerifierParametersSchema = import_zod5.z.object({
-  version: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
-    message: "Version must be a hex string"
-  }),
-  proofVerificationData: import_zod5.z.object({
-    vkeyHash: import_zod5.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
-      message: "Invalid bytes32 hex string"
+  ).map(({ orderId }) => ({
+    to: diamondAddress,
+    data: (0, import_viem5.encodeFunctionData)({
+      abi: ABIS.FACETS.ORDER_FLOW,
+      functionName: "cancelOrder",
+      args: [orderId]
     }),
-    proof: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
-      message: "Proof must be a hex string"
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/orders/actions/paid-buy-order.ts
+var import_viem6 = require("viem");
+function createPaidBuyOrderAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodPaidBuyOrderParamsSchema,
+    params,
+    (message, cause, data) => new OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).map(({ orderId }) => ({
+    to: diamondAddress,
+    data: (0, import_viem6.encodeFunctionData)({
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "paidBuyOrder",
+      args: [orderId]
     }),
-    publicInputs: import_zod5.z.array(
-      import_zod5.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
-        message: "Each public input must be a valid bytes32 hex string"
-      })
-    )
-  }),
-  committedInputs: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
-    message: "Committed inputs must be a hex string"
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/orders/actions/place-order.ts
+var import_viem8 = require("viem");
+
+// src/constants/orders.constant.ts
+var ORDER_TYPE = {
+  BUY: 0,
+  SELL: 1,
+  PAY: 2
+};
+var ORDER_STATUS = {
+  PLACED: 0,
+  ACCEPTED: 1,
+  PAID: 2,
+  COMPLETED: 3,
+  CANCELLED: 4
+};
+var DISPUTE_STATUS = {
+  NONE: 0,
+  OPEN: 1,
+  RESOLVED: 2
+};
+
+// src/orders/relay-identity/identity.ts
+var import_viem7 = require("viem");
+var import_accounts = require("viem/accounts");
+var import_zod4 = require("zod");
+var ZodRelayIdentitySchema = import_zod4.z.object({
+  address: import_zod4.z.string().refine(import_viem7.isAddress, { message: "Invalid relay identity address" }),
+  publicKey: import_zod4.z.string().refine((v) => (0, import_viem7.isHex)(`0x${v}`), {
+    message: "Invalid relay identity public key"
   }),
-  serviceConfig: import_zod5.z.object({
-    validityPeriodInSeconds: import_zod5.z.number().int().nonnegative(),
-    domain: import_zod5.z.string(),
-    scope: import_zod5.z.string(),
-    devMode: import_zod5.z.boolean()
-  })
-});
-var ZodZkPassportRegisterParamsSchema = import_zod5.z.object({
-  params: ZodSolidityVerifierParametersSchema,
-  isIDCard: import_zod5.z.boolean()
+  privateKey: import_zod4.z.string().refine(import_viem7.isHex, { message: "Invalid relay identity private key" })
 });
+function createRelayIdentity() {
+  const privateKey = (0, import_accounts.generatePrivateKey)();
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+  const publicKey = account.publicKey.slice(4);
+  return {
+    address: account.address,
+    publicKey,
+    privateKey
+  };
+}
 
-// src/contracts/reputation-manager/writes.ts
-function prepareSocialVerify(reputationManagerAddress, params) {
-  return validate(
-    ZodSocialVerifyParamsSchema,
-    params,
-    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
-  ).andThen(
-    (validated) => import_neverthrow6.Result.fromThrowable(
-      () => ({
-        to: reputationManagerAddress,
-        data: (0, import_viem4.encodeFunctionData)({
-          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
-          functionName: "socialVerify",
-          args: [
-            validated._socialName,
-            validated.proofs.map((proof) => ({
-              ...proof,
-              signedClaim: {
-                ...proof.signedClaim,
-                claim: {
-                  ...proof.signedClaim.claim,
-                  identifier: proof.signedClaim.claim.identifier
-                },
-                signatures: proof.signedClaim.signatures
-              }
-            }))
-          ]
+// src/orders/relay-identity/resolve.ts
+var import_neverthrow7 = require("neverthrow");
+
+// src/orders/relay-identity/stores.ts
+var RelayIdentityCorruptError = class extends Error {
+  constructor(cause) {
+    super("Stored relay identity is corrupt", { cause });
+    this.name = "RelayIdentityCorruptError";
+  }
+};
+function createInMemoryRelayStore() {
+  let value = null;
+  return {
+    async get() {
+      return value;
+    },
+    async set(identity) {
+      value = identity;
+    }
+  };
+}
+
+// src/orders/relay-identity/resolve.ts
+var pending = /* @__PURE__ */ new WeakMap();
+async function resolveFromStore(store) {
+  let stored;
+  try {
+    stored = await store.get();
+  } catch (cause) {
+    if (cause instanceof RelayIdentityCorruptError) {
+      return (0, import_neverthrow7.err)(
+        new OrdersError("Stored relay identity is corrupt", {
+          code: "RELAY_IDENTITY_CORRUPT",
+          cause: cause.cause
         })
-      }),
-      (error) => new ZkkycError("Failed to encode socialVerify", {
-        code: "ENCODE_ERROR",
-        cause: error
+      );
+    }
+    return (0, import_neverthrow7.err)(
+      new OrdersError("Relay identity store.get failed", {
+        code: "RELAY_IDENTITY_STORE_FAILED",
+        cause
       })
-    )()
-  );
-}
-function prepareSubmitAnonAadharProof(reputationManagerAddress, params) {
-  return validate(
-    ZodAnonAadharProofParamsSchema,
-    params,
-    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
-  ).andThen(
-    (validated) => import_neverthrow6.Result.fromThrowable(
-      () => ({
-        to: reputationManagerAddress,
-        data: (0, import_viem4.encodeFunctionData)({
-          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
-          functionName: "submitAnonAadharProof",
-          args: [
-            validated.nullifierSeed,
-            validated.nullifier,
-            validated.timestamp,
-            validated.signal,
-            validated.revealArray,
-            validated.packedGroth16Proof
-          ]
+    );
+  }
+  if (stored !== null) {
+    const parsed = ZodRelayIdentitySchema.safeParse(stored);
+    if (!parsed.success) {
+      return (0, import_neverthrow7.err)(
+        new OrdersError("Stored relay identity failed validation", {
+          code: "RELAY_IDENTITY_CORRUPT",
+          cause: parsed.error
         })
-      }),
-      (error) => new ZkkycError("Failed to encode submitAnonAadharProof", {
-        code: "ENCODE_ERROR",
-        cause: error
+      );
+    }
+    return (0, import_neverthrow7.ok)(stored);
+  }
+  const fresh = createRelayIdentity();
+  try {
+    await store.set(fresh);
+  } catch (cause) {
+    return (0, import_neverthrow7.err)(
+      new OrdersError("Relay identity store.set failed", {
+        code: "RELAY_IDENTITY_STORE_FAILED",
+        cause
       })
-    )()
-  );
+    );
+  }
+  return (0, import_neverthrow7.ok)(fresh);
 }
-function prepareZkPassportRegister(reputationManagerAddress, params) {
-  return validate(
-    ZodZkPassportRegisterParamsSchema,
-    params,
-    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
-  ).andThen(
-    (validated) => import_neverthrow6.Result.fromThrowable(
-      () => {
-        const { proofVerificationData, serviceConfig, committedInputs, version } = validated.params;
-        const proofVerificationParams = {
-          version,
-          proofVerificationData: {
-            vkeyHash: proofVerificationData.vkeyHash,
-            proof: proofVerificationData.proof,
-            publicInputs: proofVerificationData.publicInputs
-          },
-          committedInputs,
-          serviceConfig: {
-            validityPeriodInSeconds: BigInt(serviceConfig.validityPeriodInSeconds),
-            domain: serviceConfig.domain,
-            scope: serviceConfig.scope,
-            devMode: serviceConfig.devMode
-          }
-        };
-        return {
-          to: reputationManagerAddress,
-          data: (0, import_viem4.encodeFunctionData)({
-            abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
-            functionName: "zkPassportRegister",
-            args: [proofVerificationParams, validated.isIDCard]
-          })
-        };
-      },
-      (error) => new ZkkycError("Failed to encode zkPassportRegister", {
-        code: "ENCODE_ERROR",
-        cause: error
-      })
-    )()
-  );
+function resolveRelayIdentity(input) {
+  if (input.relayIdentity) {
+    return (0, import_neverthrow7.okAsync)(input.relayIdentity);
+  }
+  const existing = pending.get(input.store);
+  if (existing) {
+    return import_neverthrow7.ResultAsync.fromSafePromise(existing).andThen((r) => r);
+  }
+  const promise = resolveFromStore(input.store).finally(() => {
+    pending.delete(input.store);
+  });
+  pending.set(input.store, promise);
+  return import_neverthrow7.ResultAsync.fromSafePromise(promise).andThen((r) => r);
 }
 
-// src/contracts/tx-limits/index.ts
-var import_neverthrow7 = require("neverthrow");
-var import_viem5 = require("viem");
-function getTxLimits(publicClient, diamondAddress, params) {
-  return validate(
-    ZodTxLimitsParamsSchema,
+// src/orders/actions/place-order.ts
+function enrichWithOrderId(result, userAddress) {
+  if (!result.receipt) return result;
+  try {
+    const events = (0, import_viem8.parseEventLogs)({
+      abi: ABIS.FACETS.ORDER_FLOW,
+      eventName: "OrderPlaced",
+      logs: result.receipt.logs
+    });
+    const lowered = userAddress.toLowerCase();
+    const mine = events.find((e) => e.args.user?.toLowerCase() === lowered);
+    const chosen = mine ?? events[0];
+    if (!chosen) return result;
+    const orderId = chosen.args.orderId;
+    if (orderId === void 0) return result;
+    return { ...result, meta: { ...result.meta, orderId } };
+  } catch {
+    return result;
+  }
+}
+function createPlaceOrderAction(input) {
+  const { publicClient, diamondAddress, orderRouter, relayIdentityStore, relayIdentity } = input;
+  const prepareFn = (params) => validate(
+    ZodPlaceOrderParamsSchema,
     params,
-    (message, cause, data) => new ProfileError(message, {
+    (message, cause, data) => new OrdersError(message, {
       code: "VALIDATION_ERROR",
       cause,
-      context: { params: data }
+      context: { data }
     })
-  ).asyncAndThen(
-    (validated) => import_neverthrow7.ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: diamondAddress,
-        abi: ABIS.FACETS.ORDER_FLOW,
-        functionName: "userTxLimit",
-        args: [validated.address, (0, import_viem5.stringToHex)(validated.currency, { size: 32 })]
-      }),
-      (error) => new ProfileError("Failed to read tx limits", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { address: validated.address, currency: validated.currency, diamondAddress }
+  ).asyncAndThen((v) => {
+    const pcConfigId = v.preferredPaymentChannelConfigId ?? 0n;
+    const circleResult = orderRouter.selectCircle({
+      currency: v.currency,
+      user: v.user,
+      usdtAmount: v.amount,
+      fiatAmount: v.fiatAmount,
+      orderType: BigInt(v.orderType),
+      preferredPCConfigId: pcConfigId
+    }).mapErr(
+      (cause) => new OrdersError(`Circle selection failed: ${cause.message}`, {
+        code: "CIRCLE_SELECTION_FAILED",
+        cause
       })
-    ).map(([buyLimit, sellLimit]) => ({
-      buyLimit: Number((0, import_viem5.formatUnits)(buyLimit, 6)),
-      sellLimit: Number((0, import_viem5.formatUnits)(sellLimit, 6))
-    }))
-  );
+    );
+    const identityResult = resolveRelayIdentity({
+      relayIdentity,
+      store: relayIdentityStore
+    });
+    return identityResult.andThen(
+      (senderIdentity) => circleResult.map((circleId) => {
+        const isBuy = v.orderType === ORDER_TYPE.BUY;
+        const keyFromCaller = v.pubKey ?? senderIdentity.publicKey;
+        const pubKey = isBuy ? keyFromCaller : "";
+        const userPubKey = isBuy ? "" : keyFromCaller;
+        const currencyBytes32 = (0, import_viem8.stringToHex)(v.currency, { size: 32 });
+        const data = (0, import_viem8.encodeFunctionData)({
+          abi: ABIS.FACETS.ORDER_FLOW,
+          functionName: "placeOrder",
+          args: [
+            pubKey,
+            v.amount,
+            v.recipientAddr,
+            v.orderType,
+            "",
+            // _userUpi — set later via setSellOrderUpi if applicable
+            userPubKey,
+            currencyBytes32,
+            pcConfigId,
+            circleId,
+            v.fiatAmountLimit ?? 0n
+          ]
+        });
+        return {
+          to: diamondAddress,
+          data,
+          value: 0n,
+          meta: { circleId, relayIdentity: senderIdentity }
+        };
+      })
+    );
+  });
+  return {
+    prepare(params) {
+      return prepareFn(params);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      const owner = walletClient.account?.address;
+      const enrich = (r) => owner ? enrichWithOrderId(r, owner) : r;
+      return prepareFn(params).andThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt }).map(enrich)
+      );
+    }
+  };
 }
-function getRpPerUsdtLimitRational(publicClient, diamondAddress, params) {
-  return validate(
-    ZodPriceConfigParamsSchema,
+
+// src/orders/actions/raise-dispute.ts
+var import_viem9 = require("viem");
+function createRaiseDisputeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodRaiseDisputeParamsSchema,
     params,
-    (message, cause, data) => new ProfileError(message, {
+    (message, cause, data) => new OrdersError(message, {
       code: "VALIDATION_ERROR",
       cause,
-      context: { params: data }
+      context: { data }
     })
-  ).asyncAndThen(
-    (validated) => import_neverthrow7.ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: diamondAddress,
-        abi: ABIS.DIAMOND,
-        functionName: "getRpPerUsdtLimitRational",
-        args: [(0, import_viem5.stringToHex)(validated.currency, { size: 32 })]
-      }),
-      (error) => new ProfileError("Failed to read RP per USDT limit rational", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { currency: validated.currency, diamondAddress }
-      })
-    ).map(([numerator, denominator]) => ({
-      numerator,
-      denominator,
-      multiplier: numerator > 0n ? Number(denominator) / Number(numerator) : 0
-    }))
-  );
-}
-
-// src/contracts/usdc/index.ts
-var import_neverthrow8 = require("neverthrow");
-function getUsdcBalance(publicClient, usdcAddress, params) {
-  return validate(
-    ZodUsdcBalanceParamsSchema,
-    params,
-    (message, cause, data) => new ProfileError(message, {
-      code: "VALIDATION_ERROR",
-      cause,
-      context: { params: data }
-    })
-  ).asyncAndThen(
-    (validated) => import_neverthrow8.ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: usdcAddress,
-        abi: ABIS.EXTERNAL.USDC,
-        functionName: "balanceOf",
-        args: [validated.address]
-      }),
-      (error) => new ProfileError("Failed to read USDC balance", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { address: validated.address, usdcAddress }
-      })
-    )
-  );
+  ).map(({ orderId, redactTransId }) => ({
+    to: diamondAddress,
+    data: (0, import_viem9.encodeFunctionData)({
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "raiseDispute",
+      args: [orderId, redactTransId]
+    }),
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
 }
 
-// src/order-routing/routing.ts
-var import_neverthrow9 = require("neverthrow");
-var EPSILON = 0.25;
-var RECOVERY_SCALE = 0.3;
-var BOOTSTRAP_MAX_WEIGHT = 25;
-var MAX_VALIDATION_ATTEMPTS = 3;
-function circleWeight(c) {
-  const score = c.metrics.circleScore;
-  if (c.metrics.circleStatus === "paused") {
-    return score * RECOVERY_SCALE;
-  }
-  if (c.metrics.circleStatus === "bootstrap") {
-    return Math.min(score, BOOTSTRAP_MAX_WEIGHT);
-  }
-  return score;
+// src/orders/actions/set-sell-order-upi.ts
+var import_viem11 = require("viem");
+
+// src/orders/crypto/encryption.ts
+var import_neverthrow8 = require("neverthrow");
+var import_viem10 = require("viem");
+var import_accounts2 = require("viem/accounts");
+var import_zod5 = require("zod");
+
+// node_modules/@noble/ciphers/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function filterEligibleCircles(circles, orderCurrency) {
-  return circles.filter((c) => c.currency.toLowerCase() === orderCurrency.toLowerCase());
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
 }
-function weightedRandomChoice(arr, weights) {
-  const totalWeight = weights.reduce((sum, w) => sum + w, 0);
-  if (totalWeight === 0) {
-    return arr[Math.floor(Math.random() * arr.length)];
-  }
-  let rand = Math.random() * totalWeight;
-  for (let i = 0; i < arr.length; i++) {
-    rand -= weights[i];
-    if (rand <= 0) {
-      return arr[i];
-    }
-  }
-  return arr[arr.length - 1];
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
-function selectCircle(eligible) {
-  if (eligible.length === 0) {
-    return null;
-  }
-  const activeCircles = eligible.filter((c) => c.metrics.circleStatus === "active");
-  const isExplore = Math.random() < EPSILON;
-  if (isExplore) {
-    const weights2 = eligible.map(circleWeight);
-    return weightedRandomChoice(eligible, weights2);
-  }
-  if (activeCircles.length === 0) {
-    const weights2 = eligible.map(circleWeight);
-    return weightedRandomChoice(eligible, weights2);
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-  const weights = activeCircles.map((c) => c.metrics.circleScore);
-  return weightedRandomChoice(activeCircles, weights);
 }
-function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logger = noopLogger) {
-  const eligible = filterEligibleCircles(circles, orderCurrency);
-  let remaining = [...eligible];
-  logger.debug("filtering eligible circles", {
-    total: circles.length,
-    eligible: eligible.length,
-    currency: orderCurrency,
-    circles: eligible
-  });
-  if (eligible.length === 0) {
-    logger.warn("no eligible circles found for currency", { currency: orderCurrency });
-  }
-  function attempt(attemptsLeft) {
-    if (attemptsLeft <= 0 || remaining.length === 0) {
-      logger.warn("exhausted all attempts or circles", {
-        attemptsLeft,
-        remainingCircles: remaining.length
-      });
-      return (0, import_neverthrow9.errAsync)(
-        new OrderRoutingError("No eligible circles found", {
-          code: "NO_ELIGIBLE_CIRCLES"
-        })
-      );
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function overlapBytes(a, b) {
+  return a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
+  a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
+  b.byteOffset < a.byteOffset + a.byteLength;
+}
+function complexOverlapBytes(input, output) {
+  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
+    throw new Error("complex overlap of input and output is not supported");
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key);
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      if (!nonce)
+        throw new Error("nonce / iv required");
+      if (params.varSizeNonce)
+        abytes(nonce);
+      else
+        abytes(nonce, params.nonceLength);
     }
-    const selected = selectCircle(remaining);
-    if (!selected) {
-      return (0, import_neverthrow9.errAsync)(
-        new OrderRoutingError("No eligible circles found", {
-          code: "NO_ELIGIBLE_CIRCLES"
-        })
-      );
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0) {
+      abytes(args[1]);
     }
-    const circleId = BigInt(selected.circleId);
-    logger.debug("selected circle, validating on-chain", {
-      circleId: String(circleId),
-      status: selected.metrics.circleStatus,
-      score: selected.metrics.circleScore,
-      attemptsLeft
-    });
-    return validateCircle(circleId).orElse((error) => {
-      logger.warn("validation errored, treating as ineligible", {
-        circleId: String(circleId),
-        error: String(error)
-      });
-      return (0, import_neverthrow9.okAsync)(false);
-    }).andThen((isValid) => {
-      if (isValid) {
-        logger.info("circle validated successfully", { circleId: String(circleId) });
-        return (0, import_neverthrow9.okAsync)(circleId);
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output);
       }
-      logger.debug("circle failed validation, retrying", {
-        circleId: String(circleId),
-        remainingCircles: remaining.length - 1
-      });
-      remaining = remaining.filter((c) => c.circleId !== selected.circleId);
-      return attempt(attemptsLeft - 1);
-    });
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error("invalid ciphertext length: smaller than tagLength=" + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
   }
-  return attempt(MAX_VALIDATION_ATTEMPTS);
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength)
+    throw new Error("invalid output length, expected " + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
 }
 
-// src/order-routing/subgraph/client.ts
-var import_neverthrow10 = require("neverthrow");
-var DEFAULT_TIMEOUT_MS = 1e4;
-var MAX_RETRIES = 3;
-var BACKOFF_MS = 500;
-function isTransient(error) {
-  if (error instanceof OrderRoutingError) return false;
-  if (error instanceof DOMException && error.name === "AbortError") return true;
-  if (error instanceof TypeError) return true;
-  return false;
-}
-function querySubgraph(url, params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const fetchOnce = async () => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          query: params.query,
-          variables: params.variables
-        }),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new OrderRoutingError(`Subgraph request failed (status: ${response.status})`, {
-          code: "SUBGRAPH_ERROR",
-          cause: response,
-          context: { status: response.status }
-        });
-      }
-      const json = await response.json();
-      if (json.errors?.length > 0) {
-        throw new OrderRoutingError("Subgraph returned GraphQL errors", {
-          code: "SUBGRAPH_ERROR",
-          cause: json.errors,
-          context: { errors: json.errors }
-        });
-      }
-      if (!json.data) {
-        throw new OrderRoutingError("Subgraph returned no data", {
-          code: "SUBGRAPH_ERROR",
-          cause: "Missing data field in GraphQL response",
-          context: { response: json }
-        });
-      }
-      return json.data;
-    } finally {
-      clearTimeout(timer);
-    }
-  };
-  const fetchWithRetry = async () => {
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        return await fetchOnce();
-      } catch (error) {
-        const lastAttempt = attempt === MAX_RETRIES;
-        if (lastAttempt || !isTransient(error)) throw error;
-        await sleep(BACKOFF_MS * (attempt + 1));
-      }
-    }
-    throw new OrderRoutingError("Subgraph query exhausted retries", {
-      code: "SUBGRAPH_ERROR"
-    });
-  };
-  return import_neverthrow10.ResultAsync.fromPromise(
-    fetchWithRetry(),
-    (error) => error instanceof OrderRoutingError ? error : new OrderRoutingError("Subgraph query failed", {
-      code: "SUBGRAPH_ERROR",
-      cause: error
-    })
-  );
-}
-
-// src/order-routing/subgraph/queries.ts
-var CIRCLES_FOR_ROUTING_QUERY = (
-  /* GraphQL */
-  `
-  query CirclesForRouting($currency: Bytes!) {
-    circles(
-      first: 1000
-      where: {
-        currency: $currency
-        metrics_: {
-          circleStatus_in: ["active", "bootstrap", "paused"]
-        }
-      }
-    ) {
-      circleId
-      currency
-      metrics {
-        circleScore
-        circleStatus
-        scoreState {
-          activeMerchantsCount
-        }
-      }
-    }
-  }
-`
-);
-
-// src/order-routing/subgraph/index.ts
-function getCirclesForRouting(subgraphUrl, currency, logger = noopLogger) {
-  logger.debug("fetching circles from subgraph", { subgraphUrl, currency });
-  return querySubgraph(subgraphUrl, {
-    query: CIRCLES_FOR_ROUTING_QUERY,
-    variables: { currency }
-  }).andThen(
-    (data) => validate(
-      ZodCirclesForRoutingResponseSchema,
-      data,
-      (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-    ).map((validated) => {
-      const circles = validated.circles.filter(
-        (item) => Number(item.metrics.scoreState.activeMerchantsCount) > 0
-      );
-      logger.info("fetched circles from subgraph", {
-        total: validated.circles.length,
-        withActiveMerchants: circles.length,
-        circles
-      });
-      return circles;
-    })
-  );
-}
-
-// src/order-routing/client.ts
-function createOrderRouter(config) {
-  const { subgraphUrl, publicClient, contractAddress } = config;
-  const logger = config.logger ?? noopLogger;
-  return {
-    selectCircle(params) {
-      const currencyHex = (0, import_viem6.stringToHex)(params.currency, { size: 32 });
-      logger.info("selectCircle started", {
-        currency: params.currency,
-        user: params.user,
-        orderType: String(params.orderType)
-      });
-      return getCirclesForRouting(subgraphUrl, currencyHex, logger).andThen(
-        (circles) => selectCircleForOrderAsync(
-          circles,
-          currencyHex,
-          (circleId) => checkCircleEligibility(
-            publicClient,
-            contractAddress,
-            {
-              circleId,
-              currency: currencyHex,
-              user: params.user,
-              usdtAmount: params.usdtAmount,
-              fiatAmount: params.fiatAmount,
-              orderType: params.orderType,
-              preferredPCConfigId: params.preferredPCConfigId
-            },
-            logger
-          ),
-          logger
-        )
-      );
-    }
-  };
-}
-
-// src/payload/actions.ts
-var import_neverthrow13 = require("neverthrow");
-
-// src/payload/crypto.ts
-var import_neverthrow12 = require("neverthrow");
-var import_viem8 = require("viem");
-var import_accounts2 = require("viem/accounts");
-var import_zod7 = require("zod");
-
-// node_modules/@noble/ciphers/esm/utils.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function abytes(b, ...lengths) {
-  if (!isBytes(b))
-    throw new Error("Uint8Array expected");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function overlapBytes(a, b) {
-  return a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
-  a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
-  b.byteOffset < a.byteOffset + a.byteLength;
-}
-function complexOverlapBytes(input, output) {
-  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
-    throw new Error("complex overlap of input and output is not supported");
-}
-var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
-  function wrappedCipher(key, ...args) {
-    abytes(key);
-    if (!isLE)
-      throw new Error("Non little-endian hardware is not yet supported");
-    if (params.nonceLength !== void 0) {
-      const nonce = args[0];
-      if (!nonce)
-        throw new Error("nonce / iv required");
-      if (params.varSizeNonce)
-        abytes(nonce);
-      else
-        abytes(nonce, params.nonceLength);
-    }
-    const tagl = params.tagLength;
-    if (tagl && args[1] !== void 0) {
-      abytes(args[1]);
-    }
-    const cipher = constructor(key, ...args);
-    const checkOutput = (fnLength, output) => {
-      if (output !== void 0) {
-        if (fnLength !== 2)
-          throw new Error("cipher output not supported");
-        abytes(output);
-      }
-    };
-    let called = false;
-    const wrCipher = {
-      encrypt(data, output) {
-        if (called)
-          throw new Error("cannot encrypt() twice with same key + nonce");
-        called = true;
-        abytes(data);
-        checkOutput(cipher.encrypt.length, output);
-        return cipher.encrypt(data, output);
-      },
-      decrypt(data, output) {
-        abytes(data);
-        if (tagl && data.length < tagl)
-          throw new Error("invalid ciphertext length: smaller than tagLength=" + tagl);
-        checkOutput(cipher.decrypt.length, output);
-        return cipher.decrypt(data, output);
-      }
-    };
-    return wrCipher;
-  }
-  Object.assign(wrappedCipher, params);
-  return wrappedCipher;
-};
-function getOutput(expectedLength, out, onlyAligned = true) {
-  if (out === void 0)
-    return new Uint8Array(expectedLength);
-  if (out.length !== expectedLength)
-    throw new Error("invalid output length, expected " + expectedLength + ", got: " + out.length);
-  if (onlyAligned && !isAligned32(out))
-    throw new Error("invalid output, must be aligned");
-  return out;
-}
-function isAligned32(bytes) {
-  return bytes.byteOffset % 4 === 0;
-}
-function copyBytes(bytes) {
-  return Uint8Array.from(bytes);
-}
-
-// node_modules/@noble/ciphers/esm/aes.js
-var BLOCK_SIZE = 16;
-var POLY = 283;
-function mul2(n) {
-  return n << 1 ^ POLY & -(n >> 7);
+// node_modules/@noble/ciphers/esm/aes.js
+var BLOCK_SIZE = 16;
+var POLY = 283;
+function mul2(n) {
+  return n << 1 ^ POLY & -(n >> 7);
 }
 function mul(a, b) {
   let res = 0;
@@ -3587,15 +3898,15 @@ function weierstrassPoints(opts) {
       throw new Error("ProjectivePoint expected");
   }
   const toAffineMemo = memoized((p, iz) => {
-    const { px: x, py: y, pz: z9 } = p;
-    if (Fp.eql(z9, Fp.ONE))
+    const { px: x, py: y, pz: z10 } = p;
+    if (Fp.eql(z10, Fp.ONE))
       return { x, y };
     const is0 = p.is0();
     if (iz == null)
-      iz = is0 ? Fp.ONE : Fp.inv(z9);
+      iz = is0 ? Fp.ONE : Fp.inv(z10);
     const ax = Fp.mul(x, iz);
     const ay = Fp.mul(y, iz);
-    const zz = Fp.mul(z9, iz);
+    const zz = Fp.mul(z10, iz);
     if (is0)
       return { x: Fp.ZERO, y: Fp.ZERO };
     if (!Fp.eql(zz, Fp.ONE))
@@ -4356,7 +4667,8 @@ var sha2562 = sha256;
 // node_modules/@noble/hashes/esm/sha512.js
 var sha5122 = sha512;
 
-// src/payload/ecies.ts
+// src/orders/crypto/ecies.ts
+var MIN_CIPHER_BYTES = 82;
 function hexToBytes3(hex) {
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < bytes.length; i++) {
@@ -4369,243 +4681,1747 @@ function bytesToHex2(bytes) {
   for (const b of bytes) {
     hex += b.toString(16).padStart(2, "0");
   }
-  return hex;
-}
-function deriveKeys(sharedSecret) {
-  const hash = sha5122(sharedSecret);
-  return {
-    encKey: hash.slice(0, 32),
-    macKey: hash.slice(32)
-  };
+  return hex;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+function deriveKeys(sharedSecret) {
+  const hash = sha5122(sharedSecret);
+  return {
+    encKey: hash.slice(0, 32),
+    macKey: hash.slice(32)
+  };
+}
+async function encryptWithPublicKey(publicKey, message) {
+  const pubKeyBytes = hexToBytes3(`04${publicKey}`);
+  const ephemPrivKey = randomBytes(32);
+  const ephemPubKey = secp256k1.getPublicKey(ephemPrivKey, false);
+  const sharedPoint = secp256k1.getSharedSecret(ephemPrivKey, pubKeyBytes, true);
+  const sharedSecret = sharedPoint.slice(1);
+  const { encKey, macKey } = deriveKeys(sharedSecret);
+  const iv = randomBytes(16);
+  const plaintext = new TextEncoder().encode(message);
+  const cipher = cbc(encKey, iv);
+  const ciphertext = cipher.encrypt(plaintext);
+  const macData = concatBytes2(iv, ephemPubKey, ciphertext);
+  const mac = hmac(sha2562, macKey, macData);
+  return {
+    iv: bytesToHex2(iv),
+    ephemPublicKey: bytesToHex2(ephemPubKey),
+    ciphertext: bytesToHex2(ciphertext),
+    mac: bytesToHex2(mac)
+  };
+}
+async function decryptWithPrivateKey(privateKey, encrypted) {
+  const privKeyBytes = hexToBytes3(privateKey.replace(/^0x/, ""));
+  const ephemPubKeyBytes = hexToBytes3(encrypted.ephemPublicKey);
+  const ivBytes = hexToBytes3(encrypted.iv);
+  const ciphertextBytes = hexToBytes3(encrypted.ciphertext);
+  const macBytes = hexToBytes3(encrypted.mac);
+  const sharedPoint = secp256k1.getSharedSecret(privKeyBytes, ephemPubKeyBytes, true);
+  const sharedSecret = sharedPoint.slice(1);
+  const { encKey, macKey } = deriveKeys(sharedSecret);
+  const macData = concatBytes2(ivBytes, ephemPubKeyBytes, ciphertextBytes);
+  const computedMac = hmac(sha2562, macKey, macData);
+  if (!timingSafeEqual(computedMac, macBytes)) {
+    throw new Error("MAC mismatch \u2014 ciphertext may be corrupted or tampered with");
+  }
+  const cipher = cbc(encKey, ivBytes);
+  const plaintext = cipher.decrypt(ciphertextBytes);
+  return new TextDecoder().decode(plaintext);
+}
+function cipherStringify(encrypted) {
+  const ephemPubKeyBytes = hexToBytes3(encrypted.ephemPublicKey);
+  const compressed = secp256k1.ProjectivePoint.fromHex(ephemPubKeyBytes).toRawBytes(true);
+  const iv = hexToBytes3(encrypted.iv);
+  const mac = hexToBytes3(encrypted.mac);
+  const ciphertext = hexToBytes3(encrypted.ciphertext);
+  return bytesToHex2(concatBytes2(iv, compressed, mac, ciphertext));
+}
+function cipherParse(str) {
+  const buf = hexToBytes3(str);
+  if (buf.length < MIN_CIPHER_BYTES) {
+    throw new Error(
+      `cipherParse: input too short (${buf.length} bytes, need at least ${MIN_CIPHER_BYTES})`
+    );
+  }
+  const iv = buf.slice(0, 16);
+  const compressed = buf.slice(16, 49);
+  const mac = buf.slice(49, 81);
+  const ciphertext = buf.slice(81);
+  const ephemPubKey = secp256k1.ProjectivePoint.fromHex(compressed).toRawBytes(false);
+  return {
+    iv: bytesToHex2(iv),
+    ephemPublicKey: bytesToHex2(ephemPubKey),
+    ciphertext: bytesToHex2(ciphertext),
+    mac: bytesToHex2(mac)
+  };
+}
+
+// src/orders/crypto/encryption.ts
+function tryParseLegacyEthCryptoEnvelope(input) {
+  if (input.charCodeAt(0) !== 123) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const o = parsed;
+  if (typeof o.iv !== "string" || typeof o.ephemPublicKey !== "string" || typeof o.ciphertext !== "string" || typeof o.mac !== "string") {
+    return void 0;
+  }
+  return {
+    iv: o.iv,
+    ephemPublicKey: o.ephemPublicKey,
+    ciphertext: o.ciphertext,
+    mac: o.mac
+  };
+}
+function encryptPaymentAddress(input) {
+  return (0, import_neverthrow8.safeTry)(async function* () {
+    const messageHash = (0, import_viem10.keccak256)((0, import_viem10.stringToHex)(input.paymentAddress));
+    const signature = yield* import_neverthrow8.ResultAsync.fromPromise(
+      (0, import_accounts2.sign)({ hash: messageHash, privateKey: input.senderIdentity.privateKey }),
+      (cause) => new OrdersError("Failed to sign payment address", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    ).map(import_viem10.serializeSignature);
+    const payload = JSON.stringify({ message: input.paymentAddress, signature });
+    const encrypted = yield* import_neverthrow8.ResultAsync.fromPromise(
+      encryptWithPublicKey(input.recipientPublicKey, payload),
+      (cause) => new OrdersError("ECIES encryption failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    const safeStringify = import_neverthrow8.Result.fromThrowable(
+      (e) => cipherStringify(e),
+      (cause) => new OrdersError("Ciphertext stringify failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    return (0, import_neverthrow8.ok)(yield* safeStringify(encrypted));
+  });
+}
+var ZodDecryptedPayloadSchema = import_zod5.z.object({
+  message: import_zod5.z.string(),
+  signature: import_zod5.z.string()
+});
+function decryptPaymentAddress(input) {
+  return (0, import_neverthrow8.safeTry)(async function* () {
+    const legacyEnvelope = tryParseLegacyEthCryptoEnvelope(input.encrypted);
+    const safeCipherParse = import_neverthrow8.Result.fromThrowable(
+      (s) => cipherParse(s),
+      (cause) => new OrdersError("Failed to parse ciphertext", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    const encryptedData = legacyEnvelope ?? (yield* safeCipherParse(input.encrypted));
+    const plaintext = yield* import_neverthrow8.ResultAsync.fromPromise(
+      decryptWithPrivateKey(input.recipientIdentity.privateKey, encryptedData),
+      (cause) => new OrdersError("ECIES decryption failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    if (legacyEnvelope) {
+      return (0, import_neverthrow8.ok)(plaintext);
+    }
+    const safeJsonParse = import_neverthrow8.Result.fromThrowable(
+      (s) => JSON.parse(s),
+      (cause) => new OrdersError("Failed to parse decrypted payload JSON", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    const parsed = yield* safeJsonParse(plaintext);
+    const payload = yield* validate(
+      ZodDecryptedPayloadSchema,
+      parsed,
+      (message, cause, data) => new OrdersError(message, {
+        code: "ENCRYPTION_FAILED",
+        cause,
+        context: { data }
+      })
+    );
+    return (0, import_neverthrow8.ok)(payload.message);
+  });
+}
+
+// src/orders/actions/set-sell-order-upi.ts
+function createSetSellOrderUpiAction(input) {
+  const { publicClient, diamondAddress, relayIdentityStore, relayIdentity } = input;
+  const prepareFn = (params) => validate(
+    ZodSetSellOrderUpiParamsSchema,
+    params,
+    (message, cause, data) => new OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).asyncAndThen(
+    (v) => resolveRelayIdentity({ relayIdentity, store: relayIdentityStore }).andThen(
+      (senderIdentity) => encryptPaymentAddress({
+        paymentAddress: v.paymentAddress,
+        recipientPublicKey: v.merchantPublicKey,
+        senderIdentity
+      }).map((userEncUpi) => ({ v, userEncUpi, senderIdentity }))
+    )
+  ).map(({ v, userEncUpi, senderIdentity }) => ({
+    to: diamondAddress,
+    data: (0, import_viem11.encodeFunctionData)({
+      abi: ABIS.FACETS.ORDER_FLOW,
+      functionName: "setSellOrderUpi",
+      args: [v.orderId, userEncUpi, v.updatedAmount]
+    }),
+    value: 0n,
+    meta: { relayIdentity: senderIdentity }
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).andThen(
+        (prepared) => submitPreparedTx({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/orders/internal/routing/client.ts
+var import_viem16 = require("viem");
+
+// src/contracts/errors.ts
+var contractErrors = {
+  // Access control
+  NotAdmin: "NOT_ADMIN",
+  NotSuperAdmin: "NOT_SUPER_ADMIN",
+  NotAuthorized: "NOT_AUTHORIZED",
+  NotSelf: "NOT_SELF",
+  NotWhitelisted: "NOT_WHITELISTED",
+  NotCircleAdmin: "NOT_CIRCLE_ADMIN",
+  // Circle / community management
+  InvalidName: "INVALID_NAME",
+  InvalidCommunityUrl: "INVALID_COMMUNITY_URL",
+  InvalidAdminCommunityUrl: "INVALID_ADMIN_COMMUNITY_URL",
+  AdminAlreadyHasCircle: "ADMIN_ALREADY_HAS_CIRCLE",
+  CircleNameAlreadyTaken: "CIRCLE_NAME_ALREADY_TAKEN",
+  P2PStakeConfigNotSet: "P2P_STAKE_CONFIG_NOT_SET",
+  InsufficientP2PStake: "INSUFFICIENT_P2P_STAKE",
+  P2PTokenNotSet: "P2P_TOKEN_NOT_SET",
+  P2PUnstakeRequestPending: "P2P_UNSTAKE_REQUEST_PENDING",
+  NoP2PUnstakeRequest: "NO_P2P_UNSTAKE_REQUEST",
+  P2PUnstakeCooldownNotPassed: "P2P_UNSTAKE_COOLDOWN_NOT_PASSED",
+  SlashAmountExceedsStake: "SLASH_AMOUNT_EXCEEDS_STAKE",
+  CircleNotActive: "CIRCLE_NOT_ACTIVE",
+  InvalidCircleId: "INVALID_CIRCLE_ID",
+  CurrencyMismatch: "CURRENCY_MISMATCH",
+  CircleFull: "CIRCLE_FULL",
+  CircleIdMismatch: "CIRCLE_ID_MISMATCH",
+  DuplicateAccountName: "DUPLICATE_ACCOUNT_NAME",
+  EmptyName: "EMPTY_NAME",
+  AccountBoundToAnotherCircle: "ACCOUNT_BOUND_TO_ANOTHER_CIRCLE",
+  ExitAmountExceededCircleBalance: "EXIT_AMOUNT_EXCEEDED_CIRCLE_BALANCE",
+  UndelegationAmountTooHigh: "UNDELEGATION_AMOUNT_TOO_HIGH",
+  // Exchange / order lifecycle
+  ExchangeNotOperational: "EXCHANGE_NOT_OPERATIONAL",
+  OrderNotPlaced: "ORDER_NOT_PLACED",
+  OrderNotPaid: "ORDER_NOT_PAID",
+  OrderStatusInvalid: "ORDER_STATUS_INVALID",
+  OrderExpired: "ORDER_EXPIRED",
+  OrderAlreadyPaid: "ORDER_ALREADY_PAID",
+  OrderAlreadyCompleted: "ORDER_ALREADY_COMPLETED",
+  InvalidOrderType: "INVALID_ORDER_TYPE",
+  OrderTypeIncorrect: "ORDER_TYPE_INCORRECT",
+  OrderNotAccepted: "ORDER_NOT_ACCEPTED",
+  OrderNotAssigned: "ORDER_NOT_ASSIGNED",
+  OrderAmountExceedsLimit: "ORDER_AMOUNT_EXCEEDS_LIMIT",
+  InvalidOrderAmount: "INVALID_ORDER_AMOUNT",
+  InvalidOrderAmountToCoverFee: "INVALID_ORDER_AMOUNT_TO_COVER_FEE",
+  InvalidOrderId: "INVALID_ORDER_ID",
+  OrderTooEarlyForReassignment: "ORDER_TOO_EARLY_FOR_REASSIGNMENT",
+  OrderTooLateForReassignment: "ORDER_TOO_LATE_FOR_REASSIGNMENT",
+  ReAssignmentNotRequired: "REASSIGNMENT_NOT_REQUIRED",
+  TipAlreadyGiven: "TIP_ALREADY_GIVEN",
+  CashbackTransferFailed: "CASHBACK_TRANSFER_FAILED",
+  // Order limits
+  DailyBuyOrderLimitExceeded: "DAILY_BUY_ORDER_LIMIT_EXCEEDED",
+  MonthlyBuyOrderLimitExceeded: "MONTHLY_BUY_ORDER_LIMIT_EXCEEDED",
+  SellOrderAmountLimitExceeded: "SELL_ORDER_AMOUNT_LIMIT_EXCEEDED",
+  BuyOrderAmountExceedsLimit: "BUY_ORDER_AMOUNT_EXCEEDS_LIMIT",
+  SellOrderAmountExceedsLimit: "SELL_ORDER_AMOUNT_EXCEEDS_LIMIT",
+  BuyAmountExceedsUsdcLimit: "BUY_AMOUNT_EXCEEDS_USDC_LIMIT",
+  SellAmountExceedsFiatLimit: "SELL_AMOUNT_EXCEEDS_FIAT_LIMIT",
+  DailyVolumeLimitExceeded: "DAILY_VOLUME_LIMIT_EXCEEDED",
+  MonthlyVolumeLimitExceeded: "MONTHLY_VOLUME_LIMIT_EXCEEDED",
+  UserYearlyVolumeLimitExceeded: "USER_YEARLY_VOLUME_LIMIT_EXCEEDED",
+  // Dispute
+  DisputeTimeNotReached: "DISPUTE_TIME_NOT_REACHED",
+  DisputeTimeExpired: "DISPUTE_TIME_EXPIRED",
+  InvalidOrderStatusToRaiseDispute: "INVALID_ORDER_STATUS_TO_RAISE_DISPUTE",
+  DisputeNotRaised: "DISPUTE_NOT_RAISED",
+  CannotRaiseDisputeTwice: "CANNOT_RAISE_DISPUTE_TWICE",
+  DisputeAlreadySettled: "DISPUTE_ALREADY_SETTLED",
+  TransactionIdMismatch: "TRANSACTION_ID_MISMATCH",
+  AccountNumberMismatch: "ACCOUNT_NUMBER_MISMATCH",
+  NotPaidBuyOrder: "NOT_PAID_BUY_ORDER",
+  // Payment channels
+  PaymentChannelNotFound: "PAYMENT_CHANNEL_NOT_FOUND",
+  PaymentChannelNotActive: "PAYMENT_CHANNEL_NOT_ACTIVE",
+  PaymentChannelNotApproved: "PAYMENT_CHANNEL_NOT_APPROVED",
+  PaymentChannelNotRejected: "PAYMENT_CHANNEL_NOT_REJECTED",
+  InvalidPaymentChannelId: "INVALID_PAYMENT_CHANNEL_ID",
+  DuplicatePaymentChannel: "DUPLICATE_PAYMENT_CHANNEL",
+  OldPaymentChannelNotFound: "OLD_PAYMENT_CHANNEL_NOT_FOUND",
+  NewPaymentChannelNotFound: "NEW_PAYMENT_CHANNEL_NOT_FOUND",
+  SamePaymentChannel: "SAME_PAYMENT_CHANNEL",
+  OldPaymentChannelShouldBeInactive: "OLD_PAYMENT_CHANNEL_SHOULD_BE_INACTIVE",
+  NewPaymentChannelShouldBeActive: "NEW_PAYMENT_CHANNEL_SHOULD_BE_ACTIVE",
+  OngoingOrderOnPaymentChannel: "ONGOING_ORDER_ON_PAYMENT_CHANNEL",
+  UpiAlreadySent: "UPI_ALREADY_SENT",
+  InvalidOrderUpi: "INVALID_ORDER_UPI",
+  NoFiatLiquidity: "NO_FIAT_LIQUIDITY",
+  // Merchant
+  NotEnoughEligibleMerchants: "NOT_ENOUGH_ELIGIBLE_MERCHANTS",
+  MerchantNotRegistered: "MERCHANT_NOT_REGISTERED",
+  MerchantNotApproved: "MERCHANT_NOT_APPROVED",
+  MerchantAlreadyRegistered: "MERCHANT_ALREADY_REGISTERED",
+  MerchantAlreadyRejected: "MERCHANT_ALREADY_REJECTED",
+  MerchantBlacklisted: "MERCHANT_BLACKLISTED",
+  MerchantNotBlacklisted: "MERCHANT_NOT_BLACKLISTED",
+  MerchantAlreadyBlacklisted: "MERCHANT_ALREADY_BLACKLISTED",
+  MerchantHasOngoingOrders: "MERCHANT_HAS_ONGOING_ORDERS",
+  MerchantNotFullfilledEligibilityThreshold: "MERCHANT_NOT_FULLFILLED_ELIGIBILITY_THRESHOLD",
+  InvalidMerchant: "INVALID_MERCHANT",
+  // Staking / unstaking
+  StakeAmountTooLow: "STAKE_AMOUNT_TOO_LOW",
+  AdditionalStakeNotAllowed: "ADDITIONAL_STAKE_NOT_ALLOWED",
+  UnstakeRequestPending: "UNSTAKE_REQUEST_PENDING",
+  UnstakeRequestNotPending: "UNSTAKE_REQUEST_NOT_PENDING",
+  UnstakeAmountExceeded: "UNSTAKE_AMOUNT_EXCEEDED",
+  ZeroUnstakeAmount: "ZERO_UNSTAKE_AMOUNT",
+  NoWithdrawableAmount: "NO_WITHDRAWABLE_AMOUNT",
+  NoStake: "NO_STAKE",
+  NoStakers: "NO_STAKERS",
+  InsufficientStakedAmount: "INSUFFICIENT_STAKED_AMOUNT",
+  CooldownNotPassed: "COOLDOWN_NOT_PASSED",
+  ClaimableRewardsNotAvailable: "CLAIMABLE_REWARDS_NOT_AVAILABLE",
+  // Delegation
+  ExitWouldBreachDelegationInvariant: "EXIT_WOULD_BREACH_DELEGATION_INVARIANT",
+  AggregateDelegationExceedsTotalStaked: "AGGREGATE_DELEGATION_EXCEEDS_TOTAL_STAKED",
+  InsufficientMerchantRewards: "INSUFFICIENT_MERCHANT_REWARDS",
+  // Migration
+  InvalidMigrationStatus: "INVALID_MIGRATION_STATUS",
+  MigrationRequestNotPending: "MIGRATION_REQUEST_NOT_PENDING",
+  MigrationAlreadyRequested: "MIGRATION_ALREADY_REQUESTED",
+  // Token / currency
+  TokenAlreadyExists: "TOKEN_ALREADY_EXISTS",
+  TokenNotFound: "TOKEN_NOT_FOUND",
+  TokenEmpty: "TOKEN_EMPTY",
+  CurrencyNotSupported: "CURRENCY_NOT_SUPPORTED",
+  InvalidCurrency: "INVALID_CURRENCY",
+  // USDC / transfer
+  UsdtTransferFailed: "USDC_TRANSFER_FAILED",
+  UsdtTransferFailedWithErrorMessage: "USDC_TRANSFER_FAILED_WITH_ERROR_MESSAGE",
+  UsdtTransferFailedWithPanic: "USDC_TRANSFER_FAILED_WITH_PANIC",
+  InsufficientAllowance: "INSUFFICIENT_ALLOWANCE",
+  // ZK Passport
+  ZKPassportVerifierNotSet: "ZK_PASSPORT_VERIFIER_NOT_SET",
+  ZKPassportDomainEmpty: "ZK_PASSPORT_DOMAIN_EMPTY",
+  ZKPassportScopeEmpty: "ZK_PASSPORT_SCOPE_EMPTY",
+  PassportAlreadyVerified: "PASSPORT_ALREADY_VERIFIED",
+  ZKPassportProofInvalid: "ZK_PASSPORT_PROOF_INVALID",
+  ZKPassportIdentifierAlreadyVerified: "ZK_PASSPORT_IDENTIFIER_ALREADY_VERIFIED",
+  ZKPassportInvalidScope: "ZK_PASSPORT_INVALID_SCOPE",
+  ZKPassportUnexpectedSender: "ZK_PASSPORT_UNEXPECTED_SENDER",
+  ZKPassportAgeBelowMinimum: "ZK_PASSPORT_AGE_BELOW_MINIMUM",
+  ZKPassportMinAgeTooHigh: "ZK_PASSPORT_MIN_AGE_TOO_HIGH",
+  // Chainlink / oracle
+  UnexpectedRequestId: "UNEXPECTED_REQUEST_ID",
+  OnlyRouterCanFulfill: "ONLY_ROUTER_CAN_FULFILL",
+  RequestFailed: "REQUEST_FAILED",
+  SourceCodeMismatch: "SOURCE_CODE_MISMATCH",
+  ZeroMarketPrice: "ZERO_MARKET_PRICE",
+  InvalidComputedPrices: "INVALID_COMPUTED_PRICES",
+  NotPriceUpdaterForCurrency: "NOT_PRICE_UPDATER_FOR_CURRENCY",
+  ThresholdNotConfigured: "THRESHOLD_NOT_CONFIGURED",
+  SlippageExceeded: "SLIPPAGE_EXCEEDED",
+  // Reputation / verification
+  UserHasNoReputation: "USER_HAS_NO_REPUTATION",
+  ZeroReputationPoints: "ZERO_REPUTATION_POINTS",
+  NoReputation: "NO_REPUTATION",
+  InsufficientRP: "INSUFFICIENT_RP",
+  NullifierAlreadyVerified: "NULLIFIER_ALREADY_VERIFIED",
+  VerificationFailed: "VERIFICATION_FAILED",
+  InvalidSocialPlatform: "INVALID_SOCIAL_PLATFORM",
+  SocialAlreadyVerified: "SOCIAL_ALREADY_VERIFIED",
+  YearFieldNotInProof: "YEAR_FIELD_NOT_IN_PROOF",
+  UserIdFieldNotInProof: "USER_ID_FIELD_NOT_IN_PROOF",
+  UserIdAlreadyVerified: "USER_ID_ALREADY_VERIFIED",
+  UsernameAlreadyVerified: "USERNAME_ALREADY_VERIFIED",
+  UsernameNotInProof: "USERNAME_NOT_IN_PROOF",
+  LinkedInOnlyRpUpdates: "LINKEDIN_ONLY_RP_UPDATES",
+  FacebookOnlyRpUpdates: "FACEBOOK_ONLY_RP_UPDATES",
+  // Voting / referral
+  AlreadyReferred: "ALREADY_REFERRED",
+  SelfReferralNotAllowed: "SELF_REFERRAL_NOT_ALLOWED",
+  NotEligibleToRefer: "NOT_ELIGIBLE_TO_REFER",
+  MerchantMonthlyReferralLimitReached: "MERCHANT_MONTHLY_REFERRAL_LIMIT_REACHED",
+  NoRecommender: "NO_RECOMMENDER",
+  RecommendationAlreadyClaimed: "RECOMMENDATION_ALREADY_CLAIMED",
+  CannotVoteYourself: "CANNOT_VOTE_YOURSELF",
+  VotesPerEpochExceeded: "VOTES_PER_EPOCH_EXCEEDED",
+  AlreadyVoted: "ALREADY_VOTED",
+  FunctionNotFound: "FUNCTION_NOT_FOUND",
+  // Campaign
+  CampaignNotActive: "CAMPAIGN_NOT_ACTIVE",
+  InvalidManagerDetails: "INVALID_MANAGER_DETAILS",
+  UnclaimedRewardsExist: "UNCLAIMED_REWARDS_EXIST",
+  RewardAlreadyClaimed: "REWARD_ALREADY_CLAIMED",
+  OnlyNewUsersAllowed: "ONLY_NEW_USERS_ALLOWED",
+  ManagerNotFound: "MANAGER_NOT_FOUND",
+  ManagerInactive: "MANAGER_INACTIVE",
+  NoRewards: "NO_REWARDS",
+  InvalidCampaignId: "INVALID_CAMPAIGN_ID",
+  CannotClaimRevenueForCurrentMonth: "CANNOT_CLAIM_REVENUE_FOR_CURRENT_MONTH",
+  // Referral reward config
+  RewardPercentageTooHigh: "REWARD_PERCENTAGE_TOO_HIGH",
+  // Signature / nonce
+  NonceAlreadyUsed: "NONCE_ALREADY_USED",
+  SignatureValidationFailed: "SIGNATURE_VALIDATION_FAILED",
+  // Misc
+  InvalidAddress: "INVALID_ADDRESS",
+  InvalidBlockAmount: "INVALID_BLOCK_AMOUNT",
+  InvalidAmount: "INVALID_AMOUNT",
+  InvalidInput: "INVALID_INPUT",
+  InvalidStatusTransition: "INVALID_STATUS_TRANSITION",
+  ArrayLengthMismatch: "ARRAY_LENGTH_MISMATCH",
+  UserIsBlacklisted: "USER_IS_BLACKLISTED",
+  ZeroAddress: "ZERO_ADDRESS",
+  ReentrancyGuard: "REENTRANCY_GUARD",
+  BatchTooLarge: "BATCH_TOO_LARGE",
+  UnderflowSubtraction: "UNDERFLOW_SUBTRACTION",
+  TargetLongerThanData: "TARGET_LONGER_THAN_DATA"
+};
+var hexContractErrors = {
+  // Access control
+  "0x7bfa4b9f": contractErrors.NotAdmin,
+  "0x16c726b1": contractErrors.NotSuperAdmin,
+  "0xea8e4eb5": contractErrors.NotAuthorized,
+  "0x29c3b7ee": contractErrors.NotSelf,
+  "0x584a7938": contractErrors.NotWhitelisted,
+  "0xa8143fbc": contractErrors.NotCircleAdmin,
+  // Circle / community management
+  "0x430f13b3": contractErrors.InvalidName,
+  "0xe7cbf75a": contractErrors.InvalidCommunityUrl,
+  "0x3762bfee": contractErrors.InvalidAdminCommunityUrl,
+  "0x201c1ffc": contractErrors.AdminAlreadyHasCircle,
+  "0x6540a51d": contractErrors.CircleNameAlreadyTaken,
+  "0xcadc6786": contractErrors.P2PStakeConfigNotSet,
+  "0x78317f44": contractErrors.InsufficientP2PStake,
+  "0x18eda032": contractErrors.P2PTokenNotSet,
+  "0xdab11ea6": contractErrors.P2PUnstakeRequestPending,
+  "0xeb1ce40b": contractErrors.NoP2PUnstakeRequest,
+  "0xbf2d0ba1": contractErrors.P2PUnstakeCooldownNotPassed,
+  "0x06b663af": contractErrors.SlashAmountExceedsStake,
+  "0xff9b022c": contractErrors.CircleNotActive,
+  "0x3d90c0a6": contractErrors.InvalidCircleId,
+  "0xfb42a67d": contractErrors.CurrencyMismatch,
+  "0xf2775265": contractErrors.CircleFull,
+  "0x784b6c3c": contractErrors.CircleIdMismatch,
+  "0xee240e49": contractErrors.DuplicateAccountName,
+  "0x2ef13105": contractErrors.EmptyName,
+  "0x1b5433c8": contractErrors.AccountBoundToAnotherCircle,
+  "0x549e2555": contractErrors.ExitAmountExceededCircleBalance,
+  "0x865b21e1": contractErrors.UndelegationAmountTooHigh,
+  // Exchange / order lifecycle
+  "0x4bbac5de": contractErrors.ExchangeNotOperational,
+  "0x58db8ed6": contractErrors.OrderNotPlaced,
+  "0x1e3b9629": contractErrors.OrderNotPaid,
+  "0x181b1b2e": contractErrors.OrderStatusInvalid,
+  "0xc56873ba": contractErrors.OrderExpired,
+  "0x7f61b868": contractErrors.OrderAlreadyPaid,
+  "0x03683687": contractErrors.OrderAlreadyCompleted,
+  "0x688c176f": contractErrors.InvalidOrderType,
+  "0x2e757a60": contractErrors.OrderTypeIncorrect,
+  "0x6b1b90b4": contractErrors.OrderNotAccepted,
+  "0x1775c43e": contractErrors.OrderNotAssigned,
+  "0xf42e41a1": contractErrors.OrderAmountExceedsLimit,
+  "0x93845d68": contractErrors.InvalidOrderAmount,
+  "0x138b9d5a": contractErrors.InvalidOrderAmountToCoverFee,
+  "0x5d706033": contractErrors.InvalidOrderId,
+  "0xbb776720": contractErrors.OrderTooEarlyForReassignment,
+  "0x20d5910f": contractErrors.OrderTooLateForReassignment,
+  "0xccd87bf0": contractErrors.ReAssignmentNotRequired,
+  "0xb20277f8": contractErrors.TipAlreadyGiven,
+  "0xdf9f707c": contractErrors.CashbackTransferFailed,
+  // Order limits
+  "0xe595a7bf": contractErrors.DailyBuyOrderLimitExceeded,
+  "0x675dbc86": contractErrors.MonthlyBuyOrderLimitExceeded,
+  "0x64301cb8": contractErrors.SellOrderAmountLimitExceeded,
+  "0x91da284f": contractErrors.BuyOrderAmountExceedsLimit,
+  "0xb407b9ec": contractErrors.SellOrderAmountExceedsLimit,
+  "0x4b29cf0a": contractErrors.BuyAmountExceedsUsdcLimit,
+  "0xbba2edf9": contractErrors.SellAmountExceedsFiatLimit,
+  "0x7e2ee654": contractErrors.DailyVolumeLimitExceeded,
+  "0x49de1789": contractErrors.MonthlyVolumeLimitExceeded,
+  "0xb14a1ff3": contractErrors.UserYearlyVolumeLimitExceeded,
+  // Dispute
+  "0x07a2454f": contractErrors.DisputeTimeNotReached,
+  "0xb28c3e29": contractErrors.DisputeTimeExpired,
+  "0x2a829f07": contractErrors.InvalidOrderStatusToRaiseDispute,
+  "0x88d039ce": contractErrors.DisputeNotRaised,
+  "0x3764a75c": contractErrors.CannotRaiseDisputeTwice,
+  "0x866e9f89": contractErrors.DisputeAlreadySettled,
+  "0x6131d13d": contractErrors.TransactionIdMismatch,
+  "0x8ec051b8": contractErrors.AccountNumberMismatch,
+  "0xf8bfad32": contractErrors.NotPaidBuyOrder,
+  // Payment channels
+  "0x552ff5ec": contractErrors.PaymentChannelNotFound,
+  "0xfccd93cf": contractErrors.PaymentChannelNotActive,
+  "0x6764f4d6": contractErrors.PaymentChannelNotApproved,
+  "0xab284291": contractErrors.PaymentChannelNotRejected,
+  "0x99c8ef4d": contractErrors.InvalidPaymentChannelId,
+  "0x0569ab3e": contractErrors.DuplicatePaymentChannel,
+  "0xff4f83ca": contractErrors.OldPaymentChannelNotFound,
+  "0xb1198199": contractErrors.NewPaymentChannelNotFound,
+  "0xc905b99a": contractErrors.SamePaymentChannel,
+  "0xcedb41f1": contractErrors.OldPaymentChannelShouldBeInactive,
+  "0x487add97": contractErrors.NewPaymentChannelShouldBeActive,
+  "0x6d4c3f9e": contractErrors.OngoingOrderOnPaymentChannel,
+  "0xc1654697": contractErrors.UpiAlreadySent,
+  "0xaa60ec26": contractErrors.InvalidOrderUpi,
+  "0x81c2b982": contractErrors.NoFiatLiquidity,
+  // Merchant
+  "0x5d04ff4c": contractErrors.NotEnoughEligibleMerchants,
+  "0xa6af7ebe": contractErrors.MerchantNotRegistered,
+  "0x7290a612": contractErrors.MerchantNotApproved,
+  "0xf4a1e014": contractErrors.MerchantAlreadyRegistered,
+  "0x8713aaba": contractErrors.MerchantAlreadyRejected,
+  "0x9ae55bc7": contractErrors.MerchantBlacklisted,
+  "0x0ee0b659": contractErrors.MerchantNotBlacklisted,
+  "0x5f765689": contractErrors.MerchantAlreadyBlacklisted,
+  "0x9c54e5a8": contractErrors.MerchantHasOngoingOrders,
+  "0x70d753bd": contractErrors.MerchantNotFullfilledEligibilityThreshold,
+  "0xc0b6c919": contractErrors.InvalidMerchant,
+  // Staking / unstaking
+  "0x3fd2347e": contractErrors.StakeAmountTooLow,
+  "0x703cde0a": contractErrors.AdditionalStakeNotAllowed,
+  "0xa9de99ae": contractErrors.UnstakeRequestPending,
+  "0x0b7c70f3": contractErrors.UnstakeRequestNotPending,
+  "0xe665491f": contractErrors.UnstakeAmountExceeded,
+  "0x2d3087f9": contractErrors.ZeroUnstakeAmount,
+  "0x1b1d7861": contractErrors.NoWithdrawableAmount,
+  "0xcacf989a": contractErrors.NoStake,
+  "0x21311aa3": contractErrors.NoStakers,
+  "0xd06ff88e": contractErrors.InsufficientStakedAmount,
+  "0x9ab7872d": contractErrors.CooldownNotPassed,
+  "0x73380d99": contractErrors.ClaimableRewardsNotAvailable,
+  // Delegation
+  "0xec4b3ce6": contractErrors.ExitWouldBreachDelegationInvariant,
+  "0x8f90a426": contractErrors.AggregateDelegationExceedsTotalStaked,
+  "0x2cc11576": contractErrors.InsufficientMerchantRewards,
+  // Migration
+  "0x92aa7d0f": contractErrors.InvalidMigrationStatus,
+  "0x7ff47425": contractErrors.MigrationRequestNotPending,
+  "0x88ddec46": contractErrors.MigrationAlreadyRequested,
+  // Token / currency
+  "0xc991cbb1": contractErrors.TokenAlreadyExists,
+  "0xcbdb7b30": contractErrors.TokenNotFound,
+  "0x9f11a53f": contractErrors.TokenEmpty,
+  "0x02a6fdd2": contractErrors.CurrencyNotSupported,
+  "0xf5993428": contractErrors.InvalidCurrency,
+  // USDC / transfer
+  "0x149f9fca": contractErrors.UsdtTransferFailed,
+  "0x47bfece5": contractErrors.UsdtTransferFailedWithErrorMessage,
+  "0x279bbc0c": contractErrors.UsdtTransferFailedWithPanic,
+  "0xfb8f41b2": contractErrors.InsufficientAllowance,
+  // ZK Passport
+  "0xfd8d4a6d": contractErrors.ZKPassportVerifierNotSet,
+  "0xb87078f9": contractErrors.ZKPassportDomainEmpty,
+  "0x5eadc4c2": contractErrors.ZKPassportScopeEmpty,
+  "0x7642fe15": contractErrors.PassportAlreadyVerified,
+  "0x1fa24b35": contractErrors.ZKPassportProofInvalid,
+  "0x36bdb7b6": contractErrors.ZKPassportIdentifierAlreadyVerified,
+  "0xd13a7934": contractErrors.ZKPassportInvalidScope,
+  "0x69f5bfe7": contractErrors.ZKPassportUnexpectedSender,
+  "0x0464115c": contractErrors.ZKPassportAgeBelowMinimum,
+  "0x48183836": contractErrors.ZKPassportMinAgeTooHigh,
+  // Chainlink / oracle
+  "0x7f73f237": contractErrors.UnexpectedRequestId,
+  "0xab948796": contractErrors.OnlyRouterCanFulfill,
+  "0x61982c98": contractErrors.RequestFailed,
+  "0xab66be18": contractErrors.SourceCodeMismatch,
+  "0xff2826ef": contractErrors.ZeroMarketPrice,
+  "0xbb6c216c": contractErrors.InvalidComputedPrices,
+  "0x3a8fbef4": contractErrors.NotPriceUpdaterForCurrency,
+  "0x3e2c36f2": contractErrors.ThresholdNotConfigured,
+  "0x71c4efed": contractErrors.SlippageExceeded,
+  // Reputation / verification
+  "0x071ea33c": contractErrors.UserHasNoReputation,
+  "0xd2e1e6e0": contractErrors.ZeroReputationPoints,
+  "0x3c0ca622": contractErrors.NoReputation,
+  "0x412dd2b1": contractErrors.InsufficientRP,
+  "0x0f165e7b": contractErrors.NullifierAlreadyVerified,
+  "0x439cc0cd": contractErrors.VerificationFailed,
+  "0x2366073b": contractErrors.InvalidSocialPlatform,
+  "0x2f850b6b": contractErrors.SocialAlreadyVerified,
+  "0x466f52a8": contractErrors.YearFieldNotInProof,
+  "0x4d460588": contractErrors.UserIdFieldNotInProof,
+  "0xa18ea4e8": contractErrors.UserIdAlreadyVerified,
+  "0x69470b13": contractErrors.UsernameAlreadyVerified,
+  "0x8390b2dd": contractErrors.UsernameNotInProof,
+  "0xef053cf4": contractErrors.LinkedInOnlyRpUpdates,
+  "0x355b0709": contractErrors.FacebookOnlyRpUpdates,
+  // Voting / referral
+  "0x7aabdfe3": contractErrors.AlreadyReferred,
+  "0x83463f4a": contractErrors.SelfReferralNotAllowed,
+  "0x69f6994a": contractErrors.NotEligibleToRefer,
+  "0x1b19ad97": contractErrors.MerchantMonthlyReferralLimitReached,
+  "0x944a2241": contractErrors.NoRecommender,
+  "0x0ece93a6": contractErrors.RecommendationAlreadyClaimed,
+  "0x74785d0f": contractErrors.CannotVoteYourself,
+  "0xc26d5f75": contractErrors.VotesPerEpochExceeded,
+  "0x7c9a1cf9": contractErrors.AlreadyVoted,
+  "0x403e7fa6": contractErrors.FunctionNotFound,
+  // Campaign
+  "0x7a551e38": contractErrors.CampaignNotActive,
+  "0x668ca75d": contractErrors.InvalidManagerDetails,
+  "0x2f950361": contractErrors.UnclaimedRewardsExist,
+  "0x626b7c00": contractErrors.RewardAlreadyClaimed,
+  "0x902ade67": contractErrors.OnlyNewUsersAllowed,
+  "0x22a5e34b": contractErrors.ManagerNotFound,
+  "0xa1610e37": contractErrors.ManagerInactive,
+  "0x3fb087f4": contractErrors.NoRewards,
+  "0x3eedee0f": contractErrors.InvalidCampaignId,
+  "0x302c5138": contractErrors.CannotClaimRevenueForCurrentMonth,
+  // Referral reward config
+  "0x074a6991": contractErrors.RewardPercentageTooHigh,
+  // Signature / nonce
+  "0x1fb09b80": contractErrors.NonceAlreadyUsed,
+  "0x2fdec18b": contractErrors.SignatureValidationFailed,
+  // Misc
+  "0xe6c4247b": contractErrors.InvalidAddress,
+  "0x3eb17c88": contractErrors.InvalidBlockAmount,
+  "0x2c5211c6": contractErrors.InvalidAmount,
+  "0xb4fa3fb3": contractErrors.InvalidInput,
+  "0x1117a646": contractErrors.InvalidStatusTransition,
+  "0xa24a13a6": contractErrors.ArrayLengthMismatch,
+  "0xebb6f34b": contractErrors.UserIsBlacklisted,
+  "0xd92e233d": contractErrors.ZeroAddress,
+  "0x8beb9d16": contractErrors.ReentrancyGuard,
+  "0xbb1cb70b": contractErrors.BatchTooLarge,
+  "0xd97cf1ba": contractErrors.UnderflowSubtraction,
+  "0xc9b16952": contractErrors.TargetLongerThanData
+};
+
+// src/contracts/order-flow/index.ts
+var import_neverthrow9 = require("neverthrow");
+
+// src/orders/internal/routing/errors.ts
+var OrderRoutingError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "OrderRoutingError";
+  }
+};
+
+// src/orders/internal/routing/validation.ts
+var import_zod6 = require("zod");
+var ZodCircleScoreStateSchema = import_zod6.z.object({
+  activeMerchantsCount: import_zod6.z.coerce.number()
+});
+var ZodCircleMetricsForRoutingSchema = import_zod6.z.object({
+  circleScore: import_zod6.z.coerce.number(),
+  circleStatus: import_zod6.z.string(),
+  scoreState: ZodCircleScoreStateSchema
+});
+var ZodCircleForRoutingSchema = import_zod6.z.object({
+  circleId: import_zod6.z.string(),
+  currency: import_zod6.z.string(),
+  metrics: ZodCircleMetricsForRoutingSchema
+});
+var ZodCirclesForRoutingResponseSchema = import_zod6.z.object({
+  circles: import_zod6.z.array(ZodCircleForRoutingSchema)
+});
+var ZodCheckCircleEligibilityParamsSchema = import_zod6.z.object({
+  circleId: import_zod6.z.bigint(),
+  currency: import_zod6.z.string(),
+  user: ZodAddressSchema,
+  usdtAmount: import_zod6.z.bigint(),
+  fiatAmount: import_zod6.z.bigint(),
+  orderType: import_zod6.z.bigint(),
+  preferredPCConfigId: import_zod6.z.bigint()
+});
+var ZodSelectCircleParamsSchema = import_zod6.z.object({
+  currency: import_zod6.z.string().min(1),
+  user: ZodAddressSchema,
+  usdtAmount: import_zod6.z.bigint(),
+  fiatAmount: import_zod6.z.bigint(),
+  orderType: import_zod6.z.bigint(),
+  preferredPCConfigId: import_zod6.z.bigint()
+});
+
+// src/contracts/order-flow/index.ts
+function checkCircleEligibility(publicClient, contractAddress, params, logger = noopLogger) {
+  return validate(
+    ZodCheckCircleEligibilityParamsSchema,
+    params,
+    (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
+  ).asyncAndThen((validated) => {
+    logger.debug("checking on-chain eligibility", {
+      circleId: String(validated.circleId),
+      contractAddress
+    });
+    return import_neverthrow9.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: contractAddress,
+        abi: ABIS.FACETS.ORDER_FLOW,
+        functionName: "getAssignableMerchantsFromCircle",
+        args: [
+          validated.circleId,
+          1n,
+          validated.currency,
+          validated.user,
+          validated.usdtAmount,
+          validated.fiatAmount,
+          validated.orderType,
+          validated.preferredPCConfigId
+        ]
+      }),
+      (error) => new OrderRoutingError("Eligibility check failed", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { circleId: String(params.circleId) }
+      })
+    );
+  }).map((merchants) => {
+    const arr = merchants;
+    const eligible = arr.length >= 1;
+    logger.debug("eligibility check result", {
+      circleId: String(params.circleId),
+      assignableMerchants: arr.length,
+      eligible
+    });
+    return eligible;
+  });
+}
+
+// src/contracts/p2p-config/index.ts
+var import_neverthrow10 = require("neverthrow");
+var import_viem12 = require("viem");
+
+// src/prices/errors.ts
+var PricesError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PricesError";
+  }
+};
+
+// src/prices/validation.ts
+var import_zod7 = require("zod");
+var ZodCurrencyScopedParamsSchema = import_zod7.z.object({
+  currency: ZodCurrencySchema
+});
+
+// src/contracts/p2p-config/index.ts
+function getPriceConfig(publicClient, diamondAddress, params) {
+  return validate(
+    ZodCurrencyScopedParamsSchema,
+    params,
+    (message, cause, data) => new PricesError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow10.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: diamondAddress,
+        abi: ABIS.FACETS.CONFIG,
+        functionName: "getPriceConfig",
+        args: [(0, import_viem12.stringToHex)(validated.currency, { size: 32 })]
+      }),
+      (error) => new PricesError("Failed to read price config", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { currency: validated.currency, diamondAddress }
+      })
+    )
+  );
+}
+function getReputationPerUsdcLimit(publicClient, diamondAddress, params) {
+  return validate(
+    ZodCurrencyScopedParamsSchema,
+    params,
+    (message, cause, data) => new PricesError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow10.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: diamondAddress,
+        abi: ABIS.DIAMOND,
+        functionName: "getRpPerUsdtLimitRational",
+        args: [(0, import_viem12.stringToHex)(validated.currency, { size: 32 })]
+      }),
+      (error) => new PricesError("Failed to read reputation-per-USDC limit", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { currency: validated.currency, diamondAddress }
+      })
+    ).map(([numerator, denominator]) => ({
+      numerator,
+      denominator,
+      multiplier: numerator > 0n ? Number(denominator) / Number(numerator) : 0
+    }))
+  );
+}
+
+// src/contracts/reputation-manager/writes.ts
+var import_neverthrow11 = require("neverthrow");
+var import_viem13 = require("viem");
+
+// src/zkkyc/errors.ts
+var ZkkycError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ZkkycError";
+  }
+};
+
+// src/zkkyc/validation.ts
+var import_zod8 = require("zod");
+var ZodAnonAadharProofParamsSchema = import_zod8.z.object({
+  nullifierSeed: import_zod8.z.bigint(),
+  nullifier: import_zod8.z.bigint(),
+  timestamp: import_zod8.z.bigint(),
+  signal: import_zod8.z.bigint(),
+  revealArray: import_zod8.z.tuple([import_zod8.z.bigint(), import_zod8.z.bigint(), import_zod8.z.bigint(), import_zod8.z.bigint()]),
+  packedGroth16Proof: import_zod8.z.tuple([
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint(),
+    import_zod8.z.bigint()
+  ])
+});
+var ZodSocialVerifyParamsSchema = import_zod8.z.object({
+  _socialName: import_zod8.z.string(),
+  proofs: import_zod8.z.array(
+    import_zod8.z.object({
+      claimInfo: import_zod8.z.object({
+        provider: import_zod8.z.string(),
+        parameters: import_zod8.z.string(),
+        context: import_zod8.z.string()
+      }),
+      signedClaim: import_zod8.z.object({
+        claim: import_zod8.z.object({
+          identifier: import_zod8.z.string(),
+          owner: ZodAddressSchema,
+          timestampS: import_zod8.z.number(),
+          epoch: import_zod8.z.number()
+        }),
+        signatures: import_zod8.z.array(import_zod8.z.string())
+      })
+    })
+  )
+});
+var ZodSolidityVerifierParametersSchema = import_zod8.z.object({
+  version: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+    message: "Version must be a hex string"
+  }),
+  proofVerificationData: import_zod8.z.object({
+    vkeyHash: import_zod8.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+      message: "Invalid bytes32 hex string"
+    }),
+    proof: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+      message: "Proof must be a hex string"
+    }),
+    publicInputs: import_zod8.z.array(
+      import_zod8.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+        message: "Each public input must be a valid bytes32 hex string"
+      })
+    )
+  }),
+  committedInputs: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+    message: "Committed inputs must be a hex string"
+  }),
+  serviceConfig: import_zod8.z.object({
+    validityPeriodInSeconds: import_zod8.z.number().int().nonnegative(),
+    domain: import_zod8.z.string(),
+    scope: import_zod8.z.string(),
+    devMode: import_zod8.z.boolean()
+  })
+});
+var ZodZkPassportRegisterParamsSchema = import_zod8.z.object({
+  params: ZodSolidityVerifierParametersSchema,
+  isIDCard: import_zod8.z.boolean()
+});
+
+// src/contracts/reputation-manager/writes.ts
+function prepareSocialVerify(reputationManagerAddress, params) {
+  return validate(
+    ZodSocialVerifyParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow11.Result.fromThrowable(
+      () => ({
+        to: reputationManagerAddress,
+        data: (0, import_viem13.encodeFunctionData)({
+          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+          functionName: "socialVerify",
+          args: [
+            validated._socialName,
+            validated.proofs.map((proof) => ({
+              ...proof,
+              signedClaim: {
+                ...proof.signedClaim,
+                claim: {
+                  ...proof.signedClaim.claim,
+                  identifier: proof.signedClaim.claim.identifier
+                },
+                signatures: proof.signedClaim.signatures
+              }
+            }))
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode socialVerify", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+function prepareSubmitAnonAadharProof(reputationManagerAddress, params) {
+  return validate(
+    ZodAnonAadharProofParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow11.Result.fromThrowable(
+      () => ({
+        to: reputationManagerAddress,
+        data: (0, import_viem13.encodeFunctionData)({
+          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+          functionName: "submitAnonAadharProof",
+          args: [
+            validated.nullifierSeed,
+            validated.nullifier,
+            validated.timestamp,
+            validated.signal,
+            validated.revealArray,
+            validated.packedGroth16Proof
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode submitAnonAadharProof", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+function prepareZkPassportRegister(reputationManagerAddress, params) {
+  return validate(
+    ZodZkPassportRegisterParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow11.Result.fromThrowable(
+      () => {
+        const { proofVerificationData, serviceConfig, committedInputs, version } = validated.params;
+        const proofVerificationParams = {
+          version,
+          proofVerificationData: {
+            vkeyHash: proofVerificationData.vkeyHash,
+            proof: proofVerificationData.proof,
+            publicInputs: proofVerificationData.publicInputs
+          },
+          committedInputs,
+          serviceConfig: {
+            validityPeriodInSeconds: BigInt(serviceConfig.validityPeriodInSeconds),
+            domain: serviceConfig.domain,
+            scope: serviceConfig.scope,
+            devMode: serviceConfig.devMode
+          }
+        };
+        return {
+          to: reputationManagerAddress,
+          data: (0, import_viem13.encodeFunctionData)({
+            abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+            functionName: "zkPassportRegister",
+            args: [proofVerificationParams, validated.isIDCard]
+          })
+        };
+      },
+      (error) => new ZkkycError("Failed to encode zkPassportRegister", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+
+// src/contracts/tx-limits/index.ts
+var import_neverthrow12 = require("neverthrow");
+var import_viem14 = require("viem");
+
+// src/profile/errors.ts
+var ProfileError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProfileError";
+  }
+};
+
+// src/profile/validation.ts
+var import_zod9 = require("zod");
+var ZodUsdcBalanceParamsSchema = import_zod9.z.object({
+  address: ZodAddressSchema
+});
+var ZodUsdcAllowanceParamsSchema = import_zod9.z.object({
+  owner: ZodAddressSchema
+});
+var ZodGetBalancesParamsSchema = import_zod9.z.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+var ZodTxLimitsParamsSchema = import_zod9.z.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+
+// src/contracts/tx-limits/index.ts
+function getTxLimits(publicClient, diamondAddress, params) {
+  return validate(
+    ZodTxLimitsParamsSchema,
+    params,
+    (message, cause, data) => new ProfileError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow12.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: diamondAddress,
+        abi: ABIS.FACETS.ORDER_FLOW,
+        functionName: "userTxLimit",
+        args: [validated.address, (0, import_viem14.stringToHex)(validated.currency, { size: 32 })]
+      }),
+      (error) => new ProfileError("Failed to read tx limits", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { address: validated.address, currency: validated.currency, diamondAddress }
+      })
+    ).map(([buyLimit, sellLimit]) => ({
+      buyLimit: Number((0, import_viem14.formatUnits)(buyLimit, 6)),
+      sellLimit: Number((0, import_viem14.formatUnits)(sellLimit, 6))
+    }))
+  );
+}
+
+// src/contracts/usdc/index.ts
+var import_neverthrow13 = require("neverthrow");
+var import_viem15 = require("viem");
+function getUsdcBalance(publicClient, usdcAddress, params) {
+  return validate(
+    ZodUsdcBalanceParamsSchema,
+    params,
+    (message, cause, data) => new ProfileError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow13.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: usdcAddress,
+        abi: ABIS.EXTERNAL.USDC,
+        functionName: "balanceOf",
+        args: [validated.address]
+      }),
+      (error) => new ProfileError("Failed to read USDC balance", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { address: validated.address, usdcAddress }
+      })
+    )
+  );
+}
+function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
+  return validate(
+    ZodUsdcAllowanceParamsSchema,
+    params,
+    (message, cause, data) => new ProfileError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow13.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: usdcAddress,
+        abi: import_viem15.erc20Abi,
+        functionName: "allowance",
+        args: [validated.owner, diamondAddress]
+      }),
+      (error) => new ProfileError("Failed to read USDC allowance", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { owner: validated.owner, usdcAddress, diamondAddress }
+      })
+    )
+  );
+}
+
+// src/orders/internal/routing/routing.ts
+var import_neverthrow14 = require("neverthrow");
+var EPSILON = 0.25;
+var RECOVERY_SCALE = 0.3;
+var BOOTSTRAP_MAX_WEIGHT = 25;
+var MAX_VALIDATION_ATTEMPTS = 3;
+function circleWeight(c) {
+  const score = c.metrics.circleScore;
+  if (c.metrics.circleStatus === "paused") {
+    return score * RECOVERY_SCALE;
+  }
+  if (c.metrics.circleStatus === "bootstrap") {
+    return Math.min(score, BOOTSTRAP_MAX_WEIGHT);
+  }
+  return score;
+}
+function filterEligibleCircles(circles, orderCurrency) {
+  return circles.filter((c) => c.currency.toLowerCase() === orderCurrency.toLowerCase());
+}
+function weightedRandomChoice(arr, weights) {
+  const totalWeight = weights.reduce((sum, w) => sum + w, 0);
+  if (totalWeight === 0) {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+  let rand = Math.random() * totalWeight;
+  for (let i = 0; i < arr.length; i++) {
+    rand -= weights[i];
+    if (rand <= 0) {
+      return arr[i];
+    }
+  }
+  return arr[arr.length - 1];
+}
+function selectCircle(eligible) {
+  if (eligible.length === 0) {
+    return null;
+  }
+  const activeCircles = eligible.filter((c) => c.metrics.circleStatus === "active");
+  const isExplore = Math.random() < EPSILON;
+  if (isExplore) {
+    const weights2 = eligible.map(circleWeight);
+    return weightedRandomChoice(eligible, weights2);
+  }
+  if (activeCircles.length === 0) {
+    const weights2 = eligible.map(circleWeight);
+    return weightedRandomChoice(eligible, weights2);
+  }
+  const weights = activeCircles.map((c) => c.metrics.circleScore);
+  return weightedRandomChoice(activeCircles, weights);
+}
+function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logger = noopLogger) {
+  const eligible = filterEligibleCircles(circles, orderCurrency);
+  let remaining = [...eligible];
+  logger.debug("filtering eligible circles", {
+    total: circles.length,
+    eligible: eligible.length,
+    currency: orderCurrency,
+    circles: eligible
+  });
+  if (eligible.length === 0) {
+    logger.warn("no eligible circles found for currency", { currency: orderCurrency });
+  }
+  function attempt(attemptsLeft) {
+    if (attemptsLeft <= 0 || remaining.length === 0) {
+      logger.warn("exhausted all attempts or circles", {
+        attemptsLeft,
+        remainingCircles: remaining.length
+      });
+      return (0, import_neverthrow14.errAsync)(
+        new OrderRoutingError("No eligible circles found", {
+          code: "NO_ELIGIBLE_CIRCLES"
+        })
+      );
+    }
+    const selected = selectCircle(remaining);
+    if (!selected) {
+      return (0, import_neverthrow14.errAsync)(
+        new OrderRoutingError("No eligible circles found", {
+          code: "NO_ELIGIBLE_CIRCLES"
+        })
+      );
+    }
+    const circleId = BigInt(selected.circleId);
+    logger.debug("selected circle, validating on-chain", {
+      circleId: String(circleId),
+      status: selected.metrics.circleStatus,
+      score: selected.metrics.circleScore,
+      attemptsLeft
+    });
+    return validateCircle(circleId).orElse((error) => {
+      logger.warn("validation errored, treating as ineligible", {
+        circleId: String(circleId),
+        error: String(error)
+      });
+      return (0, import_neverthrow14.okAsync)(false);
+    }).andThen((isValid) => {
+      if (isValid) {
+        logger.info("circle validated successfully", { circleId: String(circleId) });
+        return (0, import_neverthrow14.okAsync)(circleId);
+      }
+      logger.debug("circle failed validation, retrying", {
+        circleId: String(circleId),
+        remainingCircles: remaining.length - 1
+      });
+      remaining = remaining.filter((c) => c.circleId !== selected.circleId);
+      return attempt(attemptsLeft - 1);
+    });
+  }
+  return attempt(MAX_VALIDATION_ATTEMPTS);
+}
+
+// src/orders/internal/routing/subgraph/queries.ts
+var CIRCLES_FOR_ROUTING_QUERY = (
+  /* GraphQL */
+  `
+  query CirclesForRouting($currency: Bytes!) {
+    circles(
+      first: 1000
+      where: {
+        currency: $currency
+        metrics_: {
+          circleStatus_in: ["active", "bootstrap", "paused"]
+        }
+      }
+    ) {
+      circleId
+      currency
+      metrics {
+        circleScore
+        circleStatus
+        scoreState {
+          activeMerchantsCount
+        }
+      }
+    }
+  }
+`
+);
+
+// src/orders/internal/routing/subgraph/index.ts
+function getCirclesForRouting(subgraphUrl, currency, logger = noopLogger) {
+  logger.debug("fetching circles from subgraph", { subgraphUrl, currency });
+  return querySubgraph(subgraphUrl, {
+    query: CIRCLES_FOR_ROUTING_QUERY,
+    variables: { currency }
+  }).mapErr(
+    (e) => new OrderRoutingError(e.message, {
+      code: "SUBGRAPH_ERROR",
+      cause: e.cause ?? e,
+      context: e.context
+    })
+  ).andThen(
+    (data) => validate(
+      ZodCirclesForRoutingResponseSchema,
+      data,
+      (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
+    ).map((validated) => {
+      const circles = validated.circles.filter(
+        (item) => Number(item.metrics.scoreState.activeMerchantsCount) > 0
+      );
+      logger.info("fetched circles from subgraph", {
+        total: validated.circles.length,
+        withActiveMerchants: circles.length,
+        circles
+      });
+      return circles;
+    })
+  );
 }
-async function encryptWithPublicKey(publicKey, message) {
-  const pubKeyBytes = hexToBytes3(`04${publicKey}`);
-  const ephemPrivKey = randomBytes(32);
-  const ephemPubKey = secp256k1.getPublicKey(ephemPrivKey, false);
-  const sharedPoint = secp256k1.getSharedSecret(ephemPrivKey, pubKeyBytes, true);
-  const sharedSecret = sharedPoint.slice(1);
-  const { encKey, macKey } = deriveKeys(sharedSecret);
-  const iv = randomBytes(16);
-  const plaintext = new TextEncoder().encode(message);
-  const cipher = cbc(encKey, iv);
-  const ciphertext = cipher.encrypt(plaintext);
-  const macData = concatBytes2(iv, ephemPubKey, ciphertext);
-  const mac = hmac(sha2562, macKey, macData);
+
+// src/orders/internal/routing/client.ts
+function createOrderRouter(config) {
+  const { subgraphUrl, publicClient, contractAddress } = config;
+  const logger = config.logger ?? noopLogger;
   return {
-    iv: bytesToHex2(iv),
-    ephemPublicKey: bytesToHex2(ephemPubKey),
-    ciphertext: bytesToHex2(ciphertext),
-    mac: bytesToHex2(mac)
+    selectCircle(params) {
+      const currencyHex = (0, import_viem16.stringToHex)(params.currency, { size: 32 });
+      logger.info("selectCircle started", {
+        currency: params.currency,
+        user: params.user,
+        orderType: String(params.orderType)
+      });
+      return getCirclesForRouting(subgraphUrl, currencyHex, logger).andThen(
+        (circles) => selectCircleForOrderAsync(
+          circles,
+          currencyHex,
+          (circleId) => checkCircleEligibility(
+            publicClient,
+            contractAddress,
+            {
+              circleId,
+              currency: currencyHex,
+              user: params.user,
+              usdtAmount: params.usdtAmount,
+              fiatAmount: params.fiatAmount,
+              orderType: params.orderType,
+              preferredPCConfigId: params.preferredPCConfigId
+            },
+            logger
+          ),
+          logger
+        )
+      );
+    }
   };
 }
-function cipherStringify(encrypted) {
-  const ephemPubKeyBytes = hexToBytes3(encrypted.ephemPublicKey);
-  const compressed = secp256k1.ProjectivePoint.fromHex(ephemPubKeyBytes).toRawBytes(true);
-  const iv = hexToBytes3(encrypted.iv);
-  const mac = hexToBytes3(encrypted.mac);
-  const ciphertext = hexToBytes3(encrypted.ciphertext);
-  return bytesToHex2(concatBytes2(iv, compressed, mac, ciphertext));
-}
 
-// src/payload/errors.ts
-var PayloadError = class extends SdkError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "PayloadError";
-  }
+// src/orders/normalize.ts
+var import_neverthrow15 = require("neverthrow");
+var import_viem17 = require("viem");
+var ORDER_TYPE_MAP = {
+  [ORDER_TYPE.BUY]: "buy",
+  [ORDER_TYPE.SELL]: "sell",
+  [ORDER_TYPE.PAY]: "pay"
 };
-
-// src/payload/relay-identity.ts
-var import_neverthrow11 = require("neverthrow");
-var import_viem7 = require("viem");
-var import_accounts = require("viem/accounts");
-var import_zod6 = require("zod");
-var ZodRelayIdentitySchema = import_zod6.z.object({
-  address: import_zod6.z.string().refine(import_viem7.isAddress, { message: "Invalid relay identity address" }),
-  publicKey: import_zod6.z.string().refine((val) => (0, import_viem7.isHex)(`0x${val}`), {
-    message: "Invalid relay identity public key"
-  }),
-  privateKey: import_zod6.z.string().refine(import_viem7.isHex, { message: "Invalid relay identity private key" })
-});
-var STORAGE_KEY = "@P2PME:RELAY_IDENTITY";
-function createRelayIdentity() {
-  const privateKey = (0, import_accounts.generatePrivateKey)();
-  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
-  const rawPubKey = account.publicKey;
-  const publicKey = rawPubKey.slice(4);
-  const identity = {
-    address: account.address,
-    publicKey,
-    privateKey
-  };
-  localStorage.setItem(STORAGE_KEY, JSON.stringify(identity));
-  return identity;
+var ORDER_STATUS_MAP = {
+  [ORDER_STATUS.PLACED]: "placed",
+  [ORDER_STATUS.ACCEPTED]: "accepted",
+  [ORDER_STATUS.PAID]: "paid",
+  [ORDER_STATUS.COMPLETED]: "completed",
+  [ORDER_STATUS.CANCELLED]: "cancelled"
+};
+var DISPUTE_STATUS_MAP = {
+  [DISPUTE_STATUS.NONE]: "none",
+  [DISPUTE_STATUS.OPEN]: "open",
+  [DISPUTE_STATUS.RESOLVED]: "resolved"
+};
+function malformed(field, value, context) {
+  return new OrdersError(`Unknown ${field}: ${String(value)}`, {
+    code: "MALFORMED_ORDER",
+    context: { field, value, ...context }
+  });
 }
-function getRelayIdentity() {
-  const data = localStorage.getItem(STORAGE_KEY);
-  if (!data) {
-    return (0, import_neverthrow11.ok)(createRelayIdentity());
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return (0, import_neverthrow11.ok)(createRelayIdentity());
-  }
-  const result = validate(
-    ZodRelayIdentitySchema,
-    parsed,
-    (message, cause, d) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-  );
-  if (result.isErr()) {
-    return (0, import_neverthrow11.ok)(createRelayIdentity());
-  }
-  return result;
+function mapOrderType(v, ctx) {
+  const t = ORDER_TYPE_MAP[v];
+  return t ? (0, import_neverthrow15.ok)(t) : (0, import_neverthrow15.err)(malformed("orderType", v, ctx));
+}
+function mapOrderStatus(v, ctx) {
+  const s = ORDER_STATUS_MAP[v];
+  return s ? (0, import_neverthrow15.ok)(s) : (0, import_neverthrow15.err)(malformed("status", v, ctx));
+}
+function mapDisputeStatus(v, ctx) {
+  const s = DISPUTE_STATUS_MAP[v];
+  return s ? (0, import_neverthrow15.ok)(s) : (0, import_neverthrow15.err)(malformed("disputeStatus", v, ctx));
+}
+function decodeCurrency(hex) {
+  return (0, import_viem17.hexToString)(hex, { size: 32 }).replaceAll("\0", "");
+}
+function normalizeContractOrder(raw, details) {
+  if (raw.id === 0n && (0, import_viem17.isAddressEqual)(raw.user, import_viem17.zeroAddress)) return (0, import_neverthrow15.ok)(null);
+  const ctx = { orderId: raw.id.toString() };
+  return import_neverthrow15.Result.combine([
+    mapOrderType(raw.orderType, ctx),
+    mapOrderStatus(raw.status, ctx),
+    mapDisputeStatus(raw.disputeInfo.status, ctx)
+  ]).map(([type, status, disputeStatus]) => ({
+    orderId: raw.id,
+    type,
+    status,
+    usdcAmount: raw.amount,
+    fiatAmount: raw.fiatAmount,
+    actualUsdcAmount: details.actualUsdtAmount,
+    actualFiatAmount: details.actualFiatAmount,
+    currency: decodeCurrency(raw.currency),
+    user: raw.user,
+    recipient: raw.recipientAddr,
+    acceptedMerchant: raw.acceptedMerchant,
+    placedAt: raw.placedTimestamp,
+    acceptedAt: details.acceptedTimestamp,
+    paidAt: details.paidTimestamp,
+    completedAt: raw.completedTimestamp,
+    circleId: raw.circleId,
+    fixedFeePaid: details.fixedFeePaid,
+    tipsPaid: details.tipsPaid,
+    disputeStatus,
+    encUpi: raw.encUpi,
+    encMerchantUpi: raw.encMerchantUpi,
+    pubkey: raw.pubkey
+  }));
 }
-
-// src/payload/crypto.ts
-function encryptPaymentAddress(paymentAddress, encryptionPublicKey) {
-  return (0, import_neverthrow12.safeTry)(async function* () {
-    const relayIdentity = yield* getRelayIdentity().mapErr(
-      (e) => new PayloadError(`Relay identity error: ${e.message}`, {
-        code: "ENCRYPTION_ERROR",
-        cause: e
-      })
-    );
-    const messageHash = (0, import_viem8.keccak256)((0, import_viem8.stringToHex)(paymentAddress));
-    const signResult = yield* import_neverthrow12.ResultAsync.fromPromise(
-      (0, import_accounts2.sign)({ hash: messageHash, privateKey: relayIdentity.privateKey }),
-      (error) => new PayloadError(
-        `Signing error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "ENCRYPTION_ERROR", cause: error }
-      )
-    );
-    const signature = (0, import_viem8.serializeSignature)(signResult);
-    const payload = { message: paymentAddress, signature };
-    const encrypted = yield* import_neverthrow12.ResultAsync.fromPromise(
-      encryptWithPublicKey(encryptionPublicKey, JSON.stringify(payload)),
-      (error) => new PayloadError(
-        `Encryption error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "ENCRYPTION_ERROR", cause: error }
-      )
-    );
-    const safeCipherStringify = import_neverthrow12.Result.fromThrowable(
-      (encryptedData) => cipherStringify(encryptedData),
-      (error) => new PayloadError(
-        `Stringify error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "ENCRYPTION_ERROR", cause: error }
-      )
-    );
-    const stringified = yield* safeCipherStringify(encrypted);
-    return (0, import_neverthrow12.ok)(stringified);
-  });
+function normalizeSubgraphOrder(raw) {
+  const ctx = { orderId: raw.orderId };
+  return import_neverthrow15.Result.combine([
+    mapOrderType(raw.type, ctx),
+    mapOrderStatus(raw.status, ctx),
+    mapDisputeStatus(raw.disputeStatus, ctx)
+  ]).map(([type, status, disputeStatus]) => ({
+    orderId: BigInt(raw.orderId),
+    type,
+    status,
+    usdcAmount: BigInt(raw.usdcAmount),
+    fiatAmount: BigInt(raw.fiatAmount),
+    actualUsdcAmount: BigInt(raw.actualUsdcAmount),
+    actualFiatAmount: BigInt(raw.actualFiatAmount),
+    currency: decodeCurrency(raw.currency),
+    user: raw.userAddress,
+    recipient: raw.usdcRecipientAddress,
+    acceptedMerchant: raw.acceptedMerchantAddress,
+    placedAt: BigInt(raw.placedAt),
+    acceptedAt: BigInt(raw.acceptedAt),
+    paidAt: BigInt(raw.paidAt),
+    completedAt: BigInt(raw.completedAt),
+    circleId: BigInt(raw.circleId),
+    fixedFeePaid: BigInt(raw.fixedFeePaid),
+    tipsPaid: BigInt(raw.tipsPaid),
+    disputeStatus,
+    // Subgraph entity does not currently expose these encryption fields;
+    // consumers needing them should fall back to the contract via getOrder.
+    encUpi: "",
+    encMerchantUpi: "",
+    pubkey: ""
+  }));
 }
-var ZodEncryptedDataSchema = import_zod7.z.object({
-  ciphertext: import_zod7.z.string(),
-  iv: import_zod7.z.string(),
-  mac: import_zod7.z.string(),
-  ephemPublicKey: import_zod7.z.string()
-});
 
-// src/payload/validation.ts
-var import_zod8 = require("zod");
-var ZodPlaceOrderParamsSchema = import_zod8.z.object({
-  amount: import_zod8.z.bigint(),
-  recipientAddr: ZodAddressSchema,
-  orderType: import_zod8.z.number().int().min(0).max(2),
-  currency: ZodCurrencySchema,
-  fiatAmount: import_zod8.z.bigint(),
-  user: ZodAddressSchema,
-  pubKey: import_zod8.z.string().optional(),
-  preferredPaymentChannelConfigId: import_zod8.z.bigint().optional(),
-  fiatAmountLimit: import_zod8.z.bigint().optional().default(0n)
-});
-var ZodSetSellOrderUpiParamsSchema = import_zod8.z.object({
-  orderId: import_zod8.z.number().int().nonnegative(),
-  paymentAddress: import_zod8.z.string().min(1),
-  merchantPublicKey: import_zod8.z.string().min(1),
-  updatedAmount: import_zod8.z.bigint()
-});
+// src/orders/subgraph/index.ts
+var import_neverthrow16 = require("neverthrow");
 
-// src/payload/actions.ts
-function buildPlaceOrderPayload(orderRouter, params) {
-  const validation = validate(
-    ZodPlaceOrderParamsSchema,
-    params,
-    (message, cause, data) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data } })
-  );
-  if (validation.isErr()) {
-    return (0, import_neverthrow13.errAsync)(validation.error);
-  }
-  const v = validation.value;
-  const isBuy = v.orderType === ORDER_TYPE.BUY;
-  const pcConfigId = v.preferredPaymentChannelConfigId ?? 0n;
-  const circleResult = orderRouter.selectCircle({
-    currency: v.currency,
-    user: v.user,
-    usdtAmount: v.amount,
-    fiatAmount: v.fiatAmount,
-    orderType: BigInt(v.orderType),
-    preferredPCConfigId: pcConfigId
-  });
-  const relayResult = getRelayIdentity();
-  if (relayResult.isErr()) {
-    return (0, import_neverthrow13.errAsync)(relayResult.error);
-  }
-  const common = {
-    amount: v.amount,
-    recipientAddr: v.recipientAddr,
-    orderType: v.orderType,
-    userUpi: "",
-    currency: v.currency,
-    preferredPaymentChannelConfigId: pcConfigId,
-    fiatAmountLimit: v.fiatAmountLimit
-  };
-  const pubKeyValue = v.pubKey ?? relayResult.value.publicKey;
-  return circleResult.map((circleId) => ({
-    ...common,
-    pubKey: isBuy ? pubKeyValue : "",
-    userPubKey: isBuy ? "" : pubKeyValue,
-    circleId
-  })).mapErr(
-    (e) => new PayloadError(e.message, {
-      code: "CIRCLE_SELECTION_ERROR",
-      cause: e
+// src/orders/subgraph/queries.ts
+var ORDERS_BY_USER_QUERY = (
+  /* GraphQL */
+  `
+  query OrdersByUser($user: Bytes!, $skip: Int!, $first: Int!) {
+    orders_collection(
+      where: { userAddress: $user }
+      orderBy: placedAt
+      orderDirection: desc
+      skip: $skip
+      first: $first
+    ) {
+      orderId
+      type
+      status
+      circleId
+      userAddress
+      usdcRecipientAddress
+      acceptedMerchantAddress
+      usdcAmount
+      fiatAmount
+      actualUsdcAmount
+      actualFiatAmount
+      currency
+      placedAt
+      acceptedAt
+      paidAt
+      completedAt
+      fixedFeePaid
+      tipsPaid
+      disputeStatus
+    }
+  }
+`
+);
+
+// src/orders/subgraph/index.ts
+function getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger = noopLogger) {
+  const user = userAddress.toLowerCase();
+  logger.debug("fetching orders from subgraph", { subgraphUrl, user, skip, limit });
+  return querySubgraph(subgraphUrl, {
+    query: ORDERS_BY_USER_QUERY,
+    variables: { user, skip, first: limit }
+  }).mapErr(
+    (e) => new OrdersError(e.message, {
+      code: "SUBGRAPH_REQUEST_FAILED",
+      cause: e.cause ?? e,
+      context: { user, skip, limit, ...e.context ?? {} }
     })
+  ).andThen(
+    (data) => validate(
+      ZodSubgraphOrdersResponseSchema,
+      data,
+      (message, cause, d) => new OrdersError(message, {
+        code: "SUBGRAPH_VALIDATION_FAILED",
+        cause,
+        context: { data: d }
+      })
+    ).andThen(
+      (validated) => import_neverthrow16.Result.combine(validated.orders_collection.map(normalizeSubgraphOrder))
+    )
   );
 }
-function buildSetSellOrderUpiPayload(params) {
-  const validation = validate(
-    ZodSetSellOrderUpiParamsSchema,
-    params,
-    (message, cause, data) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data } })
-  );
-  if (validation.isErr()) {
-    return (0, import_neverthrow13.errAsync)(validation.error);
-  }
-  const v = validation.value;
-  return encryptPaymentAddress(v.paymentAddress, v.merchantPublicKey).map((userEncUpi) => ({
-    orderId: v.orderId,
-    userEncUpi,
-    updatedAmount: v.updatedAmount
-  }));
+
+// src/orders/watch-events.ts
+var PLACED_CONFIG = {
+  eventName: "OrderPlaced",
+  toEvent: (log) => ({
+    type: "placed",
+    orderId: log.args.orderId,
+    user: log.args.user,
+    orderType: log.args.orderType,
+    blockNumber: log.blockNumber,
+    txHash: log.transactionHash
+  }),
+  userFromLog: (log) => log.args.user
+};
+var ACCEPTED_CONFIG = {
+  eventName: "OrderAccepted",
+  toEvent: (log) => ({
+    type: "accepted",
+    orderId: log.args.orderId,
+    merchant: log.args.merchant,
+    blockNumber: log.blockNumber,
+    txHash: log.transactionHash
+  }),
+  // OrderAccepted's top-level args are (orderId, merchant, pubKey, _order).
+  // The buyer's address lives inside the _order tuple as _order.user.
+  userFromLog: (log) => log.args._order?.user
+};
+var PAID_CONFIG = {
+  eventName: "BuyOrderPaid",
+  toEvent: (log) => ({
+    type: "paid",
+    orderId: log.args.orderId,
+    blockNumber: log.blockNumber,
+    txHash: log.transactionHash
+  }),
+  userFromLog: (log) => log.args.user
+};
+var COMPLETED_CONFIG = {
+  eventName: "OrderCompleted",
+  toEvent: (log) => ({
+    type: "completed",
+    orderId: log.args.orderId,
+    blockNumber: log.blockNumber,
+    txHash: log.transactionHash
+  }),
+  userFromLog: (log) => log.args.user
+};
+var CANCELLED_CONFIG = {
+  eventName: "CancelledOrders",
+  toEvent: (log) => ({
+    type: "cancelled",
+    orderId: log.args.orderId,
+    blockNumber: log.blockNumber,
+    txHash: log.transactionHash
+  }),
+  // CancelledOrders's top-level args are (orderId, _order). The buyer's
+  // address lives inside the _order tuple as _order.user.
+  userFromLog: (log) => log.args._order?.user
+};
+var ALL_CONFIGS = [
+  PLACED_CONFIG,
+  ACCEPTED_CONFIG,
+  PAID_CONFIG,
+  COMPLETED_CONFIG,
+  CANCELLED_CONFIG
+];
+function createWatchEvents(input) {
+  const { publicClient, diamondAddress } = input;
+  return ({ user, onEvent, onError }) => {
+    const unwatchers = [];
+    for (const config of ALL_CONFIGS) {
+      try {
+        const unwatch = publicClient.watchContractEvent({
+          address: diamondAddress,
+          abi: ABIS.DIAMOND,
+          eventName: config.eventName,
+          onLogs: (logs) => {
+            for (const log of logs) {
+              if (user && config.userFromLog) {
+                const logUser = config.userFromLog(log);
+                if (!logUser || logUser.toLowerCase() !== user.toLowerCase()) continue;
+              }
+              onEvent(config.toEvent(log));
+            }
+          },
+          onError: (err5) => {
+            onError?.(
+              new OrdersError(`watchContractEvent failed for ${config.eventName}`, {
+                code: "EVENT_WATCH_FAILED",
+                cause: err5,
+                context: { eventName: config.eventName }
+              })
+            );
+          }
+        });
+        unwatchers.push(unwatch);
+      } catch (err5) {
+        onError?.(
+          new OrdersError(`failed to subscribe to ${config.eventName}`, {
+            code: "EVENT_WATCH_FAILED",
+            cause: err5,
+            context: { eventName: config.eventName }
+          })
+        );
+      }
+    }
+    return () => {
+      for (const u of unwatchers) {
+        try {
+          u();
+        } catch {
+        }
+      }
+    };
+  };
 }
 
-// src/payload/client.ts
-function createPayloadGenerator(config) {
+// src/orders/client.ts
+function createOrders(config) {
+  const { publicClient, diamondAddress, usdcAddress, subgraphUrl, relayIdentity } = config;
+  const logger = config.logger ?? noopLogger;
+  const relayIdentityStore = config.relayIdentityStore ?? createInMemoryRelayStore();
+  const orderRouter = createOrderRouter({
+    publicClient,
+    subgraphUrl,
+    contractAddress: diamondAddress,
+    logger
+  });
   return {
-    placeOrder(params) {
-      return buildPlaceOrderPayload(config.orderRouter, params);
+    // ── Reads ─────────────────────────────────────────────────────────
+    getOrder(params) {
+      return validate(
+        ZodGetOrderParamsSchema,
+        params,
+        (message, cause, d) => new OrdersError(message, {
+          code: "INVALID_ORDER_ID",
+          cause,
+          context: { params: d }
+        })
+      ).asyncAndThen(
+        ({ orderId }) => readOrderMulticall(publicClient, diamondAddress, orderId).mapErr(
+          (cause) => new OrdersError("Order contract read failed", {
+            code: "CONTRACT_READ_FAILED",
+            cause,
+            context: { orderId: orderId.toString() }
+          })
+        )
+      ).andThen(
+        ({ order, details }) => normalizeContractOrder(order, details).asyncAndThen((normalized) => {
+          if (!normalized) {
+            return (0, import_neverthrow17.errAsync)(
+              new OrdersError("Order not found", {
+                code: "ORDER_NOT_FOUND",
+                context: { orderId: params.orderId.toString() }
+              })
+            );
+          }
+          logger.debug("getOrder resolved", { orderId: params.orderId.toString() });
+          return (0, import_neverthrow17.okAsync)(normalized);
+        })
+      );
+    },
+    getOrders(params) {
+      return validate(
+        ZodGetOrdersParamsSchema,
+        params,
+        (message, cause, d) => new OrdersError(message, {
+          code: "INVALID_GET_ORDERS_PARAMS",
+          cause,
+          context: { params: d }
+        })
+      ).asyncAndThen(
+        ({ userAddress, skip, limit }) => getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger)
+      );
+    },
+    getFeeConfig(params) {
+      return validate(
+        ZodGetFeeConfigParamsSchema,
+        params,
+        (message, cause, d) => new OrdersError(message, {
+          code: "INVALID_FEE_CONFIG_PARAMS",
+          cause,
+          context: { params: d }
+        })
+      ).asyncAndThen(
+        ({ currency }) => readFeeConfigMulticall(publicClient, diamondAddress, currency).mapErr(
+          (cause) => new OrdersError("Fee config contract read failed", {
+            code: "CONTRACT_READ_FAILED",
+            cause,
+            context: { currency }
+          })
+        )
+      ).map((config2) => {
+        logger.debug("getFeeConfig resolved", { currency: params.currency });
+        return config2;
+      });
+    },
+    // ── Writes ────────────────────────────────────────────────────────
+    placeOrder: createPlaceOrderAction({
+      publicClient,
+      diamondAddress,
+      orderRouter,
+      relayIdentityStore,
+      relayIdentity
+    }),
+    cancelOrder: createCancelOrderAction({ publicClient, diamondAddress }),
+    setSellOrderUpi: createSetSellOrderUpiAction({
+      publicClient,
+      diamondAddress,
+      relayIdentityStore,
+      relayIdentity
+    }),
+    raiseDispute: createRaiseDisputeAction({ publicClient, diamondAddress }),
+    approveUsdc: createApproveUsdcAction({ publicClient, diamondAddress, usdcAddress }),
+    paidBuyOrder: createPaidBuyOrderAction({ publicClient, diamondAddress }),
+    watchEvents: createWatchEvents({ publicClient, diamondAddress }),
+    // ── Crypto helpers ───────────────────────────────────────────────
+    decryptPaymentAddress({ encrypted }) {
+      return resolveRelayIdentity({ relayIdentity, store: relayIdentityStore }).andThen(
+        (recipientIdentity) => decryptPaymentAddress({ encrypted, recipientIdentity })
+      );
     },
-    setSellOrderUpi(params) {
-      return buildSetSellOrderUpiPayload(params);
+    encryptPaymentAddress({ paymentAddress, recipientPublicKey }) {
+      return resolveRelayIdentity({ relayIdentity, store: relayIdentityStore }).andThen(
+        (senderIdentity) => encryptPaymentAddress({
+          paymentAddress,
+          recipientPublicKey,
+          senderIdentity
+        })
+      );
     }
   };
 }
 
+// src/prices/client.ts
+function createPrices(config) {
+  const { publicClient, diamondAddress } = config;
+  return {
+    getPriceConfig: (params) => getPriceConfig(publicClient, diamondAddress, params),
+    getReputationPerUsdcLimit: (params) => getReputationPerUsdcLimit(publicClient, diamondAddress, params)
+  };
+}
+
 // src/profile/contracts/actions.ts
-var import_neverthrow14 = require("neverthrow");
-var import_viem9 = require("viem");
+var import_neverthrow18 = require("neverthrow");
+var import_viem18 = require("viem");
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
     ZodGetBalancesParamsSchema,
@@ -4616,16 +6432,22 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow14.ResultAsync.combine([
+    (validated) => import_neverthrow18.ResultAsync.combine([
       getUsdcBalance(publicClient, usdcAddress, {
         address: validated.address
       }),
       getPriceConfig(publicClient, diamondAddress, {
         currency: validated.currency
-      })
+      }).mapErr(
+        (cause) => new ProfileError("Failed to read price config for balance conversion", {
+          code: "CONTRACT_READ_ERROR",
+          cause,
+          context: { currency: validated.currency }
+        })
+      )
     ]).map(([usdc, priceConfig]) => {
-      const usdcFormatted = Number((0, import_viem9.formatUnits)(usdc, 6));
-      const sellPriceFormatted = Number((0, import_viem9.formatUnits)(priceConfig.sellPrice, 6));
+      const usdcFormatted = Number((0, import_viem18.formatUnits)(usdc, 6));
+      const sellPriceFormatted = Number((0, import_viem18.formatUnits)(priceConfig.sellPrice, 6));
       return {
         usdc: usdcFormatted,
         fiat: usdcFormatted * sellPriceFormatted,
@@ -4640,10 +6462,9 @@ function createProfile(config) {
   const { publicClient, diamondAddress, usdcAddress } = config;
   return {
     getUsdcBalance: (params) => getUsdcBalance(publicClient, usdcAddress, params),
-    getPriceConfig: (params) => getPriceConfig(publicClient, diamondAddress, params),
+    getUsdcAllowance: (params) => getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params),
     getBalances: (params) => getBalances(publicClient, usdcAddress, diamondAddress, params),
-    getTxLimits: (params) => getTxLimits(publicClient, diamondAddress, params),
-    getRpPerUsdtLimitRational: (params) => getRpPerUsdtLimitRational(publicClient, diamondAddress, params)
+    getTxLimits: (params) => getTxLimits(publicClient, diamondAddress, params)
   };
 }
 
@@ -4684,21 +6505,28 @@ function SdkProvider({ children, ...config }) {
     initedRef.current = fraudEngine;
     fraudEngine.init();
   }, [fraudEngine]);
+  const relayIdentityStore = config.orders?.relayIdentityStore;
+  const relayIdentity = config.orders?.relayIdentity;
   const sdk = (0, import_react.useMemo)(() => {
-    const orderRouter = createOrderRouter({
-      publicClient,
-      subgraphUrl: config.subgraphUrl,
-      contractAddress: config.diamondAddress,
-      logger
-    });
     return {
       profile: createProfile({
         publicClient,
         diamondAddress: config.diamondAddress,
         usdcAddress: config.usdcAddress
       }),
-      orderRouter,
-      payload: createPayloadGenerator({ orderRouter }),
+      prices: createPrices({
+        publicClient,
+        diamondAddress: config.diamondAddress
+      }),
+      orders: createOrders({
+        publicClient,
+        diamondAddress: config.diamondAddress,
+        usdcAddress: config.usdcAddress,
+        subgraphUrl: config.subgraphUrl,
+        relayIdentityStore,
+        relayIdentity,
+        logger
+      }),
       zkkyc: config.reputationManagerAddress ? createZkkyc({
         reputationManagerAddress: config.reputationManagerAddress
       }) : void 0,
@@ -4710,6 +6538,8 @@ function SdkProvider({ children, ...config }) {
     config.diamondAddress,
     config.usdcAddress,
     config.reputationManagerAddress,
+    relayIdentityStore,
+    relayIdentity,
     logger,
     fraudEngine
   ]);
@@ -4725,11 +6555,11 @@ function useSdk() {
 function useProfile() {
   return useSdk().profile;
 }
-function useOrderRouter() {
-  return useSdk().orderRouter;
+function usePrices() {
+  return useSdk().prices;
 }
-function usePayloadGenerator() {
-  return useSdk().payload;
+function useOrders() {
+  return useSdk().orders;
 }
 function useZkkyc() {
   const zkkyc = useSdk().zkkyc;
@@ -4746,13 +6576,32 @@ function useFraudEngine() {
   return fraudEngine;
 }
 
-// src/fraud-engine/react/use-fingerprint.ts
+// src/react/use-watch-orders.ts
 var import_react2 = require("react");
-function useFingerprint(enabled) {
-  const [data, setData] = (0, import_react2.useState)(null);
-  const [error, setError] = (0, import_react2.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+function useWatchOrders(params) {
+  const orders = useOrders();
+  const { user, onEvent, onError } = params;
+  const onEventRef = (0, import_react2.useRef)(onEvent);
+  const onErrorRef = (0, import_react2.useRef)(onError);
+  onEventRef.current = onEvent;
+  onErrorRef.current = onError;
   (0, import_react2.useEffect)(() => {
+    const unsubscribe = orders.watchEvents({
+      user,
+      onEvent: (event) => onEventRef.current(event),
+      onError: (error) => onErrorRef.current?.(error)
+    });
+    return unsubscribe;
+  }, [orders, user]);
+}
+
+// src/fraud-engine/react/use-fingerprint.ts
+var import_react3 = require("react");
+function useFingerprint(enabled) {
+  const [data, setData] = (0, import_react3.useState)(null);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  (0, import_react3.useEffect)(() => {
     if (!enabled) return;
     let cancelled = false;
     setIsLoading(true);
@@ -4784,10 +6633,11 @@ function useFingerprint(enabled) {
   SdkProvider,
   useFingerprint,
   useFraudEngine,
-  useOrderRouter,
-  usePayloadGenerator,
+  useOrders,
+  usePrices,
   useProfile,
   useSdk,
+  useWatchOrders,
   useZkkyc
 });
 /*! Bundled license information: