@p2pdotme/sdk 1.0.5 → 1.1.0

package/dist/{payload.mjs → orders.mjs}

@@ -1,27 +1,794 @@
-// src/payload/actions.ts
-import { errAsync } from "neverthrow";
+// src/orders/client.ts
+import { errAsync as errAsync3, okAsync as okAsync4 } from "neverthrow";
 
-// src/constants/currencies.constant.ts
-var CURRENCY = {
-  IDR: "IDR",
-  INR: "INR",
-  BRL: "BRL",
-  ARS: "ARS",
-  MEX: "MEX",
-  VEN: "VEN",
-  EUR: "EUR",
-  NGN: "NGN",
-  USD: "USD",
-  COP: "COP"
+// src/contracts/order-processor/index.ts
+import { ResultAsync } from "neverthrow";
+import { stringToHex } from "viem";
+
+// src/contracts/abis/index.ts
+import { erc20Abi } from "viem";
+
+// src/contracts/abis/order-flow-facet.ts
+var orderFlowFacetAbi = [
+  {
+    inputs: [
+      { internalType: "uint256", name: "circleId", type: "uint256" },
+      { internalType: "uint256", name: "assignUpto", type: "uint256" },
+      { internalType: "bytes32", name: "currency", type: "bytes32" },
+      { internalType: "address", name: "user", type: "address" },
+      { internalType: "uint256", name: "usdtAmount", type: "uint256" },
+      { internalType: "uint256", name: "fiatAmount", type: "uint256" },
+      { internalType: "int256", name: "orderType", type: "int256" },
+      { internalType: "uint256", name: "preferredPCConfigId", type: "uint256" }
+    ],
+    name: "getAssignableMerchantsFromCircle",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_user", type: "address" },
+      { internalType: "bytes32", name: "_nativeCurrency", type: "bytes32" }
+    ],
+    name: "userTxLimit",
+    outputs: [
+      { internalType: "uint256", name: "", type: "uint256" },
+      { internalType: "uint256", name: "", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { 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: "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" },
+          {
+            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" },
+          {
+            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" },
+          {
+            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: "OrderCompleted",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      { indexed: false, name: "completedTimestamp", 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" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "CancelledOrders",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", 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",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/contracts/abis/reputation-manager.ts
+var reputationManagerAbi = [
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_socialName",
+        type: "string"
+      },
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: "string",
+                name: "provider",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "parameters",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "context",
+                type: "string"
+              }
+            ],
+            internalType: "struct IReclaimSDK.ClaimInfo",
+            name: "claimInfo",
+            type: "tuple"
+          },
+          {
+            components: [
+              {
+                components: [
+                  {
+                    internalType: "bytes32",
+                    name: "identifier",
+                    type: "bytes32"
+                  },
+                  {
+                    internalType: "address",
+                    name: "owner",
+                    type: "address"
+                  },
+                  {
+                    internalType: "uint32",
+                    name: "timestampS",
+                    type: "uint32"
+                  },
+                  {
+                    internalType: "uint32",
+                    name: "epoch",
+                    type: "uint32"
+                  }
+                ],
+                internalType: "struct IReclaimSDK.CompleteClaimData",
+                name: "claim",
+                type: "tuple"
+              },
+              {
+                internalType: "bytes[]",
+                name: "signatures",
+                type: "bytes[]"
+              }
+            ],
+            internalType: "struct IReclaimSDK.SignedClaim",
+            name: "signedClaim",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct IReclaimSDK.Proof[]",
+        name: "proofs",
+        type: "tuple[]"
+      }
+    ],
+    name: "socialVerify",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "nullifierSeed",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "nullifier",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "timestamp",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "signal",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256[4]",
+        name: "revealArray",
+        type: "uint256[4]"
+      },
+      {
+        internalType: "uint256[8]",
+        name: "groth16Proof",
+        type: "uint256[8]"
+      }
+    ],
+    name: "submitAnonAadharProof",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "version",
+            type: "bytes32"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes32",
+                name: "vkeyHash",
+                type: "bytes32"
+              },
+              {
+                internalType: "bytes",
+                name: "proof",
+                type: "bytes"
+              },
+              {
+                internalType: "bytes32[]",
+                name: "publicInputs",
+                type: "bytes32[]"
+              }
+            ],
+            internalType: "struct ProofVerificationData",
+            name: "proofVerificationData",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes",
+            name: "committedInputs",
+            type: "bytes"
+          },
+          {
+            components: [
+              {
+                internalType: "uint256",
+                name: "validityPeriodInSeconds",
+                type: "uint256"
+              },
+              {
+                internalType: "string",
+                name: "domain",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "scope",
+                type: "string"
+              },
+              {
+                internalType: "bool",
+                name: "devMode",
+                type: "bool"
+              }
+            ],
+            internalType: "struct ServiceConfig",
+            name: "serviceConfig",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct ProofVerificationParams",
+        name: "params",
+        type: "tuple"
+      },
+      {
+        internalType: "bool",
+        name: "isIDCard",
+        type: "bool"
+      }
+    ],
+    name: "zkPassportRegister",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/contracts/abis/index.ts
+var DIAMOND_ABI = [
+  ...orderFlowFacetAbi,
+  ...orderProcessorFacetAbi,
+  ...p2pConfigFacetAbi
+];
+var ABIS = {
+  DIAMOND: DIAMOND_ABI,
+  FACETS: {
+    ORDER_FLOW: orderFlowFacetAbi,
+    ORDER_PROCESSOR: orderProcessorFacetAbi,
+    CONFIG: p2pConfigFacetAbi
+  },
+  EXTERNAL: {
+    USDC: erc20Abi,
+    REPUTATION_MANAGER: reputationManagerAbi
+  }
 };
 
-// src/constants/orders.constant.ts
-var ORDER_TYPE = {
-  BUY: 0,
-  SELL: 1,
-  PAY: 2
+// 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 ResultAsync.fromPromise(exec(), toError);
+}
+function readFeeConfigMulticall(publicClient, diamondAddress, currency) {
+  const currencyHex = 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 ResultAsync.fromPromise(exec(), toError);
+}
+
+// src/lib/logger.ts
+var noop = () => {
+};
+var noopLogger = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop
 };
 
+// src/lib/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/subgraph.ts
+import { ResultAsync as ResultAsync2 } from "neverthrow";
+
 // src/validation/errors.validation.ts
 var SdkError = class extends Error {
   code;
@@ -40,8 +807,25 @@ var SdkError = class extends Error {
 import { err, ok } from "neverthrow";
 import { isAddress } from "viem";
 import { z } from "zod";
+
+// src/country/currency.ts
+var CURRENCY = {
+  IDR: "IDR",
+  INR: "INR",
+  BRL: "BRL",
+  ARS: "ARS",
+  MEX: "MEX",
+  VEN: "VEN",
+  EUR: "EUR",
+  NGN: "NGN",
+  USD: "USD",
+  COP: "COP"
+};
+var CURRENCY_CODES = Object.values(CURRENCY);
+
+// src/validation/schemas.validation.ts
 var ZodAddressSchema = z.string().refine((s) => isAddress(s), { message: "Invalid Ethereum address" });
-var ZodCurrencySchema = z.enum(Object.values(CURRENCY));
+var ZodCurrencySchema = z.enum(CURRENCY_CODES);
 function validate(schema, data, toError) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -50,11 +834,600 @@ function validate(schema, data, toError) {
   return err(toError(z.prettifyError(result.error), result.error, data));
 }
 
-// src/payload/crypto.ts
-import { ok as ok3, Result, ResultAsync, safeTry } from "neverthrow";
-import { keccak256, serializeSignature, stringToHex } from "viem";
-import { sign } from "viem/accounts";
+// 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 ResultAsync2.fromPromise(
+    fetchWithRetry(),
+    (error) => error instanceof SubgraphError ? error : new SubgraphError("Subgraph query failed", {
+      code: "TRANSPORT_ERROR",
+      cause: error
+    })
+  );
+}
+
+// src/orders/actions/approve-usdc.ts
+import { encodeFunctionData, erc20Abi as erc20Abi2 } from "viem";
+
+// src/orders/errors.ts
+var OrdersError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "OrdersError";
+  }
+};
+
+// src/orders/tx.ts
+import { errAsync, okAsync, ResultAsync as ResultAsync3 } from "neverthrow";
+function submitPreparedTx(input) {
+  const { prepared, walletClient, publicClient, waitForReceipt, extraMeta } = input;
+  const account = walletClient.account;
+  if (!account) {
+    return errAsync(
+      new OrdersError("WalletClient is missing an account", {
+        code: "TX_SUBMISSION_FAILED"
+      })
+    );
+  }
+  const chain = walletClient.chain;
+  return ResultAsync3.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 okAsync({ hash, meta: combinedMeta });
+    }
+    return ResultAsync3.fromPromise(
+      publicClient.waitForTransactionReceipt({ hash }),
+      (cause) => new OrdersError("waitForTransactionReceipt failed", {
+        code: "RECEIPT_TIMEOUT",
+        cause
+      })
+    ).andThen((receipt) => {
+      if (receipt.status !== "success") {
+        return errAsync(
+          new OrdersError("Transaction reverted", {
+            code: "TX_REVERTED",
+            context: { hash, blockNumber: receipt.blockNumber.toString() }
+          })
+        );
+      }
+      return okAsync({ hash, receipt, meta: combinedMeta });
+    });
+  });
+}
+
+// src/orders/validation.ts
+import { z as z2 } from "zod";
+var ZodGetOrderParamsSchema = z2.object({
+  orderId: z2.bigint().positive()
+});
+var ZodGetFeeConfigParamsSchema = z2.object({
+  currency: ZodCurrencySchema
+});
+var ZodGetOrdersParamsSchema = z2.object({
+  userAddress: ZodAddressSchema,
+  skip: z2.number().int().min(0).default(0),
+  limit: z2.number().int().min(1).max(100).default(20)
+});
+var ZodPlaceOrderParamsSchema = z2.object({
+  orderType: z2.number().int().min(0).max(2),
+  currency: ZodCurrencySchema,
+  user: ZodAddressSchema,
+  amount: z2.bigint(),
+  fiatAmount: z2.bigint(),
+  fiatAmountLimit: z2.bigint().optional().default(0n),
+  recipientAddr: ZodAddressSchema,
+  preferredPaymentChannelConfigId: z2.bigint().optional(),
+  pubKey: z2.string().optional()
+});
+var ZodCancelOrderParamsSchema = z2.object({
+  orderId: z2.bigint().nonnegative()
+});
+var ZodSetSellOrderUpiParamsSchema = z2.object({
+  orderId: z2.bigint().nonnegative(),
+  paymentAddress: z2.string().min(1),
+  merchantPublicKey: z2.string().min(1),
+  updatedAmount: z2.bigint()
+});
+var ZodRaiseDisputeParamsSchema = z2.object({
+  orderId: z2.bigint().nonnegative(),
+  redactTransId: z2.bigint().nonnegative()
+});
+var ZodApproveUsdcParamsSchema = z2.object({
+  amount: z2.bigint().nonnegative()
+});
+var ZodPaidBuyOrderParamsSchema = z2.object({
+  orderId: z2.bigint().nonnegative()
+});
+var HexString = z2.string().regex(/^0x[0-9a-fA-F]*$/, "Expected 0x-prefixed hex");
+var ZodSubgraphOrderSchema = z2.object({
+  orderId: z2.string(),
+  type: z2.number().int().min(0),
+  status: z2.number().int().min(0),
+  circleId: z2.string(),
+  userAddress: HexString,
+  usdcRecipientAddress: HexString,
+  acceptedMerchantAddress: HexString,
+  usdcAmount: z2.string(),
+  fiatAmount: z2.string(),
+  actualUsdcAmount: z2.string(),
+  actualFiatAmount: z2.string(),
+  currency: HexString,
+  placedAt: z2.string(),
+  acceptedAt: z2.string(),
+  paidAt: z2.string(),
+  completedAt: z2.string(),
+  fixedFeePaid: z2.string(),
+  tipsPaid: z2.string(),
+  disputeStatus: z2.number().int().min(0)
+});
+var ZodSubgraphOrdersResponseSchema = z2.object({
+  orders_collection: z2.array(ZodSubgraphOrderSchema)
+});
+
+// src/orders/actions/approve-usdc.ts
+function createApproveUsdcAction(input) {
+  const { publicClient, diamondAddress, usdcAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodApproveUsdcParamsSchema,
+    params,
+    (message, cause, data) => new OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).map(({ amount }) => ({
+    to: usdcAddress,
+    data: encodeFunctionData({
+      abi: erc20Abi2,
+      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/orders/actions/cancel-order.ts
+import { encodeFunctionData as encodeFunctionData2 } from "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 }
+    })
+  ).map(({ orderId }) => ({
+    to: diamondAddress,
+    data: encodeFunctionData2({
+      abi: ABIS.FACETS.ORDER_FLOW,
+      functionName: "cancelOrder",
+      args: [orderId]
+    }),
+    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
+import { encodeFunctionData as encodeFunctionData3 } from "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: encodeFunctionData3({
+      abi: ABIS.FACETS.ORDER_PROCESSOR,
+      functionName: "paidBuyOrder",
+      args: [orderId]
+    }),
+    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
+import { encodeFunctionData as encodeFunctionData4, parseEventLogs, stringToHex as stringToHex2 } from "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
+import { isAddress as isAddress2, isHex } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { z as z3 } from "zod";
+var ZodRelayIdentitySchema = z3.object({
+  address: z3.string().refine(isAddress2, { message: "Invalid relay identity address" }),
+  publicKey: z3.string().refine((v) => isHex(`0x${v}`), {
+    message: "Invalid relay identity public key"
+  }),
+  privateKey: z3.string().refine(isHex, { message: "Invalid relay identity private key" })
+});
+function createRelayIdentity() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  const publicKey = account.publicKey.slice(4);
+  return {
+    address: account.address,
+    publicKey,
+    privateKey
+  };
+}
+
+// src/orders/relay-identity/resolve.ts
+import { err as err2, ok as ok2, okAsync as okAsync2, ResultAsync as ResultAsync4 } from "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;
+    }
+  };
+}
+var DEFAULT_KEY = "@P2PME:RELAY_IDENTITY";
+function createLocalStorageRelayStore(options = {}) {
+  const key = options.key ?? DEFAULT_KEY;
+  return {
+    async get() {
+      const raw = localStorage.getItem(key);
+      if (!raw) return null;
+      try {
+        return JSON.parse(raw);
+      } catch (cause) {
+        throw new RelayIdentityCorruptError(cause);
+      }
+    },
+    async set(identity) {
+      localStorage.setItem(key, JSON.stringify(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 err2(
+        new OrdersError("Stored relay identity is corrupt", {
+          code: "RELAY_IDENTITY_CORRUPT",
+          cause: cause.cause
+        })
+      );
+    }
+    return err2(
+      new OrdersError("Relay identity store.get failed", {
+        code: "RELAY_IDENTITY_STORE_FAILED",
+        cause
+      })
+    );
+  }
+  if (stored !== null) {
+    const parsed = ZodRelayIdentitySchema.safeParse(stored);
+    if (!parsed.success) {
+      return err2(
+        new OrdersError("Stored relay identity failed validation", {
+          code: "RELAY_IDENTITY_CORRUPT",
+          cause: parsed.error
+        })
+      );
+    }
+    return ok2(stored);
+  }
+  const fresh = createRelayIdentity();
+  try {
+    await store.set(fresh);
+  } catch (cause) {
+    return err2(
+      new OrdersError("Relay identity store.set failed", {
+        code: "RELAY_IDENTITY_STORE_FAILED",
+        cause
+      })
+    );
+  }
+  return ok2(fresh);
+}
+function resolveRelayIdentity(input) {
+  if (input.relayIdentity) {
+    return okAsync2(input.relayIdentity);
+  }
+  const existing = pending.get(input.store);
+  if (existing) {
+    return ResultAsync4.fromSafePromise(existing).andThen((r) => r);
+  }
+  const promise = resolveFromStore(input.store).finally(() => {
+    pending.delete(input.store);
+  });
+  pending.set(input.store, promise);
+  return ResultAsync4.fromSafePromise(promise).andThen((r) => r);
+}
+
+// src/orders/actions/place-order.ts
+function enrichWithOrderId(result, userAddress) {
+  if (!result.receipt) return result;
+  try {
+    const events = 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 OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).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
+      })
+    );
+    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 = stringToHex2(v.currency, { size: 32 });
+        const data = encodeFunctionData4({
+          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)
+      );
+    }
+  };
+}
+
+// src/orders/actions/raise-dispute.ts
+import { encodeFunctionData as encodeFunctionData5 } from "viem";
+function createRaiseDisputeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodRaiseDisputeParamsSchema,
+    params,
+    (message, cause, data) => new OrdersError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).map(({ orderId, redactTransId }) => ({
+    to: diamondAddress,
+    data: encodeFunctionData5({
+      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/orders/actions/set-sell-order-upi.ts
+import { encodeFunctionData as encodeFunctionData6 } from "viem";
+
+// src/orders/crypto/encryption.ts
+import { ok as ok3, Result, ResultAsync as ResultAsync5, safeTry } from "neverthrow";
+import { keccak256, serializeSignature, stringToHex as stringToHex3 } from "viem";
+import { sign } from "viem/accounts";
+import { z as z4 } from "zod";
 
 // node_modules/@noble/ciphers/esm/utils.js
 function isBytes(a) {
@@ -1118,7 +2491,7 @@ function asciiToBase16(ch) {
     return ch - (asciis.a - 10);
   return;
 }
-function hexToBytes(hex) {
+function hexToBytes2(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
   if (hasHexBuiltin)
@@ -1147,7 +2520,7 @@ function bytesToNumberLE(bytes) {
   return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+  return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
 }
 function numberToBytesLE(n, len) {
   return numberToBytesBE(n, len).reverse();
@@ -1156,7 +2529,7 @@ function ensureBytes(title, hex, expectedLength) {
   let res;
   if (typeof hex === "string") {
     try {
-      res = hexToBytes(hex);
+      res = hexToBytes2(hex);
     } catch (e) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
     }
@@ -2003,15 +3376,15 @@ function weierstrassPoints(opts) {
       throw new Error("ProjectivePoint expected");
   }
   const toAffineMemo = memoized((p, iz) => {
-    const { px: x, py: y, pz: z5 } = p;
-    if (Fp.eql(z5, Fp.ONE))
+    const { px: x, py: y, pz: z9 } = p;
+    if (Fp.eql(z9, Fp.ONE))
       return { x, y };
     const is0 = p.is0();
     if (iz == null)
-      iz = is0 ? Fp.ONE : Fp.inv(z5);
+      iz = is0 ? Fp.ONE : Fp.inv(z9);
     const ax = Fp.mul(x, iz);
     const ay = Fp.mul(y, iz);
-    const zz = Fp.mul(z5, iz);
+    const zz = Fp.mul(z9, iz);
     if (is0)
       return { x: Fp.ZERO, y: Fp.ZERO };
     if (!Fp.eql(zz, Fp.ONE))
@@ -2483,14 +3856,14 @@ function weierstrass(curveDef) {
     }
     // DER-encoded
     toDERRawBytes() {
-      return hexToBytes(this.toDERHex());
+      return hexToBytes2(this.toDERHex());
     }
     toDERHex() {
       return DER.hexFromSig(this);
     }
     // padded bytes of r, then padded bytes of s
     toCompactRawBytes() {
-      return hexToBytes(this.toCompactHex());
+      return hexToBytes2(this.toCompactHex());
     }
     toCompactHex() {
       const l = nByteLength;
@@ -2772,9 +4145,9 @@ 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 hexToBytes2(hex) {
+function hexToBytes3(hex) {
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < bytes.length; i++) {
     bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
@@ -2804,7 +4177,7 @@ function deriveKeys(sharedSecret) {
   };
 }
 async function encryptWithPublicKey(publicKey, message) {
-  const pubKeyBytes = hexToBytes2(`04${publicKey}`);
+  const pubKeyBytes = hexToBytes3(`04${publicKey}`);
   const ephemPrivKey = randomBytes(32);
   const ephemPubKey = secp256k1.getPublicKey(ephemPrivKey, false);
   const sharedPoint = secp256k1.getSharedSecret(ephemPrivKey, pubKeyBytes, true);
@@ -2824,11 +4197,11 @@ async function encryptWithPublicKey(publicKey, message) {
   };
 }
 async function decryptWithPrivateKey(privateKey, encrypted) {
-  const privKeyBytes = hexToBytes2(privateKey.replace(/^0x/, ""));
-  const ephemPubKeyBytes = hexToBytes2(encrypted.ephemPublicKey);
-  const ivBytes = hexToBytes2(encrypted.iv);
-  const ciphertextBytes = hexToBytes2(encrypted.ciphertext);
-  const macBytes = hexToBytes2(encrypted.mac);
+  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);
@@ -2842,15 +4215,15 @@ async function decryptWithPrivateKey(privateKey, encrypted) {
   return new TextDecoder().decode(plaintext);
 }
 function cipherStringify(encrypted) {
-  const ephemPubKeyBytes = hexToBytes2(encrypted.ephemPublicKey);
+  const ephemPubKeyBytes = hexToBytes3(encrypted.ephemPublicKey);
   const compressed = secp256k1.ProjectivePoint.fromHex(ephemPubKeyBytes).toRawBytes(true);
-  const iv = hexToBytes2(encrypted.iv);
-  const mac = hexToBytes2(encrypted.mac);
-  const ciphertext = hexToBytes2(encrypted.ciphertext);
+  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 = hexToBytes2(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})`
@@ -2869,241 +4242,971 @@ function cipherParse(str) {
   };
 }
 
-// src/payload/errors.ts
-var PayloadError = class extends SdkError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "PayloadError";
-  }
-};
-
-// src/payload/relay-identity.ts
-import { ok as ok2 } from "neverthrow";
-import { isAddress as isAddress2, isHex } from "viem";
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { z as z2 } from "zod";
-var ZodRelayIdentitySchema = z2.object({
-  address: z2.string().refine(isAddress2, { message: "Invalid relay identity address" }),
-  publicKey: z2.string().refine((val) => isHex(`0x${val}`), {
-    message: "Invalid relay identity public key"
-  }),
-  privateKey: z2.string().refine(isHex, { message: "Invalid relay identity private key" })
-});
-var STORAGE_KEY = "@P2PME:RELAY_IDENTITY";
-function createRelayIdentity() {
-  const privateKey = generatePrivateKey();
-  const account = 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;
-}
-function getRelayIdentity() {
-  const data = localStorage.getItem(STORAGE_KEY);
-  if (!data) {
-    return ok2(createRelayIdentity());
-  }
+// src/orders/crypto/encryption.ts
+function tryParseLegacyEthCryptoEnvelope(input) {
+  if (input.charCodeAt(0) !== 123) return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(data);
+    parsed = JSON.parse(input);
   } catch {
-    return ok2(createRelayIdentity());
+    return void 0;
   }
-  const result = validate(
-    ZodRelayIdentitySchema,
-    parsed,
-    (message, cause, d) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-  );
-  if (result.isErr()) {
-    return ok2(createRelayIdentity());
+  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 result;
+  return {
+    iv: o.iv,
+    ephemPublicKey: o.ephemPublicKey,
+    ciphertext: o.ciphertext,
+    mac: o.mac
+  };
 }
-
-// src/payload/crypto.ts
-function encryptPaymentAddress(paymentAddress, encryptionPublicKey) {
+function encryptPaymentAddress(input) {
   return safeTry(async function* () {
-    const relayIdentity = yield* getRelayIdentity().mapErr(
-      (e) => new PayloadError(`Relay identity error: ${e.message}`, {
-        code: "ENCRYPTION_ERROR",
-        cause: e
+    const messageHash = keccak256(stringToHex3(input.paymentAddress));
+    const signature = yield* ResultAsync5.fromPromise(
+      sign({ hash: messageHash, privateKey: input.senderIdentity.privateKey }),
+      (cause) => new OrdersError("Failed to sign payment address", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    ).map(serializeSignature);
+    const payload = JSON.stringify({ message: input.paymentAddress, signature });
+    const encrypted = yield* ResultAsync5.fromPromise(
+      encryptWithPublicKey(input.recipientPublicKey, payload),
+      (cause) => new OrdersError("ECIES encryption failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
       })
     );
-    const messageHash = keccak256(stringToHex(paymentAddress));
-    const signResult = yield* ResultAsync.fromPromise(
-      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 = serializeSignature(signResult);
-    const payload = { message: paymentAddress, signature };
-    const encrypted = yield* 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 = Result.fromThrowable(
-      (encryptedData) => cipherStringify(encryptedData),
-      (error) => new PayloadError(
-        `Stringify error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "ENCRYPTION_ERROR", cause: error }
-      )
+    const safeStringify = Result.fromThrowable(
+      (e) => cipherStringify(e),
+      (cause) => new OrdersError("Ciphertext stringify failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
     );
-    const stringified = yield* safeCipherStringify(encrypted);
-    return ok3(stringified);
+    return ok3(yield* safeStringify(encrypted));
   });
 }
-var ZodEncryptedDataSchema = z3.object({
-  ciphertext: z3.string(),
-  iv: z3.string(),
-  mac: z3.string(),
-  ephemPublicKey: z3.string()
+var ZodDecryptedPayloadSchema = z4.object({
+  message: z4.string(),
+  signature: z4.string()
 });
-function decryptPaymentAddress(encryptedPaymentAddress) {
+function decryptPaymentAddress(input) {
   return safeTry(async function* () {
-    const relayIdentity = yield* getRelayIdentity().mapErr(
-      (e) => new PayloadError(`Relay identity error: ${e.message}`, {
-        code: "DECRYPTION_ERROR",
-        cause: e
+    const legacyEnvelope = tryParseLegacyEthCryptoEnvelope(input.encrypted);
+    const safeCipherParse = 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* ResultAsync5.fromPromise(
+      decryptWithPrivateKey(input.recipientIdentity.privateKey, encryptedData),
+      (cause) => new OrdersError("ECIES decryption failed", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
+    );
+    if (legacyEnvelope) {
+      return ok3(plaintext);
+    }
     const safeJsonParse = Result.fromThrowable(
-      (str) => JSON.parse(str),
-      (error) => new PayloadError(
-        `JSON parse error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "DECRYPTION_ERROR", cause: error }
-      )
+      (s) => JSON.parse(s),
+      (cause) => new OrdersError("Failed to parse decrypted payload JSON", {
+        code: "ENCRYPTION_FAILED",
+        cause
+      })
     );
-    const parsed = yield* safeJsonParse(encryptedPaymentAddress);
-    const encryptedData = yield* validate(
-      ZodEncryptedDataSchema,
+    const parsed = yield* safeJsonParse(plaintext);
+    const payload = yield* validate(
+      ZodDecryptedPayloadSchema,
       parsed,
-      (message, cause, data) => new PayloadError(message, { code: "DECRYPTION_ERROR", cause, context: { data } })
-    );
-    const decrypted = yield* ResultAsync.fromPromise(
-      decryptWithPrivateKey(relayIdentity.privateKey, encryptedData),
-      (error) => new PayloadError(
-        `Decryption error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { code: "DECRYPTION_ERROR", cause: error }
-      )
+      (message, cause, data) => new OrdersError(message, {
+        code: "ENCRYPTION_FAILED",
+        cause,
+        context: { data }
+      })
     );
-    return ok3(decrypted);
+    return ok3(payload.message);
   });
 }
 
-// src/payload/validation.ts
-import { z as z4 } from "zod";
-var ZodPlaceOrderParamsSchema = z4.object({
-  amount: z4.bigint(),
-  recipientAddr: ZodAddressSchema,
-  orderType: z4.number().int().min(0).max(2),
-  currency: ZodCurrencySchema,
-  fiatAmount: z4.bigint(),
+// 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: encodeFunctionData6({
+      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
+import { stringToHex as stringToHex6 } from "viem";
+
+// src/contracts/order-flow/index.ts
+import { ResultAsync as ResultAsync6 } from "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
+import { z as z5 } from "zod";
+var ZodCircleScoreStateSchema = z5.object({
+  activeMerchantsCount: z5.coerce.number()
+});
+var ZodCircleMetricsForRoutingSchema = z5.object({
+  circleScore: z5.coerce.number(),
+  circleStatus: z5.string(),
+  scoreState: ZodCircleScoreStateSchema
+});
+var ZodCircleForRoutingSchema = z5.object({
+  circleId: z5.string(),
+  currency: z5.string(),
+  metrics: ZodCircleMetricsForRoutingSchema
+});
+var ZodCirclesForRoutingResponseSchema = z5.object({
+  circles: z5.array(ZodCircleForRoutingSchema)
+});
+var ZodCheckCircleEligibilityParamsSchema = z5.object({
+  circleId: z5.bigint(),
+  currency: z5.string(),
   user: ZodAddressSchema,
-  pubKey: z4.string().optional(),
-  preferredPaymentChannelConfigId: z4.bigint().optional(),
-  fiatAmountLimit: z4.bigint().optional().default(0n)
+  usdtAmount: z5.bigint(),
+  fiatAmount: z5.bigint(),
+  orderType: z5.bigint(),
+  preferredPCConfigId: z5.bigint()
 });
-var ZodSetSellOrderUpiParamsSchema = z4.object({
-  orderId: z4.number().int().nonnegative(),
-  paymentAddress: z4.string().min(1),
-  merchantPublicKey: z4.string().min(1),
-  updatedAmount: z4.bigint()
+var ZodSelectCircleParamsSchema = z5.object({
+  currency: z5.string().min(1),
+  user: ZodAddressSchema,
+  usdtAmount: z5.bigint(),
+  fiatAmount: z5.bigint(),
+  orderType: z5.bigint(),
+  preferredPCConfigId: z5.bigint()
 });
 
-// src/payload/actions.ts
-function buildPlaceOrderPayload(orderRouter, params) {
-  const validation = validate(
-    ZodPlaceOrderParamsSchema,
+// src/contracts/order-flow/index.ts
+function checkCircleEligibility(publicClient, contractAddress, params, logger = noopLogger) {
+  return validate(
+    ZodCheckCircleEligibilityParamsSchema,
     params,
-    (message, cause, data) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data } })
-  );
-  if (validation.isErr()) {
-    return 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
+    (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 ResultAsync6.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;
   });
-  const relayResult = getRelayIdentity();
-  if (relayResult.isErr()) {
-    return 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/contracts/p2p-config/index.ts
+import { ResultAsync as ResultAsync7 } from "neverthrow";
+import { stringToHex as stringToHex4 } from "viem";
+
+// src/prices/validation.ts
+import { z as z6 } from "zod";
+var ZodCurrencyScopedParamsSchema = z6.object({
+  currency: ZodCurrencySchema
+});
+
+// src/contracts/reputation-manager/writes.ts
+import { Result as Result2 } from "neverthrow";
+import { encodeFunctionData as encodeFunctionData7 } from "viem";
+
+// src/zkkyc/validation.ts
+import { z as z7 } from "zod";
+var ZodAnonAadharProofParamsSchema = z7.object({
+  nullifierSeed: z7.bigint(),
+  nullifier: z7.bigint(),
+  timestamp: z7.bigint(),
+  signal: z7.bigint(),
+  revealArray: z7.tuple([z7.bigint(), z7.bigint(), z7.bigint(), z7.bigint()]),
+  packedGroth16Proof: z7.tuple([
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint(),
+    z7.bigint()
+  ])
+});
+var ZodSocialVerifyParamsSchema = z7.object({
+  _socialName: z7.string(),
+  proofs: z7.array(
+    z7.object({
+      claimInfo: z7.object({
+        provider: z7.string(),
+        parameters: z7.string(),
+        context: z7.string()
+      }),
+      signedClaim: z7.object({
+        claim: z7.object({
+          identifier: z7.string(),
+          owner: ZodAddressSchema,
+          timestampS: z7.number(),
+          epoch: z7.number()
+        }),
+        signatures: z7.array(z7.string())
+      })
     })
-  );
+  )
+});
+var ZodSolidityVerifierParametersSchema = z7.object({
+  version: z7.string().refine((val) => val.startsWith("0x"), {
+    message: "Version must be a hex string"
+  }),
+  proofVerificationData: z7.object({
+    vkeyHash: z7.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+      message: "Invalid bytes32 hex string"
+    }),
+    proof: z7.string().refine((val) => val.startsWith("0x"), {
+      message: "Proof must be a hex string"
+    }),
+    publicInputs: z7.array(
+      z7.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+        message: "Each public input must be a valid bytes32 hex string"
+      })
+    )
+  }),
+  committedInputs: z7.string().refine((val) => val.startsWith("0x"), {
+    message: "Committed inputs must be a hex string"
+  }),
+  serviceConfig: z7.object({
+    validityPeriodInSeconds: z7.number().int().nonnegative(),
+    domain: z7.string(),
+    scope: z7.string(),
+    devMode: z7.boolean()
+  })
+});
+var ZodZkPassportRegisterParamsSchema = z7.object({
+  params: ZodSolidityVerifierParametersSchema,
+  isIDCard: z7.boolean()
+});
+
+// src/contracts/tx-limits/index.ts
+import { ResultAsync as ResultAsync8 } from "neverthrow";
+import { formatUnits, stringToHex as stringToHex5 } from "viem";
+
+// src/profile/validation.ts
+import { z as z8 } from "zod";
+var ZodUsdcBalanceParamsSchema = z8.object({
+  address: ZodAddressSchema
+});
+var ZodUsdcAllowanceParamsSchema = z8.object({
+  owner: ZodAddressSchema
+});
+var ZodGetBalancesParamsSchema = z8.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+var ZodTxLimitsParamsSchema = z8.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+
+// src/contracts/usdc/index.ts
+import { ResultAsync as ResultAsync9 } from "neverthrow";
+import { erc20Abi as erc20Abi3 } from "viem";
+
+// src/orders/internal/routing/routing.ts
+import { errAsync as errAsync2, okAsync as okAsync3 } from "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 buildSetSellOrderUpiPayload(params) {
-  const validation = validate(
-    ZodSetSellOrderUpiParamsSchema,
-    params,
-    (message, cause, data) => new PayloadError(message, { code: "VALIDATION_ERROR", cause, context: { data } })
+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 errAsync2(
+        new OrderRoutingError("No eligible circles found", {
+          code: "NO_ELIGIBLE_CIRCLES"
+        })
+      );
+    }
+    const selected = selectCircle(remaining);
+    if (!selected) {
+      return errAsync2(
+        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 okAsync3(false);
+    }).andThen((isValid) => {
+      if (isValid) {
+        logger.info("circle validated successfully", { circleId: String(circleId) });
+        return okAsync3(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;
+    })
   );
-  if (validation.isErr()) {
-    return errAsync(validation.error);
-  }
-  const v = validation.value;
-  return encryptPaymentAddress(v.paymentAddress, v.merchantPublicKey).map((userEncUpi) => ({
-    orderId: v.orderId,
-    userEncUpi,
-    updatedAmount: v.updatedAmount
+}
+
+// src/orders/internal/routing/client.ts
+function createOrderRouter(config) {
+  const { subgraphUrl, publicClient, contractAddress } = config;
+  const logger = config.logger ?? noopLogger;
+  return {
+    selectCircle(params) {
+      const currencyHex = stringToHex6(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/orders/normalize.ts
+import { err as err3, ok as ok4, Result as Result3 } from "neverthrow";
+import { hexToString, isAddressEqual, zeroAddress } from "viem";
+var ORDER_TYPE_MAP = {
+  [ORDER_TYPE.BUY]: "buy",
+  [ORDER_TYPE.SELL]: "sell",
+  [ORDER_TYPE.PAY]: "pay"
+};
+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 mapOrderType(v, ctx) {
+  const t = ORDER_TYPE_MAP[v];
+  return t ? ok4(t) : err3(malformed("orderType", v, ctx));
+}
+function mapOrderStatus(v, ctx) {
+  const s = ORDER_STATUS_MAP[v];
+  return s ? ok4(s) : err3(malformed("status", v, ctx));
+}
+function mapDisputeStatus(v, ctx) {
+  const s = DISPUTE_STATUS_MAP[v];
+  return s ? ok4(s) : err3(malformed("disputeStatus", v, ctx));
+}
+function decodeCurrency(hex) {
+  return hexToString(hex, { size: 32 }).replaceAll("\0", "");
+}
+function normalizeContractOrder(raw, details) {
+  if (raw.id === 0n && isAddressEqual(raw.user, zeroAddress)) return ok4(null);
+  const ctx = { orderId: raw.id.toString() };
+  return Result3.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
   }));
 }
+function normalizeSubgraphOrder(raw) {
+  const ctx = { orderId: raw.orderId };
+  return Result3.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: ""
+  }));
+}
+
+// src/orders/subgraph/index.ts
+import { Result as Result4 } from "neverthrow";
+
+// 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/payload/client.ts
-function createPayloadGenerator(config) {
+// 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) => Result4.combine(validated.orders_collection.map(normalizeSubgraphOrder))
+    )
+  );
+}
+
+// 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: (err4) => {
+            onError?.(
+              new OrdersError(`watchContractEvent failed for ${config.eventName}`, {
+                code: "EVENT_WATCH_FAILED",
+                cause: err4,
+                context: { eventName: config.eventName }
+              })
+            );
+          }
+        });
+        unwatchers.push(unwatch);
+      } catch (err4) {
+        onError?.(
+          new OrdersError(`failed to subscribe to ${config.eventName}`, {
+            code: "EVENT_WATCH_FAILED",
+            cause: err4,
+            context: { eventName: config.eventName }
+          })
+        );
+      }
+    }
+    return () => {
+      for (const u of unwatchers) {
+        try {
+          u();
+        } catch {
+        }
+      }
+    };
+  };
+}
+
+// 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 errAsync3(
+              new OrdersError("Order not found", {
+                code: "ORDER_NOT_FOUND",
+                context: { orderId: params.orderId.toString() }
+              })
+            );
+          }
+          logger.debug("getOrder resolved", { orderId: params.orderId.toString() });
+          return okAsync4(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
+        })
+      );
     }
   };
 }
 export {
-  PayloadError,
+  OrdersError,
   cipherParse,
   cipherStringify,
-  createPayloadGenerator,
+  createInMemoryRelayStore,
+  createLocalStorageRelayStore,
+  createOrders,
   createRelayIdentity,
   decryptPaymentAddress,
-  encryptPaymentAddress,
-  getRelayIdentity
+  encryptPaymentAddress
 };
 /*! Bundled license information:
 
@@ -3121,4 +5224,4 @@ export {
 @noble/curves/esm/secp256k1.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=payload.mjs.map
+//# sourceMappingURL=orders.mjs.map