@zkp2p/sdk 0.0.5 → 0.0.7

package/dist/index.mjs

@@ -1,12 +1,13 @@
 import { ValidationError, APIError, NetworkError } from './chunk-GHQK65J2.mjs';
 export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-GHQK65J2.mjs';
-export { PAYMENT_PLATFORMS, PLATFORM_METADATA, SUPPORTED_CHAIN_IDS, TOKEN_METADATA } from './chunk-P3NOBRQB.mjs';
-import { getContracts, getPaymentMethodsCatalog, getGatingServiceAddress } from './chunk-PYEJ4L76.mjs';
-export { enrichPvDepositView, enrichPvIntentView, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, parseDepositView, parseIntentView } from './chunk-PYEJ4L76.mjs';
+export { PAYMENT_PLATFORMS, PLATFORM_METADATA, SUPPORTED_CHAIN_IDS, TOKEN_METADATA } from './chunk-GYYD6SSA.mjs';
+import { getContracts, getPaymentMethodsCatalog, getGatingServiceAddress } from './chunk-W247BDNW.mjs';
+export { enrichPvDepositView, enrichPvIntentView, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, parseDepositView, parseIntentView } from './chunk-W247BDNW.mjs';
 import { resolvePaymentMethodHashFromCatalog, resolveFiatCurrencyBytes32 } from './chunk-GDKCACWH.mjs';
 export { asciiToBytes32, ensureBytes32, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-GDKCACWH.mjs';
-import { currencyKeccak256 } from './chunk-CM3RH5VZ.mjs';
-export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-CM3RH5VZ.mjs';
+import { currencyKeccak256 } from './chunk-NZ53KYLT.mjs';
+export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-NZ53KYLT.mjs';
+import './chunk-3QS3WKRC.mjs';
 import { concatHex, encodeFunctionData, createPublicClient, http } from 'viem';
 import { hardhat, baseSepolia, base } from 'viem/chains';
 import { AbiCoder } from 'ethers';
@@ -649,7 +650,7 @@ async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
   for (let i = 0; i < maxRetries; i++) {
     try {
       if (timeoutMs) {
-        const { withTimeout } = await import('./timeout-QB7K5SOB.mjs');
+        const { withTimeout } = await import('./timeout-7HCFGU6P.mjs');
         return await withTimeout(fn(), timeoutMs, `Operation timed out after ${timeoutMs}ms`);
       }
       return await fn();
@@ -767,6 +768,17 @@ async function apiFetch({
     return res.json();
   }, retryCount, retryDelayMs, timeoutMs);
 }
+function processApiResponse(data, transformDates = true) {
+  if (!transformDates) return data;
+  if (data.responseObject) {
+    if (Array.isArray(data.responseObject)) {
+      data.responseObject = data.responseObject.map((item) => transformDatesToObjects(item));
+    } else {
+      data.responseObject = transformDatesToObjects(data.responseObject);
+    }
+  }
+  return data;
+}
 async function apiPostDepositDetails(req, baseApiUrl, timeoutMs) {
   return apiFetch({
     url: `${baseApiUrl.replace(/\/$/, "")}/v1/makers/create`,
@@ -826,6 +838,34 @@ async function apiValidatePayeeDetails(req, baseApiUrl, timeoutMs) {
   }
   return data;
 }
+function transformDatesToObjects(obj) {
+  const dateFields = ["createdAt", "updatedAt", "signalTimestamp", "fulfillTimestamp", "prunedTimestamp"];
+  const transformed = { ...obj };
+  for (const key in transformed) {
+    const value = transformed[key];
+    if (dateFields.includes(key) && typeof value === "string") {
+      transformed[key] = new Date(value);
+    } else if (Array.isArray(value)) {
+      transformed[key] = value.map(
+        (item) => typeof item === "object" && item !== null ? transformDatesToObjects(item) : item
+      );
+    } else if (typeof value === "object" && value !== null) {
+      transformed[key] = transformDatesToObjects(value);
+    }
+  }
+  return transformed;
+}
+async function apiGetOwnerDeposits(req, apiKey, baseApiUrl, authToken, timeoutMs) {
+  const statusQuery = req.status ? `?status=${encodeURIComponent(req.status)}` : "";
+  const data = await apiFetch({
+    url: `${withApiBase(baseApiUrl)}/v1/deposits/maker/${req.ownerAddress}${statusQuery}`,
+    method: "GET",
+    apiKey,
+    authToken,
+    timeoutMs
+  });
+  return processApiResponse(data);
+}
 async function apiGetTakerTier(req, apiKey, baseApiUrl, authToken, timeoutMs) {
   const normalizedOwner = req.owner.toLowerCase();
   const query = new URLSearchParams({
@@ -884,6 +924,14 @@ function appendAttributionToCalldata(calldata, referrer) {
   const suffix = getAttributionDataSuffix(referrer);
   return concatHex([calldata, suffix]);
 }
+function encodeWithAttribution(request, referrer) {
+  const functionData = encodeFunctionData({
+    abi: request.abi,
+    functionName: request.functionName,
+    args: request.args || []
+  });
+  return appendAttributionToCalldata(functionData, referrer);
+}
 async function sendTransactionWithAttribution(walletClient, request, referrer, overrides) {
   const functionData = encodeFunctionData({
     abi: request.abi,
@@ -929,6 +977,413 @@ var Zkp2pClient = class {
    * @throws Error if walletClient is missing an account
    */
   constructor(opts) {
+    // ╔═══════════════════════════════════════════════════════════════════════════╗
+    // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
+    // ╚═══════════════════════════════════════════════════════════════════════════╝
+    /**
+     * Enables or disables a deposit from accepting new intents.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.accepting - Whether to accept new intents
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setAcceptingIntents = this.buildEscrowMethod(
+      "setAcceptingIntents",
+      (params) => [params.depositId, params.accepting]
+    );
+    /**
+     * Updates the min/max intent amount range for a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.min - Minimum intent amount
+     * @param params.max - Maximum intent amount
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setIntentRange = this.buildEscrowMethod(
+      "setIntentRange",
+      (params) => [params.depositId, { min: params.min, max: params.max }]
+    );
+    /**
+     * Updates the minimum conversion rate for a specific currency on a payment method.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash (bytes32)
+     * @param params.fiatCurrency - Fiat currency hash (bytes32)
+     * @param params.minConversionRate - New minimum conversion rate (18 decimals)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setCurrencyMinRate = this.buildEscrowMethod("setCurrencyMinRate", (params) => [
+      params.depositId,
+      params.paymentMethod,
+      params.fiatCurrency,
+      params.minConversionRate
+    ]);
+    /**
+     * Adds additional funds to an existing deposit.
+     * Requires prior approval of the token amount.
+     *
+     * @param params.depositId - The deposit ID to add funds to
+     * @param params.amount - Amount to add (in token units)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.addFunds = this.buildEscrowMethod(
+      "addFunds",
+      (params) => [params.depositId, params.amount]
+    );
+    /**
+     * Removes funds from a deposit (partial withdrawal).
+     * Can only withdraw available (non-locked) funds.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.amount - Amount to remove (in token units)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.removeFunds = this.buildEscrowMethod(
+      "removeFunds",
+      (params) => [params.depositId, params.amount]
+    );
+    /**
+     * Fully withdraws a deposit, returning all available funds to the owner.
+     * The deposit must have no active intents.
+     *
+     * @param params.depositId - The deposit ID to withdraw
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.withdrawDeposit = this.buildEscrowMethod(
+      "withdrawDeposit",
+      (params) => [params.depositId]
+    );
+    // ╔═══════════════════════════════════════════════════════════════════════════╗
+    // ║ CORE: ADVANCED DEPOSIT CONFIGURATION                                     ║
+    // ╚═══════════════════════════════════════════════════════════════════════════╝
+    /**
+     * Sets whether a deposit should remain active when its balance reaches zero.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.retain - If true, deposit stays active when empty
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setRetainOnEmpty = this.buildEscrowMethod(
+      "setRetainOnEmpty",
+      (params) => [params.depositId, params.retain]
+    );
+    /**
+     * Assigns a delegate address that can manage the deposit on behalf of the owner.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.delegate - Address to delegate management to
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setDelegate = this.buildEscrowMethod(
+      "setDelegate",
+      (params) => [params.depositId, params.delegate]
+    );
+    /**
+     * Removes the delegate from a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.removeDelegate = this.buildEscrowMethod(
+      "removeDelegate",
+      (params) => [params.depositId]
+    );
+    /**
+     * Adds new payment methods to an existing deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethods - Array of payment method hashes to add
+     * @param params.paymentMethodData - Corresponding payment method configuration
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.addPaymentMethods = this.buildEscrowMethod("addPaymentMethods", (params) => [params.depositId, params.paymentMethods, params.paymentMethodData, params.currencies]);
+    /**
+     * Activates or deactivates a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to modify
+     * @param params.isActive - Whether the payment method should accept intents
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.setPaymentMethodActive = this.buildEscrowMethod("setPaymentMethodActive", (params) => [params.depositId, params.paymentMethod, params.isActive]);
+    /**
+     * Deactivates a payment method on a deposit (convenience alias for setPaymentMethodActive).
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to deactivate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.removePaymentMethod = this.buildEscrowMethod(
+      "setPaymentMethodActive",
+      (params) => [params.depositId, params.paymentMethod, false]
+    );
+    /**
+     * Adds new currencies to a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash to add currencies to
+     * @param params.currencies - Array of currency configurations with code and min rate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.addCurrencies = this.buildEscrowMethod("addCurrencies", (params) => [params.depositId, params.paymentMethod, params.currencies]);
+    /**
+     * Deactivates a currency for a payment method on a deposit.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash
+     * @param params.currencyCode - Currency code hash to deactivate
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.deactivateCurrency = this.buildEscrowMethod("deactivateCurrency", (params) => [params.depositId, params.paymentMethod, params.currencyCode]);
+    /**
+     * Removes (deactivates) a currency from a payment method.
+     * Alias for deactivateCurrency.
+     *
+     * @param params.depositId - The deposit ID
+     * @param params.paymentMethod - Payment method hash
+     * @param params.currencyCode - Currency code hash to remove
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.removeCurrency = this.buildEscrowMethod(
+      "deactivateCurrency",
+      (params) => [params.depositId, params.paymentMethod, params.currencyCode]
+    );
+    /**
+     * Removes expired intents from a deposit, freeing up locked funds.
+     * Can be called by anyone (permissionless cleanup).
+     *
+     * @param params.depositId - The deposit ID to prune
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.pruneExpiredIntents = this.buildEscrowMethod(
+      "pruneExpiredIntents",
+      (params) => [params.depositId]
+    );
+    // ───────────────────────────────────────────────────────────────────────────
+    // SUPPORTING: INTENT OPERATIONS
+    // (Used by takers/buyers - not primary SDK functionality)
+    // ───────────────────────────────────────────────────────────────────────────
+    /**
+     * **Supporting Method** - Signals intent to use a deposit.
+     *
+     * > **Note**: This method is typically used by takers/buyers who want to
+     * > purchase crypto by paying fiat. Liquidity providers generally don't
+     * > need to call this method directly.
+     *
+     * This reserves funds from a deposit and creates an intent that must be
+     * fulfilled (via `fulfillIntent`) or will expire. The taker commits to
+     * sending fiat payment to the deposit's payee.
+     *
+     * If `gatingServiceSignature` is not provided, the SDK will automatically
+     * fetch one from the API (requires `apiKey` or `authorizationToken`).
+     *
+     * **Prepare Mode**: Use `.prepare()` to get the transaction calldata without sending:
+     * ```typescript
+     * const prepared = await client.signalIntent.prepare(params);
+     * // Submit via relayer or inspect calldata
+     * await relayer.submit({ to: prepared.to, data: prepared.data });
+     * ```
+     *
+     * @param params.depositId - The deposit to use
+     * @param params.amount - Amount of tokens to claim (in token units)
+     * @param params.toAddress - Address to receive the tokens when fulfilled
+     * @param params.processorName - Payment platform (e.g., 'wise', 'revolut')
+     * @param params.payeeDetails - Hashed payee details (from deposit)
+     * @param params.fiatCurrencyCode - Fiat currency code (e.g., 'USD', 'EUR')
+     * @param params.conversionRate - Agreed conversion rate (18 decimals)
+     * @param params.referrer - Optional referrer address for fee sharing
+     * @param params.referrerFee - Optional referrer fee amount
+     * @param params.postIntentHook - Optional hook contract to call after signaling
+     * @param params.data - Optional data to pass to the hook
+     * @param params.gatingServiceSignature - Pre-obtained signature (if not auto-fetching)
+     * @param params.signatureExpiration - Signature expiration timestamp
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Execute directly
+     * const hash = await client.signalIntent({
+     *   depositId: 42n,
+     *   amount: 100_000000n, // 100 USDC
+     *   toAddress: '0x...',
+     *   processorName: 'wise',
+     *   payeeDetails: '0x...',
+     *   fiatCurrencyCode: 'USD',
+     *   conversionRate: 1_020000000000000000n, // 1.02
+     * });
+     *
+     * // Or prepare for relayer submission
+     * const prepared = await client.signalIntent.prepare({
+     *   depositId: 42n,
+     *   amount: 100_000000n,
+     *   toAddress: '0x...',
+     *   processorName: 'wise',
+     *   payeeDetails: '0x...',
+     *   fiatCurrencyCode: 'USD',
+     *   conversionRate: 1_020000000000000000n,
+     * });
+     * // prepared.to, prepared.data, prepared.value, prepared.chainId
+     * ```
+     */
+    this.signalIntent = Object.assign(
+      async (params) => {
+        const prepared = await this.prepareSignalIntent(params);
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = await this.prepareSignalIntent(params);
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
+    /**
+     * **Supporting Method** - Cancels a signaled intent before fulfillment.
+     *
+     * Only the intent owner can cancel. Releases reserved funds back to the deposit.
+     *
+     * **Prepare Mode**: Use `.prepare()` to get the transaction calldata without sending:
+     * ```typescript
+     * const prepared = await client.cancelIntent.prepare({ intentHash });
+     * await relayer.submit({ to: prepared.to, data: prepared.data });
+     * ```
+     *
+     * @param params.intentHash - The intent hash to cancel (0x-prefixed, 32 bytes)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Execute directly
+     * const hash = await client.cancelIntent({ intentHash: '0x...' });
+     *
+     * // Or prepare for relayer submission
+     * const prepared = await client.cancelIntent.prepare({ intentHash: '0x...' });
+     * ```
+     */
+    this.cancelIntent = Object.assign(
+      async (params) => {
+        const prepared = await this.prepareCancelIntent(params);
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = await this.prepareCancelIntent(params);
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
+    /**
+     * **Supporting Method** - Releases funds back to the deposit owner.
+     *
+     * Called by the deposit owner when they want to reject an intent
+     * (e.g., payment verification failed or intent expired).
+     *
+     * @param params.intentHash - The intent hash (0x-prefixed, 32 bytes)
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @returns Transaction hash
+     */
+    this.releaseFundsToPayer = this.buildOrchestratorMethod(
+      "releaseFundsToPayer",
+      (params) => [params.intentHash]
+    );
+    /**
+     * **Supporting Method** - Fulfills an intent by submitting a payment proof.
+     *
+     * > **Note**: This method is typically used by takers/buyers after they've
+     * > sent fiat payment. Liquidity providers generally don't call this directly.
+     *
+     * This is the final step in the off-ramp flow. After the taker has sent
+     * fiat payment, they generate a proof (via the browser extension) and
+     * submit it here. The SDK handles attestation service calls automatically.
+     *
+     * **Flow:**
+     * 1. Intent parameters are derived from the indexer/ProtocolViewer
+     * 2. Proof is sent to the attestation service for verification
+     * 3. Attestation response is encoded and submitted on-chain
+     * 4. Funds are released to the intent's `toAddress`
+     *
+     * **Prepare Mode**: Use `.prepare()` to get the transaction calldata without sending:
+     * ```typescript
+     * const prepared = await client.fulfillIntent.prepare(params);
+     * // Submit via relayer or inspect calldata
+     * await relayer.submit({ to: prepared.to, data: prepared.data });
+     * ```
+     *
+     * @param params.intentHash - The intent hash to fulfill (0x-prefixed, 32 bytes)
+     * @param params.proof - Payment proof from Reclaim (object or JSON string)
+     * @param params.timestampBufferMs - Allowed timestamp variance (default: 300000ms)
+     * @param params.attestationServiceUrl - Override attestation service URL
+     * @param params.verifyingContract - Override verifier contract address
+     * @param params.postIntentHookData - Data to pass to post-intent hook
+     * @param params.txOverrides - Optional viem transaction overrides
+     * @param params.callbacks - Lifecycle callbacks for UI updates
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Execute directly
+     * const hash = await client.fulfillIntent({
+     *   intentHash: '0x...',
+     *   proof: proofFromExtension,
+     * });
+     *
+     * // Or prepare for relayer submission
+     * const prepared = await client.fulfillIntent.prepare({
+     *   intentHash: '0x...',
+     *   proof: proofFromExtension,
+     * });
+     * // prepared.to, prepared.data, prepared.value, prepared.chainId
+     * ```
+     */
+    this.fulfillIntent = Object.assign(
+      async (params) => {
+        params?.callbacks?.onAttestationStart?.();
+        const prepared = await this.prepareFulfillIntent(params);
+        const txHash = await this.executePreparedTransaction(prepared, params.txOverrides);
+        params?.callbacks?.onTxSent?.(txHash);
+        return txHash;
+      },
+      {
+        prepare: async (params) => {
+          params?.callbacks?.onAttestationStart?.();
+          const prepared = await this.prepareFulfillIntent(params);
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
     this.walletClient = opts.walletClient;
     this.chainId = opts.chainId;
     this.runtimeEnv = opts.runtimeEnv ?? "production";
@@ -991,6 +1446,129 @@ var Zkp2pClient = class {
       txOverrides
     );
   }
+  /**
+   * Execute a prepared transaction (simulation + send).
+   * Used internally by prepareable methods after preparation.
+   */
+  async executePreparedTransaction(prepared, txOverrides) {
+    const { referrer, ...overrides } = txOverrides ?? {};
+    await this.publicClient.simulateContract({
+      address: prepared.to,
+      abi: prepared.abi,
+      functionName: prepared.functionName,
+      args: prepared.args,
+      account: this.walletClient.account,
+      ...overrides
+    });
+    return this.walletClient.sendTransaction({
+      to: prepared.to,
+      data: prepared.data,
+      value: prepared.value,
+      account: this.walletClient.account,
+      chain: this.walletClient.chain,
+      ...overrides
+    });
+  }
+  prepareEscrowTransaction(opts) {
+    if (!this.escrowAddress || !this.escrowAbi) throw new Error("Escrow not available");
+    const { referrer, value } = opts.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: this.escrowAbi,
+        functionName: opts.functionName,
+        args: opts.args ?? []
+      },
+      referrer
+    );
+    return {
+      to: this.escrowAddress,
+      data,
+      value: opts.value ?? value ?? 0n,
+      chainId: this.chainId,
+      abi: this.escrowAbi,
+      functionName: opts.functionName,
+      args: opts.args ?? []
+    };
+  }
+  prepareOrchestratorTransaction(opts) {
+    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
+    const { referrer, value } = opts.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: this.orchestratorAbi,
+        functionName: opts.functionName,
+        args: opts.args ?? []
+      },
+      referrer
+    );
+    return {
+      to: this.orchestratorAddress,
+      data,
+      value: opts.value ?? value ?? 0n,
+      chainId: this.chainId,
+      abi: this.orchestratorAbi,
+      functionName: opts.functionName,
+      args: opts.args ?? []
+    };
+  }
+  buildEscrowMethod(functionName, buildArgs, buildValue) {
+    return Object.assign(
+      async (params) => {
+        const prepared = this.prepareEscrowTransaction({
+          functionName,
+          args: buildArgs(params),
+          txOverrides: params.txOverrides,
+          value: buildValue?.(params)
+        });
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = this.prepareEscrowTransaction({
+            functionName,
+            args: buildArgs(params),
+            txOverrides: params.txOverrides,
+            value: buildValue?.(params)
+          });
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
+  }
+  buildOrchestratorMethod(functionName, buildArgs, buildValue) {
+    return Object.assign(
+      async (params) => {
+        const prepared = this.prepareOrchestratorTransaction({
+          functionName,
+          args: buildArgs(params),
+          txOverrides: params.txOverrides,
+          value: buildValue?.(params)
+        });
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = this.prepareOrchestratorTransaction({
+            functionName,
+            args: buildArgs(params),
+            txOverrides: params.txOverrides,
+            value: buildValue?.(params)
+          });
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
+  }
   // ╔═══════════════════════════════════════════════════════════════════════════╗
   // ║ CORE: DEPOSIT QUERIES (RPC-first via ProtocolViewer)                     ║
   // ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -1314,7 +1892,29 @@ var Zkp2pClient = class {
    * ```
    */
   async createDeposit(params) {
-    const methods = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
+    const { depositDetails, prepared } = await this.prepareCreateDepositInternal(params);
+    const hash = await this.executePreparedTransaction(prepared, params.txOverrides);
+    return { depositDetails, hash };
+  }
+  /**
+   * Prepares a createDeposit transaction without sending it.
+   *
+   * Returns both the prepared transaction calldata and the posted deposit details
+   * (including hashed on-chain IDs) needed for tracking.
+   */
+  async prepareCreateDeposit(params) {
+    const { depositDetails, prepared } = await this.prepareCreateDepositInternal(params);
+    return {
+      depositDetails,
+      prepared: {
+        to: prepared.to,
+        data: prepared.data,
+        value: prepared.value,
+        chainId: prepared.chainId
+      }
+    };
+  }
+  async prepareCreateDepositInternal(params) {
     if (!Array.isArray(params.processorNames) || params.processorNames.length === 0) {
       throw new Error("processorNames must be a non-empty array");
     }
@@ -1324,40 +1924,59 @@ var Zkp2pClient = class {
     if (params.processorNames.length !== params.depositData.length) {
       throw new Error("processorNames and depositData length mismatch");
     }
-    const paymentMethods = params.processorNames.map((name) => resolvePaymentMethodHashFromCatalog(name, methods));
-    const intentGatingService = getGatingServiceAddress(this.chainId, this.runtimeEnv);
-    const baseApiUrl = (this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
-    if (!this.apiKey && !this.authorizationToken) {
-      throw new Error("createDeposit requires apiKey or authorizationToken to post deposit details");
-    }
     const depositDetails = params.processorNames.map((processorName, index) => ({
       processorName,
       depositData: params.depositData[index] || {}
     }));
-    const apiResponses = await Promise.all(
-      depositDetails.map((req) => apiPostDepositDetails(req, baseApiUrl, this.apiTimeoutMs))
+    const hasOverrides = Boolean(
+      params.paymentMethodsOverride || params.paymentMethodDataOverride || params.currenciesOverride
     );
-    if (!apiResponses.every((r) => r?.success)) {
-      const failed = apiResponses.find((r) => !r?.success);
-      throw new Error(failed?.message || "Failed to create deposit details");
-    }
-    const hashedOnchainIds = apiResponses.map((r) => r.responseObject?.hashedOnchainId);
-    const paymentMethodData = hashedOnchainIds.map((hid) => ({ intentGatingService, payeeDetails: hid, data: "0x" }));
-    params.conversionRates.forEach((group, i) => {
-      const key = params.processorNames[i]?.toLowerCase();
-      const allowed = methods[key]?.currencies?.map((c) => c.toLowerCase());
-      if (allowed && allowed.length) {
-        for (const { currency } of group) {
-          const codeHash = currencyKeccak256(String(currency).toUpperCase()).toLowerCase();
-          if (!allowed.includes(codeHash)) {
-            throw new Error(`Currency ${currency} not supported by ${params.processorNames[i]}. Allowed: ${allowed.join(", ")}`);
+    let paymentMethods;
+    let paymentMethodData;
+    let currencies;
+    if (hasOverrides) {
+      if (!params.paymentMethodsOverride || !params.paymentMethodDataOverride || !params.currenciesOverride) {
+        throw new Error("paymentMethodsOverride, paymentMethodDataOverride, and currenciesOverride must be provided together");
+      }
+      if (params.paymentMethodsOverride.length !== params.paymentMethodDataOverride.length || params.paymentMethodsOverride.length !== params.currenciesOverride.length) {
+        throw new Error("paymentMethodsOverride, paymentMethodDataOverride, and currenciesOverride length mismatch");
+      }
+      paymentMethods = params.paymentMethodsOverride;
+      paymentMethodData = params.paymentMethodDataOverride;
+      currencies = params.currenciesOverride;
+    } else {
+      const methods = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
+      paymentMethods = params.processorNames.map((name) => resolvePaymentMethodHashFromCatalog(name, methods));
+      const intentGatingService = getGatingServiceAddress(this.chainId, this.runtimeEnv);
+      const baseApiUrl = (this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
+      if (!this.apiKey && !this.authorizationToken) {
+        throw new Error("createDeposit requires apiKey or authorizationToken to post deposit details");
+      }
+      const apiResponses = await Promise.all(
+        depositDetails.map((req) => apiPostDepositDetails(req, baseApiUrl, this.apiTimeoutMs))
+      );
+      if (!apiResponses.every((r) => r?.success)) {
+        const failed = apiResponses.find((r) => !r?.success);
+        throw new Error(failed?.message || "Failed to create deposit details");
+      }
+      const hashedOnchainIds = apiResponses.map((r) => r.responseObject?.hashedOnchainId);
+      paymentMethodData = hashedOnchainIds.map((hid) => ({ intentGatingService, payeeDetails: hid, data: "0x" }));
+      params.conversionRates.forEach((group, i) => {
+        const key = params.processorNames[i]?.toLowerCase();
+        const allowed = methods[key]?.currencies?.map((c) => c.toLowerCase());
+        if (allowed && allowed.length) {
+          for (const { currency } of group) {
+            const codeHash = currencyKeccak256(String(currency).toUpperCase()).toLowerCase();
+            if (!allowed.includes(codeHash)) {
+              throw new Error(`Currency ${currency} not supported by ${params.processorNames[i]}. Allowed: ${allowed.join(", ")}`);
+            }
           }
         }
-      }
-    });
-    const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-RSSHQOM3.mjs');
-    const normalized = params.conversionRates.map((group) => group.map((r) => ({ currency: r.currency, conversionRate: r.conversionRate })));
-    const currencies = mapConversionRatesToOnchainMinRate2(normalized, paymentMethods.length);
+      });
+      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-UVK4OKUR.mjs');
+      const normalized = params.conversionRates.map((group) => group.map((r) => ({ currency: r.currency, conversionRate: r.conversionRate })));
+      currencies = mapConversionRatesToOnchainMinRate2(normalized, paymentMethods.length);
+    }
     const args = [{
       token: params.token,
       amount: params.amount,
@@ -1369,339 +1988,18 @@ var Zkp2pClient = class {
       intentGuardian: params.intentGuardian ?? "0x0000000000000000000000000000000000000000",
       retainOnEmpty: Boolean(params.retainOnEmpty ?? false)
     }];
-    const hash = await this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
+    const prepared = this.prepareEscrowTransaction({
       functionName: "createDeposit",
       args,
       txOverrides: params.txOverrides
     });
-    return { depositDetails, hash };
-  }
-  // ╔═══════════════════════════════════════════════════════════════════════════╗
-  // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
-  // ╚═══════════════════════════════════════════════════════════════════════════╝
-  /**
-   * Enables or disables a deposit from accepting new intents.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.accepting - Whether to accept new intents
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async setAcceptingIntents(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setAcceptingIntents",
-      args: [params.depositId, params.accepting],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Updates the min/max intent amount range for a deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.min - Minimum intent amount
-   * @param params.max - Maximum intent amount
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async setIntentRange(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setIntentRange",
-      args: [params.depositId, { min: params.min, max: params.max }],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Updates the minimum conversion rate for a specific currency on a payment method.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash (bytes32)
-   * @param params.fiatCurrency - Fiat currency hash (bytes32)
-   * @param params.minConversionRate - New minimum conversion rate (18 decimals)
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async setCurrencyMinRate(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setCurrencyMinRate",
-      args: [params.depositId, params.paymentMethod, params.fiatCurrency, params.minConversionRate],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Adds additional funds to an existing deposit.
-   * Requires prior approval of the token amount.
-   *
-   * @param params.depositId - The deposit ID to add funds to
-   * @param params.amount - Amount to add (in token units)
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async addFunds(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "addFunds",
-      args: [params.depositId, params.amount],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Removes funds from a deposit (partial withdrawal).
-   * Can only withdraw available (non-locked) funds.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.amount - Amount to remove (in token units)
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async removeFunds(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "removeFunds",
-      args: [params.depositId, params.amount],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Fully withdraws a deposit, returning all available funds to the owner.
-   * The deposit must have no active intents.
-   *
-   * @param params.depositId - The deposit ID to withdraw
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async withdrawDeposit(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "withdrawDeposit",
-      args: [params.depositId],
-      txOverrides: params.txOverrides
-    });
-  }
-  // ╔═══════════════════════════════════════════════════════════════════════════╗
-  // ║ CORE: ADVANCED DEPOSIT CONFIGURATION                                     ║
-  // ╚═══════════════════════════════════════════════════════════════════════════╝
-  /**
-   * Sets whether a deposit should remain active when its balance reaches zero.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.retain - If true, deposit stays active when empty
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async setRetainOnEmpty(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setRetainOnEmpty",
-      args: [params.depositId, params.retain],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Assigns a delegate address that can manage the deposit on behalf of the owner.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.delegate - Address to delegate management to
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async setDelegate(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setDelegate",
-      args: [params.depositId, params.delegate],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Removes the delegate from a deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async removeDelegate(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "removeDelegate",
-      args: [params.depositId],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Adds new payment methods to an existing deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethods - Array of payment method hashes to add
-   * @param params.paymentMethodData - Corresponding payment method configuration
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async addPaymentMethods(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "addPaymentMethods",
-      args: [params.depositId, params.paymentMethods, params.paymentMethodData],
-      txOverrides: params.txOverrides
-    });
+    return { depositDetails, prepared };
   }
   /**
-   * Activates or deactivates a payment method on a deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash to modify
-   * @param params.isActive - Whether the payment method should accept intents
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
+   * Prepare signalIntent transaction (all logic except simulation/send).
+   * Returns the prepared transaction with encoded calldata.
    */
-  async setPaymentMethodActive(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "setPaymentMethodActive",
-      args: [params.depositId, params.paymentMethod, params.isActive],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Deactivates a payment method on a deposit (convenience alias for setPaymentMethodActive).
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash to deactivate
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async removePaymentMethod(params) {
-    return this.setPaymentMethodActive({ depositId: params.depositId, paymentMethod: params.paymentMethod, isActive: false, txOverrides: params.txOverrides });
-  }
-  /**
-   * Adds new currencies to a payment method on a deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash to add currencies to
-   * @param params.currencies - Array of currency configurations with code and min rate
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async addCurrencies(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "addCurrencies",
-      args: [params.depositId, params.paymentMethod, params.currencies],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Deactivates a currency for a payment method on a deposit.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash
-   * @param params.currencyCode - Currency code hash to deactivate
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async deactivateCurrency(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "deactivateCurrency",
-      args: [params.depositId, params.paymentMethod, params.currencyCode],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * Removes (deactivates) a currency from a payment method.
-   * Alias for deactivateCurrency.
-   *
-   * @param params.depositId - The deposit ID
-   * @param params.paymentMethod - Payment method hash
-   * @param params.currencyCode - Currency code hash to remove
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async removeCurrency(params) {
-    return this.deactivateCurrency(params);
-  }
-  /**
-   * Removes expired intents from a deposit, freeing up locked funds.
-   * Can be called by anyone (permissionless cleanup).
-   *
-   * @param params.depositId - The deposit ID to prune
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async pruneExpiredIntents(params) {
-    return this.simulateAndSendWithAttribution({
-      address: this.escrowAddress,
-      abi: this.escrowAbi,
-      functionName: "pruneExpiredIntents",
-      args: [params.depositId],
-      txOverrides: params.txOverrides
-    });
-  }
-  // ───────────────────────────────────────────────────────────────────────────
-  // SUPPORTING: INTENT OPERATIONS
-  // (Used by takers/buyers - not primary SDK functionality)
-  // ───────────────────────────────────────────────────────────────────────────
-  /**
-   * **Supporting Method** - Signals intent to use a deposit.
-   *
-   * > **Note**: This method is typically used by takers/buyers who want to
-   * > purchase crypto by paying fiat. Liquidity providers generally don't
-   * > need to call this method directly.
-   *
-   * This reserves funds from a deposit and creates an intent that must be
-   * fulfilled (via `fulfillIntent`) or will expire. The taker commits to
-   * sending fiat payment to the deposit's payee.
-   *
-   * If `gatingServiceSignature` is not provided, the SDK will automatically
-   * fetch one from the API (requires `apiKey` or `authorizationToken`).
-   *
-   * @param params.depositId - The deposit to use
-   * @param params.amount - Amount of tokens to claim (in token units)
-   * @param params.toAddress - Address to receive the tokens when fulfilled
-   * @param params.processorName - Payment platform (e.g., 'wise', 'revolut')
-   * @param params.payeeDetails - Hashed payee details (from deposit)
-   * @param params.fiatCurrencyCode - Fiat currency code (e.g., 'USD', 'EUR')
-   * @param params.conversionRate - Agreed conversion rate (18 decimals)
-   * @param params.referrer - Optional referrer address for fee sharing
-   * @param params.referrerFee - Optional referrer fee amount
-   * @param params.postIntentHook - Optional hook contract to call after signaling
-   * @param params.data - Optional data to pass to the hook
-   * @param params.gatingServiceSignature - Pre-obtained signature (if not auto-fetching)
-   * @param params.signatureExpiration - Signature expiration timestamp
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   *
-   * @example
-   * ```typescript
-   * const hash = await client.signalIntent({
-   *   depositId: 42n,
-   *   amount: 100_000000n, // 100 USDC
-   *   toAddress: '0x...',
-   *   processorName: 'wise',
-   *   payeeDetails: '0x...',
-   *   fiatCurrencyCode: 'USD',
-   *   conversionRate: 1_020000000000000000n, // 1.02
-   * });
-   * ```
-   */
-  async signalIntent(params) {
+  async prepareSignalIntent(params) {
     if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
     const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
     const paymentMethod = resolvePaymentMethodHashFromCatalog(params.processorName, catalog);
@@ -1747,80 +2045,55 @@ var Zkp2pClient = class {
       postIntentHook: params.postIntentHook ?? "0x0000000000000000000000000000000000000000",
       data: params.data ?? "0x"
     }];
-    return this.simulateAndSendWithAttribution({
-      address: this.orchestratorAddress,
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: this.orchestratorAbi,
+        functionName: "signalIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: this.orchestratorAddress,
+      data,
+      value: 0n,
+      chainId: this.chainId,
       abi: this.orchestratorAbi,
       functionName: "signalIntent",
-      args,
-      txOverrides: params.txOverrides
-    });
+      args
+    };
   }
   /**
-   * **Supporting Method** - Cancels a signaled intent before fulfillment.
-   *
-   * Only the intent owner can cancel. Releases reserved funds back to the deposit.
-   *
-   * @param params.intentHash - The intent hash to cancel (0x-prefixed, 32 bytes)
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
+   * Prepare cancelIntent transaction (all logic except simulation/send).
    */
-  async cancelIntent(params) {
+  async prepareCancelIntent(params) {
     if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
-    return this.simulateAndSendWithAttribution({
-      address: this.orchestratorAddress,
+    const args = [params.intentHash];
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: this.orchestratorAbi,
+        functionName: "cancelIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: this.orchestratorAddress,
+      data,
+      value: 0n,
+      chainId: this.chainId,
       abi: this.orchestratorAbi,
       functionName: "cancelIntent",
-      args: [params.intentHash],
-      txOverrides: params.txOverrides
-    });
-  }
-  /**
-   * **Supporting Method** - Releases funds back to the deposit owner.
-   *
-   * Called by the deposit owner when they want to reject an intent
-   * (e.g., payment verification failed or intent expired).
-   *
-   * @param params.intentHash - The intent hash (0x-prefixed, 32 bytes)
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @returns Transaction hash
-   */
-  async releaseFundsToPayer(params) {
-    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
-    return this.simulateAndSendWithAttribution({
-      address: this.orchestratorAddress,
-      abi: this.orchestratorAbi,
-      functionName: "releaseFundsToPayer",
-      args: [params.intentHash],
-      txOverrides: params.txOverrides
-    });
+      args
+    };
   }
   /**
-   * **Supporting Method** - Fulfills an intent by submitting a payment proof.
-   *
-   * > **Note**: This method is typically used by takers/buyers after they've
-   * > sent fiat payment. Liquidity providers generally don't call this directly.
-   *
-   * This is the final step in the off-ramp flow. After the taker has sent
-   * fiat payment, they generate a proof (via the browser extension) and
-   * submit it here. The SDK handles attestation service calls automatically.
-   *
-   * **Flow:**
-   * 1. Intent parameters are derived from the indexer/ProtocolViewer
-   * 2. Proof is sent to the attestation service for verification
-   * 3. Attestation response is encoded and submitted on-chain
-   * 4. Funds are released to the intent's `toAddress`
-   *
-   * @param params.intentHash - The intent hash to fulfill (0x-prefixed, 32 bytes)
-   * @param params.proof - Payment proof from Reclaim (object or JSON string)
-   * @param params.timestampBufferMs - Allowed timestamp variance (default: 300000ms)
-   * @param params.attestationServiceUrl - Override attestation service URL
-   * @param params.verifyingContract - Override verifier contract address
-   * @param params.postIntentHookData - Data to pass to post-intent hook
-   * @param params.txOverrides - Optional viem transaction overrides
-   * @param params.callbacks - Lifecycle callbacks for UI updates
-   * @returns Transaction hash
+   * Prepare fulfillIntent transaction (all logic except simulation/send).
+   * Includes fetching intent inputs and calling attestation service.
    */
-  async fulfillIntent(params) {
+  async prepareFulfillIntent(params) {
     if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
     const intentHash = params.intentHash;
     const attUrl = params.attestationServiceUrl ?? this.defaultAttestationService();
@@ -1834,10 +2107,10 @@ var Zkp2pClient = class {
     const paymentMethodHash = inputs.paymentMethodHash || "0x";
     const timestampBufferMs = params.timestampBufferMs ?? "300000";
     const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
-    const { resolvePaymentMethodNameFromHash: resolvePaymentMethodNameFromHash2 } = await import('./paymentResolution-4AAJVIIC.mjs');
+    const { resolvePaymentMethodNameFromHash: resolvePaymentMethodNameFromHash2 } = await import('./paymentResolution-2FP3NLM3.mjs');
     const platformName = resolvePaymentMethodNameFromHash2(paymentMethodHash, catalog);
     if (!platformName) throw new Error("Unknown paymentMethodHash for this network/env; update SDK catalogs.");
-    const { resolvePlatformAttestationConfig } = await import('./constants-Y2IWTA6H.mjs');
+    const { resolvePlatformAttestationConfig } = await import('./constants-ZICRSYZM.mjs');
     const cfg = resolvePlatformAttestationConfig(platformName);
     const platform = cfg.actionPlatform;
     const actionType = cfg.actionType;
@@ -1858,7 +2131,6 @@ var Zkp2pClient = class {
         timestampBufferMs
       }
     };
-    params?.callbacks?.onAttestationStart?.();
     const att = await apiCreatePaymentAttestation(payload, attUrl, platform, actionType);
     const paymentProof = encodePaymentAttestation(att);
     const verificationData = encodeVerifyPaymentData({
@@ -1872,15 +2144,24 @@ var Zkp2pClient = class {
       verificationData,
       postIntentHookData: params.postIntentHookData ?? "0x"
     }];
-    const txHash = await this.simulateAndSendWithAttribution({
-      address: this.orchestratorAddress,
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: this.orchestratorAbi,
+        functionName: "fulfillIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: this.orchestratorAddress,
+      data,
+      value: 0n,
+      chainId: this.chainId,
       abi: this.orchestratorAbi,
       functionName: "fulfillIntent",
-      args,
-      txOverrides: params.txOverrides
-    });
-    params?.callbacks?.onTxSent?.(txHash);
-    return txHash;
+      args
+    };
   }
   defaultAttestationService() {
     return this.runtimeEnv === "staging" ? "https://attestation-service-staging.zkp2p.xyz" : "https://attestation-service.zkp2p.xyz";
@@ -1991,11 +2272,11 @@ var Zkp2pClient = class {
     try {
       const { address, abi } = this.requireProtocolViewer();
       const raw = await this.publicClient.readContract({ address, abi, functionName: "getDeposit", args: [id] });
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
       return parseDepositView2(raw);
     } catch (e) {
       const raw = await this.publicClient.readContract({ address: this.escrowAddress, abi: this.escrowAbi, functionName: "getDeposit", args: [id] });
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
       return parseDepositView2(raw);
     }
   }
@@ -2007,7 +2288,7 @@ var Zkp2pClient = class {
    */
   async getPvDepositsFromIds(ids) {
     if (!this.protocolViewerAddress || !this.protocolViewerAbi) {
-      const { parseDepositView: parseDepositView3 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+      const { parseDepositView: parseDepositView3 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
       const results = [];
       for (const id of ids) {
         const raw2 = await this.publicClient.readContract({
@@ -2027,7 +2308,7 @@ var Zkp2pClient = class {
       functionName: "getDepositFromIds",
       args: [bn]
     });
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
     return raw.map(parseDepositView2);
   }
   /**
@@ -2040,11 +2321,11 @@ var Zkp2pClient = class {
     try {
       const { address, abi } = this.requireProtocolViewer();
       const raw = await this.publicClient.readContract({ address, abi, functionName: "getAccountDeposits", args: [owner] });
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
       return raw.map(parseDepositView2);
     } catch (e) {
       const raw = await this.publicClient.readContract({ address: this.escrowAddress, abi: this.escrowAbi, functionName: "getAccountDeposits", args: [owner] });
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
       return raw.map(parseDepositView2);
     }
   }
@@ -2063,7 +2344,7 @@ var Zkp2pClient = class {
       functionName: "getAccountIntents",
       args: [owner]
     });
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
     return raw.map(parseIntentView2);
   }
   /**
@@ -2080,7 +2361,7 @@ var Zkp2pClient = class {
       functionName: "getIntent",
       args: [intentHash]
     });
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-3QIR3XMT.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-EH5DGVSU.mjs');
     return parseIntentView2(raw);
   }
   // ╔═══════════════════════════════════════════════════════════════════════════╗
@@ -2182,6 +2463,199 @@ var Zkp2pClient = class {
   }
 };
 
+// src/extension.ts
+var PEER_EXTENSION_CHROME_URL = "https://chromewebstore.google.com/detail/peerauth-authenticate-and/ijpgccednehjpeclfcllnjjcmiohdjih";
+var resolveWindow = (options) => {
+  if (options?.window) {
+    return options.window;
+  }
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+};
+var requirePeer = (options) => {
+  const resolvedWindow = resolveWindow(options);
+  if (!resolvedWindow) {
+    throw new Error("Peer extension SDK requires a browser window.");
+  }
+  if (!resolvedWindow.peer) {
+    throw new Error("Peer extension not available. Install or enable the Peer extension.");
+  }
+  return resolvedWindow.peer;
+};
+var isPeerExtensionAvailable = (options) => {
+  const resolvedWindow = resolveWindow(options);
+  return Boolean(resolvedWindow?.peer);
+};
+var openPeerExtensionInstallPage = (options) => {
+  const resolvedWindow = resolveWindow(options);
+  if (!resolvedWindow) {
+    throw new Error("Peer extension SDK requires a browser window.");
+  }
+  resolvedWindow.open(PEER_EXTENSION_CHROME_URL, "_blank", "noopener,noreferrer");
+};
+var getPeerExtensionState = async (options) => {
+  if (!isPeerExtensionAvailable(options)) {
+    return "needs_install";
+  }
+  try {
+    const status = await requirePeer(options).checkConnectionStatus();
+    return status === "connected" ? "ready" : "needs_connection";
+  } catch (error) {
+    return "needs_connection";
+  }
+};
+var fiatAmountRegex = /^-?\d*(\.\d{0,6})?$/;
+var usdcAmountRegex = /^\d+$/;
+var assertObjectInput = (params) => {
+  if (params === void 0) {
+    return {};
+  }
+  if (params === null || typeof params !== "object" || Array.isArray(params)) {
+    throw new Error("Peer extension onramp expects an object of query params.");
+  }
+  return params;
+};
+var normalizeOptionalString = (value, label) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Peer extension onramp ${label} must be a non-empty string.`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`Peer extension onramp ${label} must be a non-empty string.`);
+  }
+  return trimmed;
+};
+var normalizeOptionalUrl = (value, label) => {
+  const trimmed = normalizeOptionalString(value, label);
+  if (trimmed === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch (error) {
+    throw new Error(`Peer extension onramp ${label} must be a valid URL.`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Peer extension onramp ${label} must use http or https.`);
+  }
+  return trimmed;
+};
+var normalizeFiatAmount = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = typeof value === "number" ? String(value) : value;
+  if (typeof normalized !== "string") {
+    throw new Error("Peer extension onramp inputAmount must be a string or number.");
+  }
+  const trimmed = normalized.trim();
+  if (!trimmed) {
+    throw new Error("Peer extension onramp inputAmount must be a non-empty value.");
+  }
+  if (!fiatAmountRegex.test(trimmed)) {
+    throw new Error(
+      "Peer extension onramp inputAmount must be a non-negative number with up to 6 decimals."
+    );
+  }
+  if (Number.isNaN(Number(trimmed)) || Number(trimmed) < 0) {
+    throw new Error(
+      "Peer extension onramp inputAmount must be a non-negative number with up to 6 decimals."
+    );
+  }
+  return trimmed;
+};
+var normalizeUsdcAmount = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error("Peer extension onramp amountUsdc must be a non-negative integer.");
+    }
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+      throw new Error("Peer extension onramp amountUsdc must be a non-negative integer.");
+    }
+    return String(value);
+  }
+  if (typeof value !== "string") {
+    throw new Error("Peer extension onramp amountUsdc must be a string, number, or bigint.");
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Peer extension onramp amountUsdc must be a non-empty value.");
+  }
+  if (!usdcAmountRegex.test(trimmed)) {
+    throw new Error("Peer extension onramp amountUsdc must be a non-negative integer.");
+  }
+  return trimmed;
+};
+var intentHashRegex = /^0x[a-fA-F0-9]{64}$/;
+var normalizeIntentHash = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error("Peer extension onramp intentHash must be a string.");
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Peer extension onramp intentHash must be a non-empty string.");
+  }
+  if (!intentHashRegex.test(trimmed)) {
+    throw new Error(
+      "Peer extension onramp intentHash must be a valid bytes32 hex string (0x + 64 hex characters)."
+    );
+  }
+  return trimmed.toLowerCase();
+};
+var buildOnrampQueryString = (params) => {
+  const validated = assertObjectInput(params);
+  const searchParams = new URLSearchParams();
+  const setParam = (key, value) => {
+    if (value !== void 0) {
+      searchParams.set(key, value);
+    }
+  };
+  setParam("referrer", normalizeOptionalString(validated.referrer, "referrer"));
+  setParam("referrerLogo", normalizeOptionalUrl(validated.referrerLogo, "referrerLogo"));
+  setParam("inputCurrency", normalizeOptionalString(validated.inputCurrency, "inputCurrency"));
+  setParam("inputAmount", normalizeFiatAmount(validated.inputAmount));
+  setParam(
+    "paymentPlatform",
+    normalizeOptionalString(validated.paymentPlatform, "paymentPlatform")
+  );
+  setParam("toToken", normalizeOptionalString(validated.toToken, "toToken"));
+  setParam("amountUsdc", normalizeUsdcAmount(validated.amountUsdc));
+  setParam(
+    "recipientAddress",
+    normalizeOptionalString(validated.recipientAddress, "recipientAddress")
+  );
+  setParam("callbackUrl", normalizeOptionalUrl(validated.callbackUrl, "callbackUrl"));
+  setParam("intentHash", normalizeIntentHash(validated.intentHash));
+  return searchParams.toString();
+};
+var createPeerExtensionSdk = (options = {}) => ({
+  isAvailable: () => isPeerExtensionAvailable(options),
+  requestConnection: () => requirePeer(options).requestConnection(),
+  checkConnectionStatus: () => requirePeer(options).checkConnectionStatus(),
+  openSidebar: (route) => requirePeer(options).openSidebar(route),
+  onramp: (params) => requirePeer(options).onramp(buildOnrampQueryString(params)),
+  onProofComplete: (callback) => requirePeer(options).onProofComplete(callback),
+  getVersion: () => requirePeer(options).getVersion(),
+  openInstallPage: () => openPeerExtensionInstallPage(options),
+  getState: () => getPeerExtensionState(options)
+});
+var peerExtensionSdk = createPeerExtensionSdk();
+
 // src/utils/logger.ts
 var currentLevel = "info";
 function setLogLevel(level) {
@@ -2220,6 +2694,6 @@ var logger = {
   }
 };
 
-export { BASE_BUILDER_CODE, IndexerClient, IndexerDepositService, Zkp2pClient as OfframpClient, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiGetPayeeDetails, apiGetTakerTier, apiPostDepositDetails, apiValidatePayeeDetails, appendAttributionToCalldata, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, defaultIndexerEndpoint, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, logger, sendTransactionWithAttribution, setLogLevel };
+export { BASE_BUILDER_CODE, IndexerClient, IndexerDepositService, Zkp2pClient as OfframpClient, PEER_EXTENSION_CHROME_URL, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetTakerTier, apiPostDepositDetails, apiValidatePayeeDetails, appendAttributionToCalldata, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createPeerExtensionSdk, defaultIndexerEndpoint, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, isPeerExtensionAvailable, logger, openPeerExtensionInstallPage, peerExtensionSdk, sendTransactionWithAttribution, setLogLevel };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map