@p2pdotme/sdk 1.0.5 → 1.1.1

package/dist/react.d.ts

@@ -1,7 +1,7 @@
 import * as neverthrow from 'neverthrow';
 import { Result, ResultAsync } from 'neverthrow';
-import { Address } from 'viem';
-import z$1, { z } from 'zod';
+import { Address, WalletClient, TransactionReceipt } from 'viem';
+import { z } from 'zod';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 
@@ -16,10 +16,6 @@ declare class SdkError<TCode extends string = string> extends Error {
     });
 }
 
-declare const ZodCurrencySchema: z.ZodEnum<{
-    [x: string]: string;
-}>;
-
 type ZkkycErrorCode = "VALIDATION_ERROR" | "CONTRACT_READ_ERROR" | "ENCODE_ERROR" | "RECLAIM_INIT_FAILED" | "RECLAIM_SESSION_NOT_FOUND" | "RECLAIM_PROOF_GENERATION_FAILED" | "RECLAIM_PROOF_INVALID" | "RECLAIM_POLLING_ABORTED" | "ZK_PASSPORT_INIT_FAILED" | "ZK_PASSPORT_REJECTED" | "ZK_PASSPORT_VERIFICATION_FAILED" | "ZK_PASSPORT_ABORTED" | "PEER_DEPENDENCY_MISSING";
 declare class ZkkycError extends SdkError<ZkkycErrorCode> {
     constructor(message: string, options: {
@@ -93,36 +89,10 @@ interface Zkkyc {
     }, ZkkycError>;
 }
 
-type PayloadErrorCode = "VALIDATION_ERROR" | "CIRCLE_SELECTION_ERROR" | "ENCRYPTION_ERROR" | "DECRYPTION_ERROR";
-declare class PayloadError extends SdkError<PayloadErrorCode> {
-    constructor(message: string, options: {
-        code: PayloadErrorCode;
-        cause?: unknown;
-        context?: Record<string, unknown>;
-    });
-}
-
-type OrderRoutingErrorCode = "NO_ELIGIBLE_CIRCLES" | "SUBGRAPH_ERROR" | "SUBGRAPH_NOT_CONFIGURED" | "VALIDATION_ERROR" | "CONTRACT_READ_ERROR";
-declare class OrderRoutingError extends SdkError<OrderRoutingErrorCode> {
-    constructor(message: string, options: {
-        code: OrderRoutingErrorCode;
-        cause?: unknown;
-        context?: Record<string, unknown>;
-    });
-}
-
-interface Logger {
-    debug(message: string, data?: Record<string, unknown>): void;
-    info(message: string, data?: Record<string, unknown>): void;
-    warn(message: string, data?: Record<string, unknown>): void;
-    error(message: string, data?: Record<string, unknown>): void;
-}
-
-type CurrencyType = z$1.infer<typeof ZodCurrencySchema>;
-
 /**
  * Minimal viem PublicClient interface — consumers pass their own client.
- * The SDK only needs `readContract` for on-chain reads.
+ * The SDK uses `readContract` for single reads and `multicall` where available
+ * to batch multiple reads into one RPC round-trip.
  */
 interface PublicClientLike {
     readContract(args: {
@@ -131,68 +101,361 @@ interface PublicClientLike {
         functionName: string;
         args: readonly unknown[];
     }): Promise<unknown>;
+    multicall?(args: {
+        contracts: readonly {
+            address: Address;
+            abi: readonly unknown[];
+            functionName: string;
+            args?: readonly unknown[];
+        }[];
+        allowFailure?: boolean;
+    }): Promise<readonly unknown[]>;
 }
 
-interface SelectCircleParams {
-    readonly currency: string;
-    readonly user: Address;
-    readonly usdtAmount: bigint;
-    readonly fiatAmount: bigint;
-    readonly orderType: bigint;
-    readonly preferredPCConfigId: bigint;
+type OrdersErrorCode = "VALIDATION_ERROR" | "INVALID_ORDER_ID" | "INVALID_GET_ORDERS_PARAMS" | "INVALID_FEE_CONFIG_PARAMS" | "ORDER_NOT_FOUND" | "CONTRACT_READ_FAILED" | "SUBGRAPH_REQUEST_FAILED" | "SUBGRAPH_VALIDATION_FAILED" | "MALFORMED_ORDER" | "CIRCLE_SELECTION_FAILED" | "ENCRYPTION_FAILED" | "RELAY_IDENTITY_CORRUPT" | "RELAY_IDENTITY_STORE_FAILED" | "TX_SUBMISSION_FAILED" | "RECEIPT_TIMEOUT" | "TX_REVERTED" | "EVENT_WATCH_FAILED";
+declare class OrdersError extends SdkError<OrdersErrorCode> {
+    constructor(message: string, options: {
+        code: OrdersErrorCode;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
 }
 
-interface OrderRouter {
-    /**
-     * Full flow: fetch circles from subgraph → epsilon-greedy selection →
-     * on-chain eligibility validation → return circleId.
-     */
-    selectCircle(params: SelectCircleParams): ResultAsync<bigint, OrderRoutingError>;
+interface Logger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
 }
 
-interface PlaceOrderPayload {
-    readonly pubKey: string;
-    readonly amount: bigint;
-    readonly recipientAddr: `0x${string}`;
-    readonly orderType: number;
-    readonly userUpi: string;
-    readonly userPubKey: string;
-    readonly currency: CurrencyType;
-    readonly preferredPaymentChannelConfigId: bigint;
-    readonly fiatAmountLimit: bigint;
-    readonly circleId: bigint;
+interface RelayIdentity {
+    readonly address: `0x${string}`;
+    readonly publicKey: string;
+    readonly privateKey: `0x${string}`;
 }
-interface SetSellOrderUpiPayload {
-    readonly orderId: number;
-    readonly userEncUpi: string;
-    readonly updatedAmount: bigint;
+
+interface RelayIdentityStore {
+    get(): Promise<RelayIdentity | null>;
+    set(identity: RelayIdentity): Promise<void>;
 }
 
+declare const ZodGetOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type GetOrderParams = z.infer<typeof ZodGetOrderParamsSchema>;
+declare const ZodGetFeeConfigParamsSchema: z.ZodObject<{
+    currency: z.ZodEnum<{
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
+    }>;
+}, z.core.$strip>;
+type GetFeeConfigParams = z.infer<typeof ZodGetFeeConfigParamsSchema>;
+declare const ZodGetOrdersParamsSchema: z.ZodObject<{
+    userAddress: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    skip: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type GetOrdersParams = z.input<typeof ZodGetOrdersParamsSchema>;
 declare const ZodPlaceOrderParamsSchema: z.ZodObject<{
-    amount: z.ZodBigInt;
-    recipientAddr: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
     orderType: z.ZodNumber;
     currency: z.ZodEnum<{
-        [x: string]: string;
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
     }>;
-    fiatAmount: z.ZodBigInt;
     user: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
-    pubKey: z.ZodOptional<z.ZodString>;
-    preferredPaymentChannelConfigId: z.ZodOptional<z.ZodBigInt>;
+    amount: z.ZodBigInt;
+    fiatAmount: z.ZodBigInt;
     fiatAmountLimit: z.ZodDefault<z.ZodOptional<z.ZodBigInt>>;
+    recipientAddr: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    preferredPaymentChannelConfigId: z.ZodOptional<z.ZodBigInt>;
+    pubKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type PlaceOrderParams = z.input<typeof ZodPlaceOrderParamsSchema>;
+declare const ZodCancelOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type CancelOrderParams = z.infer<typeof ZodCancelOrderParamsSchema>;
 declare const ZodSetSellOrderUpiParamsSchema: z.ZodObject<{
-    orderId: z.ZodNumber;
+    orderId: z.ZodBigInt;
     paymentAddress: z.ZodString;
     merchantPublicKey: z.ZodString;
     updatedAmount: z.ZodBigInt;
 }, z.core.$strip>;
 type SetSellOrderUpiParams = z.infer<typeof ZodSetSellOrderUpiParamsSchema>;
+declare const ZodRaiseDisputeParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+    redactTransId: z.ZodBigInt;
+}, z.core.$strip>;
+type RaiseDisputeParams = z.infer<typeof ZodRaiseDisputeParamsSchema>;
+declare const ZodApproveUsdcParamsSchema: z.ZodObject<{
+    amount: z.ZodBigInt;
+}, z.core.$strip>;
+type ApproveUsdcParams = z.infer<typeof ZodApproveUsdcParamsSchema>;
+declare const ZodPaidBuyOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type PaidBuyOrderParams = z.infer<typeof ZodPaidBuyOrderParamsSchema>;
+
+type OrderType = "buy" | "sell" | "pay";
+type OrderStatus = "placed" | "accepted" | "paid" | "completed" | "cancelled";
+type DisputeStatus = "none" | "open" | "resolved";
+/**
+ * Normalized order record returned by both `getOrder` and `getOrders`.
+ * Amounts are 6-decimal bigints; timestamps are unix seconds.
+ */
+interface Order {
+    orderId: bigint;
+    type: OrderType;
+    status: OrderStatus;
+    usdcAmount: bigint;
+    fiatAmount: bigint;
+    actualUsdcAmount: bigint;
+    actualFiatAmount: bigint;
+    currency: string;
+    user: Address;
+    recipient: Address;
+    acceptedMerchant: Address;
+    placedAt: bigint;
+    acceptedAt: bigint;
+    paidAt: bigint;
+    completedAt: bigint;
+    circleId: bigint;
+    fixedFeePaid: bigint;
+    tipsPaid: bigint;
+    disputeStatus: DisputeStatus;
+    /**
+     * Encrypted UPI / payment address that the merchant published for this order
+     * (set when the merchant accepts a buy order). Empty string until set.
+     * Decrypt with `decryptPaymentAddress`.
+     */
+    encUpi: string;
+    /**
+     * Encrypted merchant UPI for the seller-side flow (set by `setSellOrderUpi`).
+     * Empty string until set.
+     */
+    encMerchantUpi: string;
+    /** Public key associated with the order, used for ECIES encryption setup. */
+    pubkey: string;
+}
+/**
+ * Per-currency small-order fee config read from the Diamond.
+ * Amounts are 6-decimal bigints.
+ */
+interface FeeConfig {
+    /** Order amounts at or below this threshold are billed the fixed fee. */
+    smallOrderThreshold: bigint;
+    /** Fixed fee applied to small orders (6 decimals). */
+    smallOrderFixedFee: bigint;
+}
+interface PreparedTxMeta {
+    readonly circleId?: bigint;
+    readonly relayIdentity?: RelayIdentity;
+}
+interface PreparedTx {
+    readonly to: `0x${string}`;
+    readonly data: `0x${string}`;
+    readonly value: bigint;
+    readonly meta?: PreparedTxMeta;
+}
+interface TxResultMeta extends PreparedTxMeta {
+    /**
+     * Populated on `placeOrder.execute({ waitForReceipt: true })` — the orderId
+     * parsed from the `OrderPlaced` event in the receipt's logs. Undefined when
+     * `waitForReceipt` is not set (no receipt means no logs to parse).
+     */
+    readonly orderId?: bigint;
+}
+interface TxResult {
+    readonly hash: `0x${string}`;
+    readonly receipt?: TransactionReceipt;
+    readonly meta?: TxResultMeta;
+}
+interface ExecuteBase {
+    readonly walletClient: WalletClient;
+    readonly waitForReceipt?: boolean;
+}
+type OrderEvent = {
+    readonly type: "placed";
+    readonly orderId: bigint;
+    readonly user: Address;
+    readonly orderType: 0 | 1 | 2;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "accepted";
+    readonly orderId: bigint;
+    readonly merchant: Address;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "paid";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "completed";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "cancelled";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+};
+
+interface ApproveUsdcAction {
+    prepare(params: ApproveUsdcParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: ApproveUsdcParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface CancelOrderAction {
+    prepare(params: CancelOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: CancelOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface PaidBuyOrderAction {
+    prepare(params: PaidBuyOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: PaidBuyOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface PlaceOrderAction {
+    prepare(params: PlaceOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: PlaceOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface RaiseDisputeAction {
+    prepare(params: RaiseDisputeParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: RaiseDisputeParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface SetSellOrderUpiAction {
+    prepare(params: SetSellOrderUpiParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: SetSellOrderUpiParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface WatchEventsParams {
+    readonly user?: Address;
+    readonly onEvent: (event: OrderEvent) => void;
+    readonly onError?: (error: OrdersError) => void;
+}
+type WatchEvents = (params: WatchEventsParams) => () => void;
+
+interface OrdersClient {
+    /** Reads a single order by id from the Diamond contract. */
+    getOrder(params: GetOrderParams): ResultAsync<Order, OrdersError>;
+    /**
+     * Lists orders created by `userAddress` from the subgraph, newest first.
+     * Defaults: `skip = 0`, `limit = 20`. Max `limit` is 100.
+     */
+    getOrders(params: GetOrdersParams): ResultAsync<Order[], OrdersError>;
+    /**
+     * Reads the per-currency small-order fee config from the Diamond via
+     * multicall: threshold (below which the fixed fee applies) and the fixed
+     * fee itself. Both are 6-decimal bigints.
+     */
+    getFeeConfig(params: GetFeeConfigParams): ResultAsync<FeeConfig, OrdersError>;
+    readonly placeOrder: PlaceOrderAction;
+    readonly cancelOrder: CancelOrderAction;
+    readonly setSellOrderUpi: SetSellOrderUpiAction;
+    readonly raiseDispute: RaiseDisputeAction;
+    readonly approveUsdc: ApproveUsdcAction;
+    readonly paidBuyOrder: PaidBuyOrderAction;
+    watchEvents: WatchEvents;
+    /**
+     * Decrypts an `encUpi` / `encMerchantUpi` ciphertext from an order using the
+     * relay identity resolved from the configured store. Returns the plaintext
+     * payment address.
+     */
+    decryptPaymentAddress(params: {
+        encrypted: string;
+    }): ResultAsync<string, OrdersError>;
+    /**
+     * Signs `paymentAddress` with the resolved relay identity and ECIES-encrypts
+     * the payload for `recipientPublicKey`. Returns the hex-stringified ciphertext
+     * suitable for on-chain storage (e.g. as the merchant's encUpi when calling
+     * `setSellOrderUpi`).
+     */
+    encryptPaymentAddress(params: {
+        paymentAddress: string;
+        recipientPublicKey: string;
+    }): ResultAsync<string, OrdersError>;
+}
+
+type PricesErrorCode = "VALIDATION_ERROR" | "CONTRACT_READ_ERROR";
+declare class PricesError extends SdkError<PricesErrorCode> {
+    constructor(message: string, options: {
+        code: PricesErrorCode;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+
+/**
+ * Shared param shape for every currency-scoped read in this module
+ * (`getPriceConfig`, `getReputationPerUsdcLimit`). All methods take `{ currency }`.
+ */
+declare const ZodCurrencyScopedParamsSchema: z.ZodObject<{
+    currency: z.ZodEnum<{
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
+    }>;
+}, z.core.$strip>;
+type CurrencyScopedParams = z.infer<typeof ZodCurrencyScopedParamsSchema>;
 
-interface PayloadGenerator {
-    placeOrder(params: PlaceOrderParams): ResultAsync<PlaceOrderPayload, PayloadError>;
-    setSellOrderUpi(params: SetSellOrderUpiParams): ResultAsync<SetSellOrderUpiPayload, PayloadError>;
+interface PriceConfig {
+    readonly buyPrice: bigint;
+    readonly sellPrice: bigint;
+    readonly buyPriceOffset: bigint;
+    readonly baseSpread: bigint;
+}
+/**
+ * Per-currency USDC transaction limit granted per Reputation Point (RP).
+ * Default is 1 RP = 2 USDC everywhere except India (INR), which has its own
+ * multiplier set on-chain.
+ *
+ *   multiplier = denominator / numerator   // USDC per RP
+ */
+interface ReputationLimit {
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    /** USDC per Reputation Point, computed from the rational form. */
+    readonly multiplier: number;
+}
+
+interface Prices {
+    /** Reads buy/sell price config for a given currency (raw bigint, 6 decimals). */
+    getPriceConfig(params: CurrencyScopedParams): ResultAsync<PriceConfig, PricesError>;
+    /**
+     * Reads the per-currency USDC transaction limit granted per Reputation Point
+     * (RP). Default is 1 RP = 2 USDC everywhere except INR, which uses its own
+     * on-chain multiplier.
+     */
+    getReputationPerUsdcLimit(params: CurrencyScopedParams): ResultAsync<ReputationLimit, PricesError>;
 }
 
 type ProfileErrorCode = "VALIDATION_ERROR" | "CONTRACT_READ_ERROR";
@@ -208,37 +471,47 @@ declare const ZodUsdcBalanceParamsSchema: z.ZodObject<{
     address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
 }, z.core.$strip>;
 type UsdcBalanceParams = z.infer<typeof ZodUsdcBalanceParamsSchema>;
+declare const ZodUsdcAllowanceParamsSchema: z.ZodObject<{
+    owner: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+}, z.core.$strip>;
+type UsdcAllowanceParams = z.infer<typeof ZodUsdcAllowanceParamsSchema>;
 declare const ZodGetBalancesParamsSchema: z.ZodObject<{
     address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
     currency: z.ZodEnum<{
-        [x: string]: string;
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
     }>;
 }, z.core.$strip>;
 type GetBalancesParams = z.infer<typeof ZodGetBalancesParamsSchema>;
 declare const ZodTxLimitsParamsSchema: z.ZodObject<{
     address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
     currency: z.ZodEnum<{
-        [x: string]: string;
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
     }>;
 }, z.core.$strip>;
 type TxLimitsParams = z.infer<typeof ZodTxLimitsParamsSchema>;
-declare const ZodPriceConfigParamsSchema: z.ZodObject<{
-    currency: z.ZodEnum<{
-        [x: string]: string;
-    }>;
-}, z.core.$strip>;
-type PriceConfigParams = z.infer<typeof ZodPriceConfigParamsSchema>;
 
 interface TxLimits {
     readonly buyLimit: number;
     readonly sellLimit: number;
 }
-interface RpPerUsdtLimit {
-    readonly numerator: bigint;
-    readonly denominator: bigint;
-    /** The USDC multiplier per RP: denominator / numerator. */
-    readonly multiplier: number;
-}
 
 interface Balances {
     /** USDC balance formatted to a number. */
@@ -248,24 +521,16 @@ interface Balances {
     /** The sell price used for conversion. */
     readonly sellPrice: number;
 }
-interface PriceConfig {
-    readonly buyPrice: bigint;
-    readonly sellPrice: bigint;
-    readonly buyPriceOffset: bigint;
-    readonly baseSpread: bigint;
-}
 
 interface Profile {
     /** Reads the USDC balance for a given address (raw bigint, 6 decimals). */
     getUsdcBalance(params: UsdcBalanceParams): ResultAsync<bigint, ProfileError>;
-    /** Reads buy/sell price config for a given currency (raw bigint, 6 decimals). */
-    getPriceConfig(params: PriceConfigParams): ResultAsync<PriceConfig, ProfileError>;
+    /** Reads the USDC allowance `owner → diamond` (raw bigint, 6 decimals). */
+    getUsdcAllowance(params: UsdcAllowanceParams): ResultAsync<bigint, ProfileError>;
     /** Fetches USDC and fiat balance in parallel for a given address and currency. */
     getBalances(params: GetBalancesParams): ResultAsync<Balances, ProfileError>;
     /** Reads buy and sell transaction limits for a given address and currency. */
     getTxLimits(params: TxLimitsParams): ResultAsync<TxLimits, ProfileError>;
-    /** Reads the RP-to-USDC limit ratio for a given currency. */
-    getRpPerUsdtLimitRational(params: PriceConfigParams): ResultAsync<RpPerUsdtLimit, ProfileError>;
 }
 
 type FraudEngineErrorCode = "API_ERROR" | "ENCRYPTION_ERROR" | "SIGNING_ERROR" | "VALIDATION_ERROR" | "NETWORK_ERROR" | "PLACE_ORDER_ERROR";
@@ -412,6 +677,10 @@ interface FraudEngineSdkConfig {
     readonly encryptionKey: string;
     readonly seonRegion?: string;
 }
+interface OrdersSdkConfig {
+    readonly relayIdentityStore?: RelayIdentityStore;
+    readonly relayIdentity?: RelayIdentity;
+}
 interface SdkConfig {
     readonly publicClient: PublicClientLike;
     readonly subgraphUrl: string;
@@ -419,18 +688,19 @@ interface SdkConfig {
     readonly usdcAddress: Address;
     readonly reputationManagerAddress?: Address;
     readonly fraudEngine?: FraudEngineSdkConfig;
+    readonly orders?: OrdersSdkConfig;
     readonly logger?: Logger;
 }
 interface Sdk {
     readonly profile: Profile;
-    readonly orderRouter: OrderRouter;
-    readonly payload: PayloadGenerator;
+    readonly prices: Prices;
+    readonly orders: OrdersClient;
     readonly zkkyc?: Zkkyc;
     readonly fraudEngine?: FraudEngine;
 }
 
 /**
- * Provides Profile, OrderRouter, PayloadGenerator, Zkkyc, and FraudEngine instances to all children.
+ * Provides Profile, Orders, Zkkyc, and FraudEngine instances to all children.
  *
  * Object props (`publicClient`, `logger`) are captured on mount and do **not** trigger
  * re-instantiation on subsequent renders. To swap them (e.g. switching chains), remount
@@ -450,15 +720,25 @@ declare function SdkProvider({ children, ...config }: SdkConfig & {
 declare function useSdk(): Sdk;
 /** Returns the Profile instance from the nearest SdkProvider. */
 declare function useProfile(): Profile;
-/** Returns the OrderRouter instance from the nearest SdkProvider. */
-declare function useOrderRouter(): OrderRouter;
-/** Returns the PayloadGenerator instance from the nearest SdkProvider. */
-declare function usePayloadGenerator(): PayloadGenerator;
+/** Returns the Prices instance from the nearest SdkProvider. */
+declare function usePrices(): Prices;
+/** Returns the Orders instance from the nearest SdkProvider. */
+declare function useOrders(): OrdersClient;
 /** Returns the Zkkyc instance from the nearest SdkProvider. */
 declare function useZkkyc(): Zkkyc;
 /** Returns the FraudEngine instance from the nearest SdkProvider. */
 declare function useFraudEngine(): FraudEngine;
 
+/**
+ * Subscribes to Diamond order lifecycle events for the lifetime of the
+ * component. Unsubscribes automatically on unmount or when `user` changes.
+ *
+ * Callbacks are captured in refs so consumers may pass inline arrow
+ * functions without causing the underlying subscriptions to thrash on
+ * every render.
+ */
+declare function useWatchOrders(params: WatchEventsParams): void;
+
 interface UseFingerprintResult {
     data: {
         visitorId: string;
@@ -469,4 +749,4 @@ interface UseFingerprintResult {
 }
 declare function useFingerprint(enabled: boolean): UseFingerprintResult;
 
-export { type FraudEngineSdkConfig, type SdkConfig, SdkProvider, useFingerprint, useFraudEngine, useOrderRouter, usePayloadGenerator, useProfile, useSdk, useZkkyc };
+export { type FraudEngineSdkConfig, type OrdersSdkConfig, type SdkConfig, SdkProvider, useFingerprint, useFraudEngine, useOrders, usePrices, useProfile, useSdk, useWatchOrders, useZkkyc };