@zkp2p/cash 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -3,6 +3,8 @@
 var viem = require('viem');
 var chains = require('viem/chains');
 var sdk = require('@zkp2p/sdk');
+var relaySdk = require('@relayprotocol/relay-sdk');
+var chainUtils = require('@relayprotocol/relay-sdk/chain-utils');
 var zod = require('zod');
 
 // src/client/createCashClient.ts
@@ -430,10 +432,13 @@ function buildCapabilities(environment) {
     };
   }).filter((p) => p.currencies.length > 0).sort((a, b) => a.platform.localeCompare(b.platform));
   const currencies = [...new Set(platforms.flatMap((p) => p.currencies))].sort();
+  const baseUsdc = { address: BASE_USDC_ADDRESS, symbol: "USDC", decimals: USDC_DECIMALS };
   return {
     chainId: BASE_CHAIN_ID,
-    token: { address: BASE_USDC_ADDRESS, symbol: "USDC", decimals: USDC_DECIMALS },
+    token: baseUsdc,
     environment,
+    destination: { chainId: BASE_CHAIN_ID, token: baseUsdc },
+    source: { default: { chainId: BASE_CHAIN_ID, token: baseUsdc } },
     platforms,
     currencies,
     amount: { min: MIN_CASHOUT_AMOUNT, recommendedMin: RECOMMENDED_MIN_CASHOUT_AMOUNT, max: null },
@@ -539,6 +544,18 @@ var errors = {
     },
     { cause }
   ),
+  sourceRouteUnsupportedInPrepare: () => new CashError({
+    code: "SOURCE_ROUTE_UNSUPPORTED_IN_PREPARE",
+    message: `prepare() cannot execute a Relay source route before creating the Base USDC cash-out.`,
+    retryable: false,
+    remediation: `Use cashout(inputWithSource, { signer }) for the one-call bridge-then-cashout flow, or call quoteSource()/executeSourceQuote() first and then prepare() a Base USDC cash-out.`
+  }),
+  sourceRecipientMismatch: (recipient, owner) => new CashError({
+    code: "SOURCE_RECIPIENT_MISMATCH",
+    message: `Source recipient ${recipient} does not match the cash-out depositor ${owner}.`,
+    retryable: false,
+    remediation: `For one-call source cashout, deliver Relay output to the depositor address. For a different recipient, bridge first and then cash out from that recipient's signer.`
+  }),
   allowanceNotVisible: (amount) => new CashError({
     code: "ALLOWANCE_NOT_VISIBLE",
     message: `USDC approval for ${amount} base units did not become visible on the read path in time.`,
@@ -598,6 +615,293 @@ function mapChainError(verb, err) {
   }
   return errors.chainCallFailed(verb, err);
 }
+var ETA_WINDOW_DAYS = 7;
+var ETA_WINDOW_SECONDS = ETA_WINDOW_DAYS * 24 * 60 * 60;
+var ETA_SAMPLE_LIMIT = 250;
+var FULFILLED = /* @__PURE__ */ new Set(["FULFILLED", "MANUALLY_RELEASED"]);
+function toUnixSeconds2(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  if (value instanceof Date) {
+    const seconds = Math.floor(value.getTime() / 1e3);
+    return Number.isFinite(seconds) && seconds > 0 ? seconds : void 0;
+  }
+  if (typeof value === "string" && /[TZ:-]/.test(value)) {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return Math.floor(parsed / 1e3);
+  }
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function median(values) {
+  if (values.length === 0) return void 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function etaLabel(seconds) {
+  if (seconds === void 0) return "Recent fill time unavailable";
+  if (seconds < 60) return "Usually starts in under a minute";
+  const minutes = Math.max(1, Math.round(seconds / 60));
+  if (minutes < 60) return `Usually starts in about ${minutes} min`;
+  const hours = Math.max(1, Math.round(minutes / 60));
+  return `Usually starts in about ${hours} hr`;
+}
+function matchesPayout(deposit, environment, platform, currency) {
+  const payouts = derivePayouts(
+    deposit.paymentMethods ?? [],
+    deposit.currencies ?? [],
+    sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment)
+  );
+  if (payouts.length === 0) return true;
+  return payouts.some(
+    (payout) => (platform === void 0 || payout.platform === platform) && (currency === void 0 || payout.currency === currency)
+  );
+}
+async function readFillEta(client, input) {
+  const now = Math.floor(Date.now() / 1e3);
+  const windowStart = now - ETA_WINDOW_SECONDS;
+  const deposits = await client.indexer.getDepositsWithRelations(
+    { chainId: BASE_CHAIN_ID },
+    { limit: ETA_SAMPLE_LIMIT, orderBy: "updatedAt", orderDirection: "desc" },
+    { includeIntents: true, intentStatuses: ["FULFILLED", "MANUALLY_RELEASED"] }
+  );
+  const firstFillLatencies = [];
+  for (const deposit of deposits) {
+    const createdAt = toUnixSeconds2(deposit.createdAt ?? deposit.timestamp);
+    if (createdAt === void 0 || createdAt < windowStart) continue;
+    if (!matchesPayout(deposit, input.environment, input.platform, input.currency)) continue;
+    const fulfilled = (deposit.intents ?? []).filter((intent) => intent.status != null && FULFILLED.has(intent.status)).map((intent) => ({
+      fulfilledAt: toUnixSeconds2(intent.fulfillTimestamp)
+    })).filter(
+      (intent) => intent.fulfilledAt !== void 0 && intent.fulfilledAt >= createdAt
+    ).sort((a, b) => a.fulfilledAt - b.fulfilledAt);
+    if (fulfilled.length === 0) continue;
+    firstFillLatencies.push(fulfilled[0].fulfilledAt - createdAt);
+  }
+  const seconds = median(firstFillLatencies);
+  return {
+    ...seconds !== void 0 ? { seconds } : {},
+    label: etaLabel(seconds)
+  };
+}
+var RELAY_API_URL = relaySdk.MAINNET_RELAY_API;
+var NATIVE_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
+var BASE_USDC_ASSET = {
+  chainId: BASE_CHAIN_ID,
+  address: BASE_USDC_ADDRESS,
+  symbol: "USDC",
+  decimals: USDC_DECIMALS,
+  name: "USD Coin"
+};
+function relayClient(options = {}) {
+  if (options.client) return options.client;
+  return relaySdk.createClient({
+    baseApiUrl: options.apiUrl ?? RELAY_API_URL,
+    source: options.source ?? "peer-cash",
+    ...options.apiKey ? { apiKey: options.apiKey } : {},
+    ...options.chains ? { chains: options.chains } : {}
+  });
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+function normalizeToken(chainId, token) {
+  const row = asRecord(token);
+  const address = asString(row.address);
+  const symbol = asString(row.symbol);
+  const decimals = asNumber(row.decimals);
+  const name = asString(row.name);
+  if (!address || !symbol || decimals === void 0) return null;
+  const metadata = asRecord(row.metadata);
+  return {
+    chainId,
+    address,
+    symbol,
+    decimals,
+    ...name ? { name } : {},
+    ...metadata.isNative === true || address.toLowerCase() === NATIVE_TOKEN_ADDRESS ? { isNative: true } : {}
+  };
+}
+function normalizeTx(data, chainId) {
+  const row = asRecord(data);
+  const to = asString(row.to);
+  const calldata = asString(row.data) ?? "0x";
+  if (!to) return null;
+  return {
+    to,
+    data: calldata,
+    value: BigInt(String(row.value ?? "0")),
+    chainId: asNumber(row.chainId) ?? chainId
+  };
+}
+function normalizeChain(chain) {
+  const row = asRecord(chain);
+  const tokenRows = [
+    chain.currency,
+    ...chain.featuredTokens ?? [],
+    ...chain.erc20Currencies ?? [],
+    ...chain.solverCurrencies ?? []
+  ];
+  const tokens = /* @__PURE__ */ new Map();
+  for (const token of tokenRows) {
+    const normalizedToken = normalizeToken(chain.id, token);
+    if (normalizedToken) tokens.set(normalizedToken.address.toLowerCase(), normalizedToken);
+  }
+  return {
+    id: chain.id,
+    name: chain.name,
+    displayName: chain.displayName,
+    disabled: row.disabled === true,
+    depositEnabled: chain.depositEnabled ?? false,
+    blockProductionLagging: chain.blockProductionLagging ?? false,
+    ...chain.vmType ? { vmType: chain.vmType } : {},
+    tokens: [...tokens.values()].sort((a, b) => a.symbol.localeCompare(b.symbol))
+  };
+}
+function isSupportedEvmChain(chain) {
+  return chain.vmType === void 0 || chain.vmType === "evm";
+}
+function quoteRequestId(quote) {
+  return quote.steps.map((step) => step.requestId).find((id) => id !== void 0);
+}
+function quoteSourceChainId(quote) {
+  const details = asRecord(quote.details);
+  const currencyIn = asRecord(details.currencyIn);
+  const sourceCurrency = asRecord(currencyIn.currency);
+  return asNumber(sourceCurrency.chainId);
+}
+function sanitizeRelayQuoteRaw(quote) {
+  if (!quote.request) return quote;
+  const request = { ...quote.request };
+  delete request.headers;
+  return { ...quote, request };
+}
+async function resolveRelayChains(options, client, config = {}) {
+  const preferInjectedClientChains = config.preferInjectedClientChains ?? true;
+  const chains = options.chains ?? (preferInjectedClientChains && options.client?.chains?.length ? options.client.chains : void 0) ?? (options.client ? await chainUtils.fetchChainConfigs(client.baseApiUrl, client.source, client.apiKey) : await chainUtils.configureDynamicChains());
+  client.chains = chains;
+  return chains;
+}
+function relayQuoteFromExecute(input, quote) {
+  const details = asRecord(quote.details);
+  const currencyIn = asRecord(details.currencyIn);
+  const currencyOut = asRecord(details.currencyOut);
+  const sourceCurrency = asRecord(currencyIn.currency);
+  const destinationCurrency = asRecord(currencyOut.currency);
+  const source = normalizeToken(input.source.chainId, sourceCurrency) ?? {
+    chainId: input.source.chainId,
+    address: input.source.currency,
+    symbol: "TOKEN",
+    decimals: 0
+  };
+  const destination = normalizeToken(BASE_CHAIN_ID, destinationCurrency) ?? BASE_USDC_ASSET;
+  const txs = quote.steps.flatMap(
+    (step) => step.items.map((item) => normalizeTx(item.data, input.source.chainId)).filter((tx) => tx !== null)
+  );
+  const outputAmount = BigInt(
+    String(currencyOut.minimumAmount ?? currencyOut.amount ?? input.amount.toString())
+  );
+  const requestId = quoteRequestId(quote);
+  const rate = asNumber(details.rate);
+  const timeEstimateSeconds = asNumber(details.timeEstimate);
+  return {
+    ...requestId ? { requestId } : {},
+    source,
+    destination,
+    inputAmount: BigInt(String(currencyIn.amount ?? input.amount.toString())),
+    outputAmount,
+    ...rate !== void 0 ? { rate } : {},
+    ...timeEstimateSeconds !== void 0 ? { timeEstimateSeconds } : {},
+    ...quote.fees !== void 0 ? { fees: quote.fees } : {},
+    txs,
+    raw: sanitizeRelayQuoteRaw(quote)
+  };
+}
+async function readRelaySourceCapabilities(options = {}) {
+  const client = relayClient(options);
+  const chains = await resolveRelayChains(options, client);
+  return {
+    destination: BASE_USDC_ASSET,
+    chains: chains.map(normalizeChain).filter((chain) => chain.tokens.length > 0 && isSupportedEvmChain(chain)).sort((a, b) => a.displayName.localeCompare(b.displayName)),
+    source: "relay-sdk",
+    asOf: Math.floor(Date.now() / 1e3)
+  };
+}
+async function quoteRelayToBaseUsdc(input, options = {}) {
+  const client = relayClient(options);
+  const quote = await client.actions.getQuote(
+    {
+      chainId: input.source.chainId,
+      currency: input.source.currency,
+      toChainId: BASE_CHAIN_ID,
+      toCurrency: BASE_USDC_ADDRESS,
+      user: input.user,
+      recipient: input.recipient ?? input.user,
+      amount: input.amount.toString(),
+      tradeType: input.tradeType ?? "EXACT_INPUT"
+    },
+    false
+  );
+  return relayQuoteFromExecute(input, quote);
+}
+async function executeRelayQuote(quote, wallet, options = {}) {
+  const client = relayClient(options.relay);
+  const sourceChainId = quoteSourceChainId(quote);
+  if (sourceChainId !== void 0 && !(client.chains ?? []).some((chain) => chain.id === sourceChainId)) {
+    await resolveRelayChains(options.relay ?? {}, client, { preferInjectedClientChains: false });
+  }
+  const { data } = await client.actions.execute({
+    quote,
+    wallet,
+    ...options.onProgress ? { onProgress: options.onProgress } : {},
+    ...options.disableCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: options.disableCapabilitiesCheck } : {}
+  });
+  const requestId = quoteRequestId(data);
+  return {
+    ...requestId ? { requestId } : {},
+    txHashes: data.steps.flatMap(
+      (step) => step.items.flatMap((item) => (item.txHashes ?? []).map((tx) => tx.txHash))
+    ),
+    quote: data
+  };
+}
+async function readRelayStatus(requestId, options = {}) {
+  const client = relayClient(options);
+  const response = await client.utils.request({
+    url: `${client.baseApiUrl}/intents/status/v3`,
+    method: "get",
+    params: { requestId }
+  });
+  const root = asRecord(response.data);
+  const status = asString(root.status);
+  if (status !== "refund" && status !== "waiting" && status !== "depositing" && status !== "failure" && status !== "pending" && status !== "submitted" && status !== "success") {
+    throw new Error(`Relay returned unknown status: ${String(root.status)}`);
+  }
+  const details = asString(root.details);
+  const updatedAt = asNumber(root.updatedAt);
+  const originChainId = asNumber(root.originChainId);
+  const destinationChainId = asNumber(root.destinationChainId);
+  const quoteCreatedAt = asNumber(root.quoteCreatedAt);
+  return {
+    requestId,
+    status,
+    ...details ? { details } : {},
+    inTxHashes: Array.isArray(root.inTxHashes) ? root.inTxHashes.map(String) : [],
+    txHashes: Array.isArray(root.txHashes) ? root.txHashes.map(String) : [],
+    ...updatedAt !== void 0 ? { updatedAt } : {},
+    ...originChainId !== void 0 ? { originChainId } : {},
+    ...destinationChainId !== void 0 ? { destinationChainId } : {},
+    ...quoteCreatedAt !== void 0 ? { quoteCreatedAt } : {},
+    raw: response.data
+  };
+}
 
 // src/client/estimate.ts
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -617,14 +921,25 @@ var CHAINLINK_LATEST_ROUND_ABI = [
   }
 ];
 var DEFAULT_MAX_STALENESS_SECONDS = 86400;
-async function readEstimate(publicClient, input) {
-  const { amount, currency } = input;
-  if (amount < MIN_CASHOUT_AMOUNT) {
-    throw errors.amountBelowMinimum(amount, MIN_CASHOUT_AMOUNT);
-  }
+async function readEstimate(publicClient, input, context = {}) {
+  const { currency } = input;
   if (!isMarketRateSupported(currency)) {
     throw errors.oracleUnsupportedCurrency(currency);
   }
+  const relayQuote = input.source !== void 0 ? await quoteRelayToBaseUsdc(
+    {
+      user: input.source.user,
+      amount: input.amount,
+      source: { chainId: input.source.chainId, currency: input.source.currency },
+      ...input.source.recipient ? { recipient: input.source.recipient } : {},
+      ...input.source.tradeType ? { tradeType: input.source.tradeType } : {}
+    },
+    context.relay
+  ) : void 0;
+  const amount = relayQuote?.outputAmount ?? input.amount;
+  if (amount < MIN_CASHOUT_AMOUNT) {
+    throw errors.amountBelowMinimum(amount, MIN_CASHOUT_AMOUNT);
+  }
   const feedConfig = sdk.CHAINLINK_ORACLE_FEEDS[currency];
   const asOf = Math.floor(Date.now() / 1e3);
   let rate;
@@ -647,7 +962,7 @@ async function readEstimate(publicClient, input) {
     rate = feedConfig.invert ? 1 / price : price;
   }
   const stale = oracleUpdatedAt !== void 0 && asOf - oracleUpdatedAt > DEFAULT_MAX_STALENESS_SECONDS;
-  return {
+  const estimate = {
     kind: "oracle-estimate",
     currency,
     amount,
@@ -655,8 +970,27 @@ async function readEstimate(publicClient, input) {
     receiveAmount: Number(amount) / 10 ** USDC_DECIMALS * rate,
     asOf,
     ...oracleUpdatedAt !== void 0 ? { oracleUpdatedAt } : {},
-    ...stale ? { stale: true } : {}
+    ...stale ? { stale: true } : {},
+    ...relayQuote ? {
+      source: {
+        kind: "relay",
+        asset: relayQuote.source,
+        inputAmount: relayQuote.inputAmount,
+        relayQuote
+      }
+    } : {}
   };
+  if (context.indexerClient && context.environment) {
+    try {
+      estimate.eta = await readFillEta(context.indexerClient, {
+        environment: context.environment,
+        currency,
+        ...input.platform ? { platform: input.platform } : {}
+      });
+    } catch {
+    }
+  }
+  return estimate;
 }
 
 // src/client/createCashClient.ts
@@ -752,9 +1086,8 @@ function createCashClient(options) {
     }
     return client;
   }
-  function validateInput(input) {
-    const { amount, receive } = input;
-    if (amount < MIN_CASHOUT_AMOUNT) throw errors.amountBelowMinimum(amount, MIN_CASHOUT_AMOUNT);
+  function validatePayout(input) {
+    const { receive } = input;
     const catalog = sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment);
     if (!catalog[receive.platform]) throw errors.unsupportedPlatform(receive.platform);
     if (!isMarketRateSupported(receive.currency)) {
@@ -764,7 +1097,6 @@ function createCashClient(options) {
       throw errors.payeeVerificationRequired(receive.platform);
     }
     return {
-      amount,
       payouts: [
         {
           processorName: receive.platform,
@@ -775,6 +1107,12 @@ function createCashClient(options) {
       ...input.intentAmountRange ? { intentAmountRange: input.intentAmountRange } : {}
     };
   }
+  function validateInput(input) {
+    if (input.amount < MIN_CASHOUT_AMOUNT) {
+      throw errors.amountBelowMinimum(input.amount, MIN_CASHOUT_AMOUNT);
+    }
+    return { amount: input.amount, ...validatePayout(input) };
+  }
   async function buildDepositParams(client, depositInput) {
     try {
       return await prepareCashDepositParams(client, depositInput);
@@ -851,6 +1189,14 @@ function createCashClient(options) {
     if (!order.isInFlight) throw errors.orderNotActive(depositId);
     return escrowContext(depositId);
   }
+  function capabilities(capabilityOptions) {
+    const baseCapabilities = buildCapabilities(environment);
+    if (!capabilityOptions?.includeRelaySources) return baseCapabilities;
+    return readRelaySourceCapabilities(options.relay).then((relay) => ({
+      ...baseCapabilities,
+      source: { ...baseCapabilities.source, relay }
+    }));
+  }
   async function settleAllowance(client, token, owner, escrow, amount) {
     let allowance;
     try {
@@ -879,18 +1225,109 @@ function createCashClient(options) {
     throw errors.allowanceNotVisible(amount);
   }
   return {
-    capabilities() {
-      return buildCapabilities(environment);
+    capabilities,
+    async sourceCapabilities() {
+      return readRelaySourceCapabilities(options.relay);
+    },
+    async quoteSource(input) {
+      return quoteRelayToBaseUsdc(input, options.relay);
+    },
+    async executeSourceQuote(quote, opts) {
+      return executeRelayQuote(quote, opts.signer, {
+        ...options.relay ? { relay: options.relay } : {},
+        ...opts.onProgress ? { onProgress: opts.onProgress } : {},
+        ...opts.disableCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: opts.disableCapabilitiesCheck } : {}
+      });
+    },
+    async relayStatus(requestId) {
+      return readRelayStatus(requestId, options.relay);
     },
     async estimate(input) {
-      return readEstimate(readClient.publicClient, input);
+      return readEstimate(readClient.publicClient, input, {
+        indexerClient: readClient,
+        environment,
+        ...options.relay ? { relay: options.relay } : {}
+      });
     },
     async cashout(input, opts) {
-      const depositInput = validateInput(input);
       const client = signingClient("cashout", opts);
+      const owner = opts.signer.account.address;
+      const payoutInput = validatePayout(input);
+      let sourceResult;
+      let cashoutAmount = input.amount;
+      if (input.source) {
+        const sourceSigner = opts.sourceSigner ?? (input.source.chainId === BASE_CHAIN_ID ? opts.signer : void 0);
+        if (!sourceSigner?.account) throw errors.signerRequired("source cashout");
+        if (input.source.recipient !== void 0 && input.source.recipient.toLowerCase() !== owner.toLowerCase()) {
+          throw errors.sourceRecipientMismatch(input.source.recipient, owner);
+        }
+        const relayQuote = await quoteRelayToBaseUsdc(
+          {
+            user: sourceSigner.account.address,
+            amount: input.amount,
+            source: { chainId: input.source.chainId, currency: input.source.currency },
+            recipient: owner,
+            ...input.source.tradeType ? { tradeType: input.source.tradeType } : {}
+          },
+          options.relay
+        );
+        if (relayQuote.outputAmount < MIN_CASHOUT_AMOUNT) {
+          throw errors.amountBelowMinimum(relayQuote.outputAmount, MIN_CASHOUT_AMOUNT);
+        }
+        cashoutAmount = relayQuote.outputAmount;
+        const depositInput2 = { amount: cashoutAmount, ...payoutInput };
+        const params2 = await buildDepositParams(client, depositInput2);
+        const escrow2 = client.escrowV2Address ?? client.escrowAddress;
+        await settleAllowance(client, params2.token, owner, escrow2, depositInput2.amount);
+        const executed = await executeRelayQuote(relayQuote.raw, sourceSigner, {
+          ...options.relay ? { relay: options.relay } : {},
+          ...opts.onSourceProgress ? { onProgress: opts.onSourceProgress } : {},
+          ...opts.disableSourceCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: opts.disableSourceCapabilitiesCheck } : {}
+        });
+        sourceResult = {
+          amount: cashoutAmount,
+          ...executed.requestId ? { requestId: executed.requestId } : {},
+          txHashes: executed.txHashes
+        };
+        const attributedParams2 = { ...params2, txOverrides: attribution };
+        const send2 = async () => {
+          try {
+            return (await client.createDeposit(attributedParams2)).hash;
+          } catch (err) {
+            if (err instanceof Error && /exceeds allowance/i.test(err.message)) {
+              await sleep(2e3);
+              return (await client.createDeposit(attributedParams2)).hash;
+            }
+            throw err;
+          }
+        };
+        let hash2;
+        try {
+          hash2 = await send2();
+        } catch (err) {
+          throw mapChainError("createDeposit", err);
+        }
+        const receipt2 = await client.publicClient.waitForTransactionReceipt({ hash: hash2 });
+        if (receipt2.status === "reverted") throw errors.transactionFailed(hash2);
+        const abi2 = client.escrowV2Abi ?? client.escrowAbi;
+        const resolved2 = resolveCashDepositId({ logs: receipt2.logs, abi: abi2 });
+        if (!resolved2) throw errors.depositResolutionFailed(hash2);
+        const order2 = deriveCashOrder(resolved2.compositeId, [], {
+          remainingAmount: depositInput2.amount,
+          status: "ACTIVE"
+        });
+        return {
+          depositId: resolved2.compositeId,
+          txHash: hash2,
+          escrowAddress: resolved2.escrowAddress,
+          onchainDepositId: resolved2.onchainDepositId,
+          order: order2,
+          source: sourceResult
+        };
+      }
+      const depositInput = validateInput(input);
       const params = await buildDepositParams(client, depositInput);
       const escrow = client.escrowV2Address ?? client.escrowAddress;
-      const owner = opts.signer.account.address;
       await settleAllowance(client, params.token, owner, escrow, depositInput.amount);
       const attributedParams = { ...params, txOverrides: attribution };
       const send = async () => {
@@ -924,10 +1361,12 @@ function createCashClient(options) {
         txHash: hash,
         escrowAddress: resolved.escrowAddress,
         onchainDepositId: resolved.onchainDepositId,
-        order
+        order,
+        ...sourceResult ? { source: sourceResult } : {}
       };
     },
     async prepare(input) {
+      if (input.source) throw errors.sourceRouteUnsupportedInPrepare();
       const depositInput = validateInput(input);
       const params = await buildDepositParams(readClient, depositInput);
       const { prepared } = await readClient.prepareCreateDeposit({
@@ -1241,7 +1680,56 @@ var cashEstimateJsonSchema = zod.z.object({
   receiveAmount: zod.z.number(),
   asOf: zod.z.number(),
   oracleUpdatedAt: zod.z.number().optional(),
-  stale: zod.z.boolean().optional()
+  stale: zod.z.boolean().optional(),
+  source: zod.z.object({
+    kind: zod.z.literal("relay"),
+    asset: zod.z.object({
+      chainId: zod.z.number(),
+      address: zod.z.string(),
+      symbol: zod.z.string(),
+      decimals: zod.z.number(),
+      name: zod.z.string().optional(),
+      isNative: zod.z.boolean().optional()
+    }),
+    inputAmount: bigintString,
+    relayQuote: zod.z.object({
+      requestId: zod.z.string().optional(),
+      source: zod.z.object({
+        chainId: zod.z.number(),
+        address: zod.z.string(),
+        symbol: zod.z.string(),
+        decimals: zod.z.number(),
+        name: zod.z.string().optional(),
+        isNative: zod.z.boolean().optional()
+      }),
+      destination: zod.z.object({
+        chainId: zod.z.number(),
+        address: zod.z.string(),
+        symbol: zod.z.string(),
+        decimals: zod.z.number(),
+        name: zod.z.string().optional(),
+        isNative: zod.z.boolean().optional()
+      }),
+      inputAmount: bigintString,
+      outputAmount: bigintString,
+      rate: zod.z.number().optional(),
+      timeEstimateSeconds: zod.z.number().optional(),
+      fees: zod.z.unknown().optional(),
+      txs: zod.z.array(
+        zod.z.object({
+          to: zod.z.string(),
+          data: zod.z.string(),
+          value: bigintString,
+          chainId: zod.z.number()
+        })
+      ),
+      raw: zod.z.unknown()
+    })
+  }).optional(),
+  eta: zod.z.object({
+    seconds: zod.z.number().optional(),
+    label: zod.z.string()
+  }).optional()
 });
 var preparedTransactionJsonSchema = zod.z.object({
   to: zod.z.string(),
@@ -1265,7 +1753,12 @@ var cashoutResultJsonSchema = zod.z.object({
   txHash: zod.z.string(),
   escrowAddress: zod.z.string(),
   onchainDepositId: bigintString,
-  order: cashOrderJsonSchema
+  order: cashOrderJsonSchema,
+  source: zod.z.object({
+    amount: bigintString,
+    requestId: zod.z.string().optional(),
+    txHashes: zod.z.array(zod.z.string())
+  }).optional()
 });
 var prepareResultJsonSchema = zod.z.object({
   txs: zod.z.array(preparedTransactionJsonSchema),
@@ -1285,6 +1778,49 @@ var cashCapabilitiesJsonSchema = zod.z.object({
   chainId: zod.z.number(),
   token: zod.z.object({ address: zod.z.string(), symbol: zod.z.literal("USDC"), decimals: zod.z.number() }),
   environment: zod.z.enum(["production", "preproduction", "staging"]),
+  destination: zod.z.object({
+    chainId: zod.z.number(),
+    token: zod.z.object({ address: zod.z.string(), symbol: zod.z.literal("USDC"), decimals: zod.z.number() })
+  }),
+  source: zod.z.object({
+    default: zod.z.object({
+      chainId: zod.z.number(),
+      token: zod.z.object({ address: zod.z.string(), symbol: zod.z.literal("USDC"), decimals: zod.z.number() })
+    }),
+    relay: zod.z.object({
+      destination: zod.z.object({
+        chainId: zod.z.number(),
+        address: zod.z.string(),
+        symbol: zod.z.string(),
+        decimals: zod.z.number(),
+        name: zod.z.string().optional(),
+        isNative: zod.z.boolean().optional()
+      }),
+      chains: zod.z.array(
+        zod.z.object({
+          id: zod.z.number(),
+          name: zod.z.string(),
+          displayName: zod.z.string(),
+          disabled: zod.z.boolean(),
+          depositEnabled: zod.z.boolean(),
+          blockProductionLagging: zod.z.boolean(),
+          vmType: zod.z.string().optional(),
+          tokens: zod.z.array(
+            zod.z.object({
+              chainId: zod.z.number(),
+              address: zod.z.string(),
+              symbol: zod.z.string(),
+              decimals: zod.z.number(),
+              name: zod.z.string().optional(),
+              isNative: zod.z.boolean().optional()
+            })
+          )
+        })
+      ),
+      source: zod.z.literal("relay-sdk"),
+      asOf: zod.z.number()
+    }).optional()
+  }),
   platforms: zod.z.array(
     zod.z.object({
       platform: zod.z.string(),
@@ -1376,14 +1912,38 @@ function orderFromJson(json) {
   return withExplain(data);
 }
 function estimateToJson(estimate) {
-  return { ...estimate, amount: estimate.amount.toString() };
+  return omitUndefined({
+    ...estimate,
+    amount: estimate.amount.toString(),
+    source: estimate.source ? {
+      ...estimate.source,
+      inputAmount: estimate.source.inputAmount.toString(),
+      relayQuote: {
+        ...estimate.source.relayQuote,
+        inputAmount: estimate.source.relayQuote.inputAmount.toString(),
+        outputAmount: estimate.source.relayQuote.outputAmount.toString(),
+        txs: estimate.source.relayQuote.txs.map(preparedTxToJson),
+        raw: sanitizeRelayQuoteRaw(estimate.source.relayQuote.raw)
+      }
+    } : void 0
+  });
 }
 function estimateFromJson(json) {
   const parsed = cashEstimateJsonSchema.parse(json);
   return omitUndefined({
     ...parsed,
     currency: parsed.currency,
-    amount: BigInt(parsed.amount)
+    amount: BigInt(parsed.amount),
+    source: parsed.source ? {
+      ...parsed.source,
+      inputAmount: BigInt(parsed.source.inputAmount),
+      relayQuote: {
+        ...parsed.source.relayQuote,
+        inputAmount: BigInt(parsed.source.relayQuote.inputAmount),
+        outputAmount: BigInt(parsed.source.relayQuote.outputAmount),
+        txs: parsed.source.relayQuote.txs.map(preparedTxFromJson)
+      }
+    } : void 0
   });
 }
 function preparedTxToJson(tx) {
@@ -1405,23 +1965,31 @@ function preparedStepFromJson(json) {
   return cashPreparedStepJsonSchema.parse(json);
 }
 function cashoutResultToJson(result) {
-  return {
+  return omitUndefined({
     depositId: result.depositId,
     txHash: result.txHash,
     escrowAddress: result.escrowAddress,
     onchainDepositId: result.onchainDepositId.toString(),
-    order: orderToJson(result.order)
-  };
+    order: orderToJson(result.order),
+    source: result.source ? {
+      ...result.source,
+      amount: result.source.amount.toString()
+    } : void 0
+  });
 }
 function cashoutResultFromJson(json) {
   const parsed = cashoutResultJsonSchema.parse(json);
-  return {
+  return omitUndefined({
     depositId: parsed.depositId,
     txHash: parsed.txHash,
     escrowAddress: parsed.escrowAddress,
     onchainDepositId: BigInt(parsed.onchainDepositId),
-    order: orderFromJson(parsed.order)
-  };
+    order: orderFromJson(parsed.order),
+    source: parsed.source ? {
+      ...parsed.source,
+      amount: BigInt(parsed.source.amount)
+    } : void 0
+  });
 }
 function prepareResultToJson(result) {
   return {
@@ -1480,6 +2048,10 @@ function capabilitiesFromJson(json) {
   const parsed = cashCapabilitiesJsonSchema.parse(json);
   return {
     ...parsed,
+    source: {
+      default: parsed.source.default,
+      ...parsed.source.relay ? { relay: parsed.source.relay } : {}
+    },
     platforms: parsed.platforms.map((p) => ({
       ...p,
       currencies: p.currencies