@zkp2p/cash 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -237,10 +237,12 @@ function deriveCashOrder(depositId, intents, options = {}) {
   const total = options.totalAmount ?? remaining + outstanding + taken + withdrawn;
   const status = options.status;
   const isTerminal = status === "CLOSED" || status === "WITHDRAWN";
-  const hasLiveFunds = remaining > DUST_THRESHOLD || outstanding > 0n;
+  const hasLiveFunds = remaining >= DUST_THRESHOLD || outstanding > 0n;
   let state;
   if (outstanding > 0n) {
     state = taken > 0n ? "delivering" : "matched";
+  } else if (!hasLiveFunds && withdrawn > 0n) {
+    state = "returned";
   } else if (taken > 0n && !hasLiveFunds) {
     state = "delivered";
   } else if (taken > 0n && hasLiveFunds) {
@@ -282,7 +284,7 @@ function deriveCashOrder(depositId, intents, options = {}) {
     ...options.payouts !== void 0 ? { payouts: options.payouts } : {},
     ...options.successRateBps !== void 0 ? { successRateBps: options.successRateBps } : {},
     isInFlight,
-    withdrawn: isTerminal
+    withdrawn: state === "returned" && withdrawn > 0n
   });
 }
 var ORACLE_KINDS = /* @__PURE__ */ new Set(["oracle_chainlink", "oracle_pyth"]);
@@ -392,12 +394,14 @@ function resolveCashDepositId(params) {
 }
 function parseCompositeDepositId(compositeId) {
   const idx = compositeId.lastIndexOf("_");
-  if (idx === -1) {
-    return { escrowAddress: "", onchainDepositId: BigInt(compositeId) };
-  }
   const escrowAddress = compositeId.slice(0, idx);
-  const onchainDepositId = BigInt(compositeId.slice(idx + 1) || "0");
-  return { escrowAddress, onchainDepositId };
+  const rawDepositId = compositeId.slice(idx + 1);
+  if (idx <= 0 || compositeId.indexOf("_") !== idx || !viem.isAddress(escrowAddress, { strict: false }) || !/^\d+$/.test(rawDepositId)) {
+    throw new Error(`Invalid deposit id: '${compositeId}'`);
+  }
+  const canonicalEscrowAddress = escrowAddress.toLowerCase();
+  const onchainDepositId = BigInt(rawDepositId);
+  return { escrowAddress: canonicalEscrowAddress, onchainDepositId };
 }
 var MIN_CASHOUT_AMOUNT = 10000n;
 var RECOMMENDED_MIN_CASHOUT_AMOUNT = 1000000n;
@@ -415,9 +419,6 @@ var PAYEE_HINTS = {
   n26: "MoneyBeam email or phone number"
 };
 var IDENTITY_ATTESTATION_PLATFORMS = /* @__PURE__ */ new Set(["wise", "paypal"]);
-function platformRequiresIdentityAttestation(platform) {
-  return IDENTITY_ATTESTATION_PLATFORMS.has(platform);
-}
 function buildCapabilities(environment) {
   const catalog = sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment);
   const platforms = Object.entries(catalog).map(([platform, entry]) => {
@@ -451,12 +452,14 @@ var CashError = class extends Error {
   code;
   retryable;
   remediation;
+  recovery;
   constructor(shape, options) {
     super(shape.message, options);
     this.name = "CashError";
     this.code = shape.code;
     this.retryable = shape.retryable;
     this.remediation = shape.remediation;
+    if (shape.recovery) this.recovery = shape.recovery;
   }
   /** Serializable view (for tool results and logs). */
   toJSON() {
@@ -464,7 +467,8 @@ var CashError = class extends Error {
       code: this.code,
       message: this.message,
       retryable: this.retryable,
-      remediation: this.remediation
+      remediation: this.remediation,
+      ...this.recovery ? { recovery: this.recovery } : {}
     };
   }
 };
@@ -478,18 +482,39 @@ var errors = {
     retryable: false,
     remediation: `Pick a currency listed in capabilities() - each one is priced by a live oracle feed.`
   }),
+  oracleReadFailed: (currency, cause) => new CashError(
+    {
+      code: "ORACLE_READ_FAILED",
+      message: `The ${currency} market-rate oracle could not be read.`,
+      retryable: true,
+      remediation: `Retry the estimate shortly or use another healthy Base RPC. Do not present a cached value as a live market rate.`
+    },
+    { cause }
+  ),
   unsupportedPlatform: (platform) => new CashError({
     code: "UNSUPPORTED_PLATFORM",
     message: `'${platform}' is not a supported payout platform in this environment.`,
     retryable: false,
     remediation: `Pick a platform listed in capabilities().`
   }),
+  unsupportedPlatformCurrency: (platform, currency) => new CashError({
+    code: "UNSUPPORTED_PLATFORM_CURRENCY",
+    message: `${platform} cannot receive ${currency} in this environment.`,
+    retryable: false,
+    remediation: `Pick one of the currencies listed for ${platform} in capabilities().`
+  }),
   amountBelowMinimum: (amount, min) => new CashError({
     code: "AMOUNT_BELOW_MINIMUM",
     message: `Amount ${amount} is below the minimum cash-out of ${min} USDC base units.`,
     retryable: false,
     remediation: `Increase the amount to at least ${min} base units (${Number(min) / 1e6} USDC).`
   }),
+  invalidIntentAmountRange: (amount, min, max) => new CashError({
+    code: "INVALID_INTENT_AMOUNT_RANGE",
+    message: `Intent amount range ${min}-${max} is invalid for a ${amount} base-unit cash-out.`,
+    retryable: false,
+    remediation: `Use a positive minimum no greater than the maximum, and a maximum no greater than the cash-out amount.`
+  }),
   activeIntentBlocksWithdrawal: (depositId) => new CashError({
     code: "ACTIVE_INTENT_BLOCKS_WITHDRAWAL",
     message: `Order ${depositId} has a live buyer intent; escrow blocks withdrawal while a buyer may still deliver.`,
@@ -502,12 +527,27 @@ var errors = {
     retryable: true,
     remediation: `Withdraw at most the available (unlocked) amount, or omit the amount to close the order fully once no buyer intent is live.`
   }),
+  insufficientTokenBalance: (requiredAmount) => new CashError({
+    code: "INSUFFICIENT_TOKEN_BALANCE",
+    message: requiredAmount === void 0 ? `The wallet does not hold enough of the source token for this transaction.` : `The wallet does not hold the ${requiredAmount} base units required for this transaction.`,
+    retryable: false,
+    remediation: requiredAmount === void 0 ? `Fund the wallet with the required token amount, then retry.` : `Fund the wallet to at least ${requiredAmount} token base units, then retry.`
+  }),
   orderNotActive: (depositId) => new CashError({
     code: "ORDER_NOT_ACTIVE",
     message: `Order ${depositId} is closed (delivered or returned); it cannot be topped up.`,
     retryable: false,
     remediation: `Start a new cash-out with cashout() instead.`
   }),
+  invalidDepositId: (depositId, cause) => new CashError(
+    {
+      code: "INVALID_DEPOSIT_ID",
+      message: `'${depositId}' is not a valid Peer Cash deposit id.`,
+      retryable: false,
+      remediation: `Use the depositId returned by cashout() (escrowAddress_onchainDepositId) without modifying it.`
+    },
+    { cause }
+  ),
   nothingToWithdraw: (depositId) => new CashError({
     code: "NOTHING_TO_WITHDRAW",
     message: `Order ${depositId} holds no withdrawable funds (already delivered or returned).`,
@@ -526,6 +566,15 @@ var errors = {
     retryable: true,
     remediation: `Verify the composite depositId (escrow_onchainId). If the deposit was created seconds ago this is indexer lag - retry shortly.`
   }),
+  indexerUnavailable: (operation, cause) => new CashError(
+    {
+      code: "INDEXER_UNAVAILABLE",
+      message: `The protocol indexer could not complete the ${operation} query.`,
+      retryable: true,
+      remediation: `Retry shortly. Keep the composite depositId or owner address so the read can resume without repeating an on-chain transaction.`
+    },
+    { cause }
+  ),
   payeeRegistrationFailed: (cause) => new CashError(
     {
       code: "PAYEE_REGISTRATION_FAILED",
@@ -556,12 +605,109 @@ var errors = {
     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.`,
-    retryable: true,
-    remediation: `The approve transaction mined but a load-balanced RPC is serving stale state. Retry the same call in a few seconds.`
-  }),
+  sourceCapabilitiesFailed: (cause) => new CashError(
+    {
+      code: "SOURCE_CAPABILITIES_FAILED",
+      message: `Relay source-chain discovery failed.`,
+      retryable: true,
+      remediation: `Retry sourceCapabilities() shortly, or use the default Base USDC path.`
+    },
+    { cause }
+  ),
+  sourceQuoteFailed: (cause) => new CashError(
+    {
+      code: "SOURCE_QUOTE_FAILED",
+      message: `Relay did not return a valid route to canonical Base USDC.`,
+      retryable: true,
+      remediation: `Refresh source capabilities and request a new quote. Do not submit transactions from this response.`
+    },
+    { cause }
+  ),
+  sourceExecutionFailed: (cause, evidence) => new CashError(
+    {
+      code: "SOURCE_EXECUTION_FAILED",
+      message: `Relay source-route execution did not complete successfully.`,
+      retryable: false,
+      remediation: `Inspect the wallet transactions and Relay request status before retrying so the source transfer is never submitted twice.`,
+      ...evidence && (evidence.requestId !== void 0 || evidence.txHashes.length > 0) ? {
+        recovery: {
+          kind: "inspect-relay-route",
+          ...evidence.requestId ? { requestId: evidence.requestId } : {},
+          txHashes: evidence.txHashes,
+          ...evidence.transactions ? { transactions: evidence.transactions } : {}
+        }
+      } : {}
+    },
+    { cause }
+  ),
+  sourceStatusFailed: (requestId, cause) => new CashError(
+    {
+      code: "SOURCE_STATUS_FAILED",
+      message: `Relay status is unavailable for request ${requestId}.`,
+      retryable: true,
+      remediation: `Retry relayStatus(requestId) shortly; keep the request id and transaction hashes for recovery.`
+    },
+    { cause }
+  ),
+  sourceRouteCompletedCashoutFailed: (source, cause) => new CashError(
+    {
+      code: "SOURCE_ROUTE_COMPLETED_CASHOUT_FAILED",
+      message: `Relay completed, but the Base USDC cash-out transaction was not created.`,
+      retryable: false,
+      remediation: `Do not repeat the Relay route. Retry cashout() without source using the recovery amount already delivered on Base.`,
+      recovery: {
+        kind: "retry-base-usdc-cashout",
+        amount: source.amount.toString(),
+        ...source.requestId ? { requestId: source.requestId } : {},
+        txHashes: source.txHashes,
+        ...source.transactions ? { transactions: source.transactions } : {}
+      }
+    },
+    { cause }
+  ),
+  sourceCashoutSubmissionUnknown: (source, depositor, cause) => new CashError(
+    {
+      code: "SOURCE_CASHOUT_SUBMISSION_UNKNOWN",
+      message: `Relay completed, but the Base cash-out submission did not return a transaction hash.`,
+      retryable: false,
+      remediation: `Do not repeat Relay or submit another cash-out yet. Inspect recent Base transactions and orders(${depositor}) to prove no deposit was broadcast; only then retry Base-USDC-only with the recovery amount.`,
+      recovery: {
+        kind: "inspect-base-cashout-submission",
+        amount: source.amount.toString(),
+        ...source.requestId ? { requestId: source.requestId } : {},
+        txHashes: source.txHashes,
+        ...source.transactions ? { transactions: source.transactions } : {},
+        depositor
+      }
+    },
+    { cause }
+  ),
+  sourceCashoutStatusUnknown: (source, depositTxHash, cause) => new CashError(
+    {
+      code: "SOURCE_CASHOUT_STATUS_UNKNOWN",
+      message: `Relay completed and Base cash-out transaction ${depositTxHash} was submitted, but its receipt could not be confirmed.`,
+      retryable: false,
+      remediation: `Do not repeat the Relay route or submit another cash-out. Inspect the Base transaction; if it succeeded, recover the depositId from its DepositReceived log, and if it reverted, retry a Base-USDC-only cashout with the recovery amount.`,
+      recovery: {
+        kind: "inspect-base-cashout-transaction",
+        amount: source.amount.toString(),
+        ...source.requestId ? { requestId: source.requestId } : {},
+        txHashes: source.txHashes,
+        ...source.transactions ? { transactions: source.transactions } : {},
+        depositTxHash
+      }
+    },
+    { cause }
+  ),
+  allowanceNotVisible: (amount, cause) => new CashError(
+    {
+      code: "ALLOWANCE_NOT_VISIBLE",
+      message: `USDC approval for ${amount} base units did not become visible on the read path in time.`,
+      retryable: true,
+      remediation: `The approve transaction mined but the RPC read path is stale or unavailable. Retry the same call in a few seconds.`
+    },
+    { cause }
+  ),
   depositResolutionFailed: (txHash) => new CashError({
     code: "DEPOSIT_RESOLUTION_FAILED",
     message: `Deposit transaction ${txHash} succeeded but no DepositReceived event was found in the receipt.`,
@@ -574,6 +720,21 @@ var errors = {
     retryable: false,
     remediation: `Pass { signer } (a viem WalletClient with an account), or use prepare() and submit the returned txs with your own signing infrastructure.`
   }),
+  signerChainMismatch: (verb, expectedChainId, actualChainId) => new CashError({
+    code: "SIGNER_CHAIN_MISMATCH",
+    message: `${verb} requires chain ${expectedChainId}, but the signer is connected to chain ${actualChainId}.`,
+    retryable: false,
+    remediation: `Switch the wallet to chain ${expectedChainId}, obtain a fresh quote if Relay is involved, and retry before submitting any transaction.`
+  }),
+  signerChainUnavailable: (verb, expectedChainId, cause) => new CashError(
+    {
+      code: "SIGNER_CHAIN_UNAVAILABLE",
+      message: `${verb} could not verify that the signer is connected to chain ${expectedChainId}.`,
+      retryable: true,
+      remediation: `Reconnect the wallet, switch it to chain ${expectedChainId}, and retry before submitting any transaction.`
+    },
+    { cause }
+  ),
   watchTimeout: (depositId, timeoutMs) => new CashError({
     code: "WATCH_TIMEOUT",
     message: `watch(${depositId}) exceeded ${timeoutMs}ms without reaching a terminal state.`,
@@ -589,6 +750,30 @@ var errors = {
     },
     { cause }
   ),
+  transactionSubmissionUnknown: (operation, cause, recovery) => new CashError(
+    {
+      code: "TRANSACTION_SUBMISSION_UNKNOWN",
+      message: `The Base ${operation} submission did not return a transaction hash.`,
+      retryable: false,
+      remediation: `Do not submit the operation again until you inspect recent Base wallet activity and protocol state; the first transaction may already exist.`,
+      ...recovery ? { recovery } : {}
+    },
+    { cause }
+  ),
+  transactionStatusUnknown: (txHash, cause, operation = "transaction") => new CashError(
+    {
+      code: "TRANSACTION_STATUS_UNKNOWN",
+      message: `Transaction ${txHash} was submitted, but its receipt could not be confirmed.`,
+      retryable: false,
+      remediation: `Do not resubmit the operation until you inspect ${txHash} on Base or successfully fetch its receipt; the transaction may already have succeeded.`,
+      recovery: {
+        kind: "inspect-base-transaction",
+        transactionHash: txHash,
+        operation
+      }
+    },
+    { cause }
+  ),
   escrowPaused: () => new CashError({
     code: "ESCROW_PAUSED",
     message: `The escrow contract is paused; deposits are temporarily disabled.`,
@@ -606,12 +791,15 @@ var errors = {
     { cause }
   )
 };
-function mapChainError(verb, err) {
+function mapChainError(verb, err, context = {}) {
   if (isCashError(err)) return err;
   const message = err instanceof Error ? err.message : String(err);
   if (/\bpaused\b/i.test(message)) return errors.escrowPaused();
-  if (/exceeds allowance|insufficient allowance|transfer amount exceeds/i.test(message)) {
-    return errors.allowanceNotVisible(0n);
+  if (/exceeds balance|insufficient token balance/i.test(message)) {
+    return errors.insufficientTokenBalance(context.requiredAmount);
+  }
+  if (/exceeds allowance|insufficient allowance/i.test(message)) {
+    return errors.allowanceNotVisible(context.requiredAmount ?? 0n);
   }
   return errors.chainCallFailed(verb, err);
 }
@@ -777,20 +965,183 @@ function normalizeChain(chain) {
 function isSupportedEvmChain(chain) {
   return chain.vmType === void 0 || chain.vmType === "evm";
 }
+function isExecutableSourceChain(chain) {
+  return isSupportedEvmChain(chain) && !chain.disabled && chain.depositEnabled && !chain.blockProductionLagging;
+}
 function quoteRequestId(quote) {
   return quote.steps.map((step) => step.requestId).find((id) => id !== void 0);
 }
+function collectRelayTransactions(steps, sourceChainId) {
+  const origin = [];
+  const destination = [];
+  const record = (tx) => {
+    (tx.chainId === sourceChainId ? origin : destination).push(tx);
+  };
+  for (const step of steps) {
+    for (const item of step.items) {
+      for (const tx of item.internalTxHashes ?? []) {
+        record({
+          hash: tx.txHash,
+          chainId: tx.chainId,
+          ...tx.isBatchTx ? { isBatchTx: true } : {}
+        });
+      }
+      for (const tx of item.txHashes ?? []) {
+        record({
+          hash: tx.txHash,
+          chainId: tx.chainId,
+          ...tx.isBatchTx ? { isBatchTx: true } : {}
+        });
+      }
+    }
+  }
+  const dedupe = (txs) => [
+    ...new Map(txs.map((tx) => [`${tx.chainId}:${tx.hash.toLowerCase()}`, tx])).values()
+  ];
+  return { origin: dedupe(origin), destination: dedupe(destination) };
+}
+function relayTransactionHashes(transactions) {
+  return [
+    ...new Set([...transactions.origin, ...transactions.destination].map(({ hash }) => hash))
+  ];
+}
 function quoteSourceChainId(quote) {
   const details = asRecord(quote.details);
   const currencyIn = asRecord(details.currencyIn);
   const sourceCurrency = asRecord(currencyIn.currency);
   return asNumber(sourceCurrency.chainId);
 }
+function assertCanonicalRelayDestination(quote) {
+  const details = asRecord(quote.details);
+  const currencyOut = asRecord(details.currencyOut);
+  const destination = asRecord(currencyOut.currency);
+  if (asNumber(destination.chainId) !== BASE_CHAIN_ID || asString(destination.address)?.toLowerCase() !== BASE_USDC_ADDRESS.toLowerCase()) {
+    throw new Error("Relay quote destination is not canonical Base USDC");
+  }
+}
+async function assertWalletChainId(wallet, expectedChainId, operation) {
+  let actualChainId;
+  try {
+    actualChainId = await wallet.getChainId();
+  } catch (err) {
+    throw errors.signerChainUnavailable(operation, expectedChainId, err);
+  }
+  if (actualChainId !== expectedChainId) {
+    throw errors.signerChainMismatch(operation, expectedChainId, actualChainId);
+  }
+}
+async function assertRelayExecutionIdentity(quote, wallet, expectedRecipient) {
+  const signer = wallet.account?.address;
+  if (!signer) throw new Error("Relay execution requires a wallet account");
+  const sourceChainId = quoteSourceChainId(quote);
+  if (sourceChainId !== void 0) {
+    await assertWalletChainId(wallet, sourceChainId, "Relay execution");
+  }
+  const details = asRecord(quote.details);
+  const sender = asString(details.sender);
+  const recipient = asString(details.recipient);
+  if (!sender || sender.toLowerCase() !== signer.toLowerCase()) {
+    throw new Error("Relay quote sender does not match the execution signer");
+  }
+  const destinationOwner = expectedRecipient ?? signer;
+  if (!recipient || recipient.toLowerCase() !== destinationOwner.toLowerCase()) {
+    throw new Error("Relay quote recipient does not match the expected Base recipient");
+  }
+}
+function isRelaySecretKey(key) {
+  const normalized = key.toLowerCase();
+  return normalized === "headers" || normalized === "apikey";
+}
+function redactRelayValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date || value instanceof Error) return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const output2 = [];
+    seen.set(value, output2);
+    for (const entry of value) output2.push(redactRelayValue(entry, seen));
+    return output2;
+  }
+  const output = {};
+  seen.set(value, output);
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isRelaySecretKey(key)) output[key] = redactRelayValue(entry, seen);
+  }
+  return output;
+}
+var RELAY_WIRE_TYPE = "__zkp2pCashType";
+function sanitizeRelayValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "bigint") {
+    return { [RELAY_WIRE_TYPE]: "bigint", value: value.toString() };
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : { [RELAY_WIRE_TYPE]: "number", value: String(value) };
+  }
+  if (typeof value === "undefined") return { [RELAY_WIRE_TYPE]: "undefined" };
+  if (value instanceof Date) {
+    return { [RELAY_WIRE_TYPE]: "date", value: value.toISOString() };
+  }
+  if (value instanceof Error) {
+    return {
+      [RELAY_WIRE_TYPE]: "error",
+      name: value.name,
+      message: value.message
+    };
+  }
+  if (typeof value !== "object") return void 0;
+  if (seen.has(value)) throw new TypeError("Relay payload contains a circular reference");
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const output2 = value.map((entry) => sanitizeRelayValue(entry, seen));
+    seen.delete(value);
+    return output2;
+  }
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (isRelaySecretKey(key)) continue;
+    const sanitized = sanitizeRelayValue(entry, seen);
+    if (sanitized !== void 0) output[key] = sanitized;
+  }
+  seen.delete(value);
+  return output;
+}
+function restoreRelayValue(value) {
+  if (Array.isArray(value)) return value.map(restoreRelayValue);
+  if (value === null || typeof value !== "object") return value;
+  const row = value;
+  const wireType = row[RELAY_WIRE_TYPE];
+  const keyCount = Object.keys(row).length;
+  if (keyCount === 2 && wireType === "bigint" && typeof row.value === "string") {
+    return BigInt(row.value);
+  }
+  if (keyCount === 2 && wireType === "date" && typeof row.value === "string") {
+    return new Date(row.value);
+  }
+  if (keyCount === 2 && wireType === "number" && typeof row.value === "string") {
+    return Number(row.value);
+  }
+  if (keyCount === 1 && wireType === "undefined") return void 0;
+  if (keyCount === 3 && wireType === "error" && typeof row.message === "string") {
+    const error = new Error(row.message);
+    if (typeof row.name === "string") error.name = row.name;
+    return error;
+  }
+  return Object.fromEntries(
+    Object.entries(row).map(([key, entry]) => [key, restoreRelayValue(entry)])
+  );
+}
+function redactRelayQuoteRaw(quote) {
+  return redactRelayValue(quote);
+}
 function sanitizeRelayQuoteRaw(quote) {
-  if (!quote.request) return quote;
-  const request = { ...quote.request };
-  delete request.headers;
-  return { ...quote, request };
+  return sanitizeRelayValue(quote);
+}
+function restoreRelayQuoteRaw(value) {
+  return restoreRelayValue(value);
 }
 async function resolveRelayChains(options, client, config = {}) {
   const preferInjectedClientChains = config.preferInjectedClientChains ?? true;
@@ -804,19 +1155,38 @@ function relayQuoteFromExecute(input, quote) {
   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 sourceChainId = asNumber(sourceCurrency.chainId);
+  const sourceAddress = asString(sourceCurrency.address);
+  const sender = asString(details.sender);
+  const recipient = asString(details.recipient);
+  const expectedRecipient = input.recipient ?? input.user;
+  const destinationChainId = asNumber(destinationCurrency.chainId);
+  const destinationAddress = asString(destinationCurrency.address);
+  if (sourceChainId !== input.source.chainId || sourceAddress?.toLowerCase() !== input.source.currency.toLowerCase()) {
+    throw new Error("Relay quote source does not match the requested asset");
+  }
+  if (!sender || sender.toLowerCase() !== input.user.toLowerCase()) {
+    throw new Error("Relay quote sender does not match the requested wallet");
+  }
+  if (!recipient || recipient.toLowerCase() !== expectedRecipient.toLowerCase()) {
+    throw new Error("Relay quote recipient does not match the requested Base recipient");
+  }
+  if (destinationChainId !== BASE_CHAIN_ID || destinationAddress?.toLowerCase() !== BASE_USDC_ADDRESS.toLowerCase()) {
+    throw new Error("Relay quote destination is not canonical Base USDC");
+  }
+  const source = normalizeToken(input.source.chainId, sourceCurrency);
+  if (!source) throw new Error("Relay quote source metadata is malformed");
+  const destination = normalizeToken(destinationChainId, destinationCurrency);
+  if (!destination) throw new Error("Relay quote destination metadata is malformed");
   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 rawOutputAmount = currencyOut.minimumAmount ?? currencyOut.amount;
+  if (rawOutputAmount === void 0 || rawOutputAmount === null) {
+    throw new Error("Relay quote is missing an output amount");
+  }
+  const outputAmount = BigInt(String(rawOutputAmount));
+  if (outputAmount <= 0n) throw new Error("Relay quote output amount must be positive");
   const requestId = quoteRequestId(quote);
   const rate = asNumber(details.rate);
   const timeEstimateSeconds = asNumber(details.timeEstimate);
@@ -824,92 +1194,135 @@ function relayQuoteFromExecute(input, quote) {
     ...requestId ? { requestId } : {},
     source,
     destination,
-    inputAmount: BigInt(String(currencyIn.amount ?? input.amount.toString())),
+    inputAmount: BigInt(String(currencyIn.amount)),
     outputAmount,
     ...rate !== void 0 ? { rate } : {},
     ...timeEstimateSeconds !== void 0 ? { timeEstimateSeconds } : {},
     ...quote.fees !== void 0 ? { fees: quote.fees } : {},
     txs,
-    raw: sanitizeRelayQuoteRaw(quote)
+    raw: redactRelayQuoteRaw(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)
-  };
+  try {
+    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 && isExecutableSourceChain(chain)).sort((a, b) => a.displayName.localeCompare(b.displayName)),
+      source: "relay-sdk",
+      asOf: Math.floor(Date.now() / 1e3)
+    };
+  } catch (err) {
+    if (isCashError(err)) throw err;
+    throw errors.sourceCapabilitiesFailed(err);
+  }
 }
 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);
+  try {
+    if (input.amount <= 0n) throw new Error("Relay quote amount must be positive");
+    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);
+  } catch (err) {
+    if (isCashError(err)) throw err;
+    throw errors.sourceQuoteFailed(err);
+  }
 }
 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
-  };
+  let observedRequestId;
+  let observedTransactions = { origin: [], destination: [] };
+  try {
+    const rawQuote = "raw" in quote ? quote.raw : quote;
+    observedRequestId = quoteRequestId(rawQuote);
+    assertCanonicalRelayDestination(rawQuote);
+    await assertRelayExecutionIdentity(rawQuote, wallet, options.recipient);
+    const client = relayClient(options.relay);
+    const sourceChainId = quoteSourceChainId(rawQuote);
+    if (sourceChainId !== void 0 && !(client.chains ?? []).some((chain) => chain.id === sourceChainId)) {
+      await resolveRelayChains(options.relay ?? {}, client, { preferInjectedClientChains: false });
+    }
+    const onProgress = (data2) => {
+      const progressSteps = Array.isArray(data2.steps) ? data2.steps : [];
+      observedRequestId = progressSteps.map((step) => step.requestId).find((id) => id !== void 0) ?? observedRequestId;
+      observedTransactions = collectRelayTransactions(progressSteps, sourceChainId);
+      if (options.onProgress) {
+        try {
+          options.onProgress(data2);
+        } catch {
+        }
+      }
+    };
+    const { data } = await client.actions.execute({
+      quote: rawQuote,
+      wallet,
+      onProgress,
+      ...options.disableCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: options.disableCapabilitiesCheck } : {}
+    });
+    const requestId = quoteRequestId(data) ?? observedRequestId;
+    const transactions = collectRelayTransactions(data.steps, sourceChainId);
+    return {
+      ...requestId ? { requestId } : {},
+      txHashes: relayTransactionHashes(transactions),
+      transactions,
+      quote: redactRelayQuoteRaw(data)
+    };
+  } catch (err) {
+    if (isCashError(err)) throw err;
+    const txHashes = relayTransactionHashes(observedTransactions);
+    throw errors.sourceExecutionFailed(err, {
+      ...observedRequestId ? { requestId: observedRequestId } : {},
+      txHashes,
+      ...txHashes.length > 0 ? { transactions: observedTransactions } : {}
+    });
+  }
 }
 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
-  };
+  try {
+    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
+    };
+  } catch (err) {
+    if (isCashError(err)) throw err;
+    throw errors.sourceStatusFailed(requestId, err);
+  }
 }
 
 // src/client/estimate.ts
@@ -956,11 +1369,16 @@ async function readEstimate(publicClient, input, context = {}) {
   if (!feedConfig || feedConfig.feed.toLowerCase() === ZERO_ADDRESS) {
     rate = 1;
   } else {
-    const result = await publicClient.readContract({
-      address: feedConfig.feed,
-      abi: CHAINLINK_LATEST_ROUND_ABI,
-      functionName: "latestRoundData"
-    });
+    let result;
+    try {
+      result = await publicClient.readContract({
+        address: feedConfig.feed,
+        abi: CHAINLINK_LATEST_ROUND_ABI,
+        functionName: "latestRoundData"
+      });
+    } catch (err) {
+      throw errors.oracleReadFailed(currency, err);
+    }
     const answer = Number(result[1]);
     const price = answer / 10 ** feedConfig.decimals;
     if (!Number.isFinite(price) || price <= 0) {
@@ -1006,6 +1424,7 @@ async function readEstimate(publicClient, input, context = {}) {
 var DEFAULT_RPC_URL = "https://mainnet.base.org";
 var CASH_ATTRIBUTION_CODE = "peer-cash";
 var DEFAULT_CURATOR_URLS = {
+  preproduction: "https://api-preprod.zkp2p.xyz",
   staging: "https://api-staging.zkp2p.xyz"
 };
 var ERC20_APPROVE_ABI = viem.parseAbi([
@@ -1040,12 +1459,29 @@ async function submitAndConfirm(client, verb, send) {
   try {
     hash = await send();
   } catch (err) {
-    throw mapChainError(verb, err);
+    const mapped = mapChainError(verb, err);
+    if (isKnownPreBroadcastFailure(err, mapped)) throw mapped;
+    throw errors.transactionSubmissionUnknown(verb, err, {
+      kind: "inspect-base-operation-submission",
+      operation: verb
+    });
+  }
+  let receipt;
+  try {
+    receipt = await client.publicClient.waitForTransactionReceipt({ hash });
+  } catch (err) {
+    throw errors.transactionStatusUnknown(hash, err, verb);
   }
-  const receipt = await client.publicClient.waitForTransactionReceipt({ hash });
   if (receipt.status === "reverted") throw errors.transactionFailed(hash);
   return hash;
 }
+function isKnownPreBroadcastFailure(err, mapped) {
+  if (mapped.code === "INSUFFICIENT_TOKEN_BALANCE" || mapped.code === "ALLOWANCE_NOT_VISIBLE" || mapped.code === "ESCROW_PAUSED") {
+    return true;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return /user rejected|user denied|rejected request|action_rejected/i.test(message);
+}
 function depositOrderOptions(deposit) {
   const remaining = toBigIntOrUndefined(deposit.remainingDeposits);
   const outstanding = toBigIntOrUndefined(deposit.outstandingIntentAmount);
@@ -1085,9 +1521,10 @@ function createCashClient(options) {
   }
   const readClient = buildSdkClient(viem.createWalletClient({ chain: chains.base, transport }));
   const signingClients = /* @__PURE__ */ new WeakMap();
-  function signingClient(verb, opts) {
+  async function signingClient(verb, opts) {
     const signer = opts?.signer;
     if (!signer?.account) throw errors.signerRequired(verb);
+    await assertWalletChainId(signer, BASE_CHAIN_ID, verb);
     let client = signingClients.get(signer);
     if (!client) {
       client = buildSdkClient(signer);
@@ -1097,13 +1534,15 @@ function createCashClient(options) {
   }
   function validatePayout(input) {
     const { receive } = input;
-    const catalog = sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment);
-    if (!catalog[receive.platform]) throw errors.unsupportedPlatform(receive.platform);
+    const platform = buildCapabilities(environment).platforms.find(
+      (capability) => capability.platform === receive.platform
+    );
+    if (!platform) throw errors.unsupportedPlatform(receive.platform);
     if (!isMarketRateSupported(receive.currency)) {
       throw errors.oracleUnsupportedCurrency(receive.currency);
     }
-    if (platformRequiresIdentityAttestation(receive.platform) && !receive.payee.identityAttestation) {
-      throw errors.payeeVerificationRequired(receive.platform);
+    if (!platform.currencies.includes(receive.currency)) {
+      throw errors.unsupportedPlatformCurrency(receive.platform, receive.currency);
     }
     return {
       payouts: [
@@ -1112,15 +1551,22 @@ function createCashClient(options) {
           currency: receive.currency,
           payeeData: receive.payee
         }
-      ],
-      ...input.intentAmountRange ? { intentAmountRange: input.intentAmountRange } : {}
+      ]
     };
   }
-  function validateInput(input) {
-    if (input.amount < MIN_CASHOUT_AMOUNT) {
-      throw errors.amountBelowMinimum(input.amount, MIN_CASHOUT_AMOUNT);
+  function validateDepositInput(amount, input, payoutInput = validatePayout(input)) {
+    if (amount < MIN_CASHOUT_AMOUNT) {
+      throw errors.amountBelowMinimum(amount, MIN_CASHOUT_AMOUNT);
     }
-    return { amount: input.amount, ...validatePayout(input) };
+    const range = input.intentAmountRange;
+    if (range && (range.min <= 0n || range.max < range.min || range.max > amount)) {
+      throw errors.invalidIntentAmountRange(amount, range.min, range.max);
+    }
+    return {
+      amount,
+      ...payoutInput,
+      ...range ? { intentAmountRange: range } : {}
+    };
   }
   async function buildDepositParams(client, depositInput) {
     try {
@@ -1135,32 +1581,54 @@ function createCashClient(options) {
       throw errors.payeeRegistrationFailed(err);
     }
   }
+  function parseDepositId(depositId) {
+    try {
+      const parsed = parseCompositeDepositId(depositId);
+      return {
+        ...parsed,
+        compositeId: sdk.createCompositeDepositId(parsed.escrowAddress, parsed.onchainDepositId)
+      };
+    } catch (err) {
+      throw errors.invalidDepositId(depositId, err);
+    }
+  }
   async function fetchOrder(depositId) {
-    const deposits = await readClient.indexer.getDepositsByIdsWithRelations([depositId], {
-      includeIntents: true,
-      intentStatuses: CASH_ORDER_STATUSES
-    });
+    const { compositeId } = parseDepositId(depositId);
+    let deposits;
+    try {
+      deposits = await readClient.indexer.getDepositsByIdsWithRelations([compositeId], {
+        includeIntents: true,
+        intentStatuses: CASH_ORDER_STATUSES
+      });
+    } catch (err) {
+      throw errors.indexerUnavailable("order", err);
+    }
     const deposit = deposits[0];
     if (!deposit) {
-      const intents = await readClient.indexer.getIntentsForDeposits(
-        [depositId],
-        CASH_ORDER_STATUSES
-      );
-      if (intents.length === 0) throw errors.orderNotFound(depositId);
-      return deriveCashOrder(depositId, intents);
+      let intents;
+      try {
+        intents = await readClient.indexer.getIntentsForDeposits(
+          [compositeId],
+          CASH_ORDER_STATUSES
+        );
+      } catch (err) {
+        throw errors.indexerUnavailable("order intents", err);
+      }
+      if (intents.length === 0) throw errors.orderNotFound(compositeId);
+      return deriveCashOrder(compositeId, intents);
     }
     const payouts = derivePayouts(
       deposit.paymentMethods ?? [],
       deposit.currencies ?? [],
       sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment)
     );
-    return deriveCashOrder(depositId, deposit.intents ?? [], {
+    return deriveCashOrder(compositeId, deposit.intents ?? [], {
       ...depositOrderOptions(deposit),
       ...payouts.length > 0 ? { payouts } : {}
     });
   }
   function escrowContext(depositId) {
-    const { escrowAddress, onchainDepositId } = parseCompositeDepositId(depositId);
+    const { escrowAddress, onchainDepositId } = parseDepositId(depositId);
     return {
       onchainDepositId,
       escrowArg: escrowAddress ? { escrowAddress } : {}
@@ -1175,7 +1643,7 @@ function createCashClient(options) {
     const signaled = order.fills.filter((f) => f.status === "SIGNALED");
     const liveIntent = signaled.some((f) => isFillLive(f, nowSeconds));
     const expiredIntent = signaled.length > 0 && !liveIntent;
-    if (order.pendingAmount > 0n && liveIntent) {
+    if (liveIntent || order.pendingAmount > 0n && signaled.length === 0) {
       throw errors.activeIntentBlocksWithdrawal(depositId);
     }
     if (availableAmount(order) <= 0n && order.pendingAmount === 0n) {
@@ -1216,22 +1684,104 @@ function createCashClient(options) {
         txOverrides: attribution
       });
     } catch (err) {
-      throw mapChainError("approve", err);
+      throw mapChainError("approve", err, { requiredAmount: amount });
     }
     if (allowance.hadAllowance || !allowance.hash) return;
-    const receipt = await client.publicClient.waitForTransactionReceipt({ hash: allowance.hash });
+    let receipt;
+    try {
+      receipt = await client.publicClient.waitForTransactionReceipt({ hash: allowance.hash });
+    } catch (err) {
+      throw errors.transactionStatusUnknown(allowance.hash, err, "approve");
+    }
     if (receipt.status === "reverted") throw errors.transactionFailed(allowance.hash);
+    let lastReadError;
     for (let attempt = 0; attempt < 15; attempt++) {
-      const visible = await client.publicClient.readContract({
-        address: token,
-        abi: ERC20_ALLOWANCE_ABI,
-        functionName: "allowance",
-        args: [owner, escrow]
-      });
-      if (visible >= amount) return;
+      try {
+        const visible = await client.publicClient.readContract({
+          address: token,
+          abi: ERC20_ALLOWANCE_ABI,
+          functionName: "allowance",
+          args: [owner, escrow]
+        });
+        if (visible >= amount) return;
+      } catch (err) {
+        lastReadError = err;
+      }
       await sleep(1e3);
     }
-    throw errors.allowanceNotVisible(amount);
+    throw errors.allowanceNotVisible(amount, lastReadError);
+  }
+  async function waitForBaseSignerAfterRelay(client, cashoutSigner, sourceSigner, owner, sourceChainId, executed) {
+    if (sourceChainId !== BASE_CHAIN_ID) return;
+    const baseTransactions = (executed.transactions?.origin ?? []).filter(
+      (transaction) => transaction.chainId === BASE_CHAIN_ID
+    );
+    const batchIds = baseTransactions.filter((transaction) => transaction.isBatchTx === true).map((transaction) => transaction.hash);
+    let batchTransactionHashes = [];
+    if (batchIds.length > 0) {
+      let batchError;
+      let batchesComplete = false;
+      for (let attempt = 0; attempt < 20; attempt++) {
+        try {
+          const statuses = await Promise.all(
+            batchIds.map((id) => sourceSigner.getCallsStatus({ id }))
+          );
+          if (statuses.some((status) => status.status === "failure")) {
+            throw new Error("Relay wallet call bundle failed");
+          }
+          if (statuses.every((status) => status.status === "success")) {
+            batchTransactionHashes = statuses.flatMap(
+              (status) => (status.receipts ?? []).map((receipt) => receipt.transactionHash)
+            );
+            batchesComplete = true;
+            break;
+          }
+        } catch (err) {
+          batchError = err;
+        }
+        await sleep(250);
+      }
+      if (!batchesComplete) {
+        throw batchError ?? new Error("Relay wallet call bundle did not complete");
+      }
+    }
+    const hashes = [
+      ...baseTransactions.filter((transaction) => transaction.isBatchTx !== true).map((transaction) => transaction.hash),
+      ...batchTransactionHashes
+    ];
+    if (hashes.length === 0) return;
+    let transactions;
+    let lastLookupError;
+    for (let attempt = 0; attempt < 20; attempt++) {
+      try {
+        transactions = await Promise.all(
+          hashes.map((hash) => client.publicClient.getTransaction({ hash }))
+        );
+        break;
+      } catch (err) {
+        lastLookupError = err;
+        await sleep(250);
+      }
+    }
+    if (!transactions) throw lastLookupError;
+    const ownerNonces = transactions.filter((transaction) => transaction.from.toLowerCase() === owner.toLowerCase()).map((transaction) => transaction.nonce);
+    if (ownerNonces.length === 0) return;
+    const afterRelay = Math.max(...ownerNonces) + 1;
+    let lastNonceError;
+    for (let attempt = 0; attempt < 20; attempt++) {
+      try {
+        const pendingHex = await cashoutSigner.transport.request({
+          method: "eth_getTransactionCount",
+          params: [owner, "pending"]
+        });
+        if (Number(BigInt(pendingHex)) >= afterRelay) return;
+      } catch (err) {
+        lastNonceError = err;
+      }
+      await sleep(250);
+    }
+    if (lastNonceError) throw lastNonceError;
+    throw new Error(`Signer provider did not observe Relay nonce ${afterRelay - 1}`);
   }
   return {
     capabilities,
@@ -1242,8 +1792,10 @@ function createCashClient(options) {
       return quoteRelayToBaseUsdc(input, options.relay);
     },
     async executeSourceQuote(quote, opts) {
+      if (!opts.signer.account) throw errors.signerRequired("executeSourceQuote");
       return executeRelayQuote(quote, opts.signer, {
         ...options.relay ? { relay: options.relay } : {},
+        ...opts.recipient ? { recipient: opts.recipient } : {},
         ...opts.onProgress ? { onProgress: opts.onProgress } : {},
         ...opts.disableCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: opts.disableCapabilitiesCheck } : {}
       });
@@ -1259,7 +1811,7 @@ function createCashClient(options) {
       });
     },
     async cashout(input, opts) {
-      const client = signingClient("cashout", opts);
+      const client = await signingClient("cashout", opts);
       const owner = opts.signer.account.address;
       const payoutInput = validatePayout(input);
       let sourceResult;
@@ -1267,6 +1819,7 @@ function createCashClient(options) {
       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");
+        await assertWalletChainId(sourceSigner, input.source.chainId, "source cashout");
         if (input.source.recipient !== void 0 && input.source.recipient.toLowerCase() !== owner.toLowerCase()) {
           throw errors.sourceRecipientMismatch(input.source.recipient, owner);
         }
@@ -1284,20 +1837,38 @@ function createCashClient(options) {
           throw errors.amountBelowMinimum(relayQuote.outputAmount, MIN_CASHOUT_AMOUNT);
         }
         cashoutAmount = relayQuote.outputAmount;
-        const depositInput2 = { amount: cashoutAmount, ...payoutInput };
+        const depositInput2 = validateDepositInput(cashoutAmount, input, 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 } : {},
+          recipient: owner,
           ...opts.onSourceProgress ? { onProgress: opts.onSourceProgress } : {},
           ...opts.disableSourceCapabilitiesCheck !== void 0 ? { disableCapabilitiesCheck: opts.disableSourceCapabilitiesCheck } : {}
         });
-        sourceResult = {
+        const routedSource = {
           amount: cashoutAmount,
           ...executed.requestId ? { requestId: executed.requestId } : {},
-          txHashes: executed.txHashes
+          txHashes: executed.txHashes,
+          ...executed.transactions ? { transactions: executed.transactions } : {}
         };
+        sourceResult = routedSource;
+        try {
+          await waitForBaseSignerAfterRelay(
+            client,
+            opts.signer,
+            sourceSigner,
+            owner,
+            input.source.chainId,
+            executed
+          );
+        } catch (err) {
+          throw errors.sourceRouteCompletedCashoutFailed(
+            routedSource,
+            mapChainError("resolve same-chain Relay nonce", err)
+          );
+        }
         const attributedParams2 = { ...params2, txOverrides: attribution };
         const send2 = async () => {
           try {
@@ -1314,10 +1885,26 @@ function createCashClient(options) {
         try {
           hash2 = await send2();
         } catch (err) {
-          throw mapChainError("createDeposit", err);
+          const mapped = mapChainError("createDeposit", err, {
+            requiredAmount: depositInput2.amount
+          });
+          if (isKnownPreBroadcastFailure(err, mapped)) {
+            throw errors.sourceRouteCompletedCashoutFailed(routedSource, mapped);
+          }
+          throw errors.sourceCashoutSubmissionUnknown(routedSource, owner, mapped);
+        }
+        let receipt2;
+        try {
+          receipt2 = await client.publicClient.waitForTransactionReceipt({ hash: hash2 });
+        } catch (err) {
+          throw errors.sourceCashoutStatusUnknown(routedSource, hash2, err);
+        }
+        if (receipt2.status === "reverted") {
+          throw errors.sourceRouteCompletedCashoutFailed(
+            routedSource,
+            errors.transactionFailed(hash2)
+          );
         }
-        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);
@@ -1331,10 +1918,10 @@ function createCashClient(options) {
           escrowAddress: resolved2.escrowAddress,
           onchainDepositId: resolved2.onchainDepositId,
           order: order2,
-          source: sourceResult
+          source: routedSource
         };
       }
-      const depositInput = validateInput(input);
+      const depositInput = validateDepositInput(input.amount, input, payoutInput);
       const params = await buildDepositParams(client, depositInput);
       const escrow = client.escrowV2Address ?? client.escrowAddress;
       await settleAllowance(client, params.token, owner, escrow, depositInput.amount);
@@ -1354,9 +1941,23 @@ function createCashClient(options) {
       try {
         hash = await send();
       } catch (err) {
-        throw mapChainError("createDeposit", err);
+        const mapped = mapChainError("createDeposit", err, {
+          requiredAmount: depositInput.amount
+        });
+        if (isKnownPreBroadcastFailure(err, mapped)) throw mapped;
+        throw errors.transactionSubmissionUnknown("cashout", err, {
+          kind: "inspect-base-cashout-submission",
+          amount: depositInput.amount.toString(),
+          depositor: owner,
+          txHashes: []
+        });
+      }
+      let receipt;
+      try {
+        receipt = await client.publicClient.waitForTransactionReceipt({ hash });
+      } catch (err) {
+        throw errors.transactionStatusUnknown(hash, err, "cashout");
       }
-      const receipt = await client.publicClient.waitForTransactionReceipt({ hash });
       if (receipt.status === "reverted") throw errors.transactionFailed(hash);
       const abi = client.escrowV2Abi ?? client.escrowAbi;
       const resolved = resolveCashDepositId({ logs: receipt.logs, abi });
@@ -1376,7 +1977,7 @@ function createCashClient(options) {
     },
     async prepare(input) {
       if (input.source) throw errors.sourceRouteUnsupportedInPrepare();
-      const depositInput = validateInput(input);
+      const depositInput = validateDepositInput(input.amount, input);
       const params = await buildDepositParams(readClient, depositInput);
       const { prepared } = await readClient.prepareCreateDeposit({
         ...params,
@@ -1415,13 +2016,46 @@ function createCashClient(options) {
       return fetchOrder(depositId);
     },
     async buyer(address) {
-      const intents = await readClient.indexer.getOwnerIntents(address, CASH_ORDER_STATUSES);
+      let intents;
+      try {
+        intents = await readClient.indexer.getOwnerIntents(address, CASH_ORDER_STATUSES);
+      } catch (err) {
+        throw errors.indexerUnavailable("buyer profile", err);
+      }
       return deriveBuyerProfile(address, intents);
     },
     async orders(owner, opts = {}) {
       const { inFlight = false, limit = 100 } = opts;
-      const deposits = await readClient.indexer.getDeposits({ depositor: owner }, { limit });
-      const derived = deposits.map((d) => deriveCashOrder(d.id, [], { ...depositOrderOptions(d), fillsIncluded: false })).filter((o) => o.totalAmount > 10000n).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+      let deposits;
+      try {
+        deposits = await readClient.indexer.getDepositsWithRelations(
+          { depositor: owner },
+          { limit }
+        );
+      } catch (err) {
+        throw errors.indexerUnavailable("orders", err);
+      }
+      const catalog = sdk.getPaymentMethodsCatalog(BASE_CHAIN_ID, environment);
+      const derived = deposits.flatMap((deposit) => {
+        if (deposit.token.toLowerCase() !== BASE_USDC_ADDRESS.toLowerCase()) return [];
+        const payouts = derivePayouts(
+          deposit.paymentMethods ?? [],
+          deposit.currencies ?? [],
+          catalog
+        );
+        if (payouts.length !== 1 || !payouts.every((payout) => payout.pricing.marketRate && payout.pricing.spreadBps === 0)) {
+          return [];
+        }
+        return [
+          deriveCashOrder(deposit.id, [], {
+            ...depositOrderOptions(deposit),
+            payouts,
+            // List rows carry no intent detail - a positive outstanding
+            // amount is treated conservatively as a live lock.
+            fillsIncluded: false
+          })
+        ];
+      }).filter((o) => o.totalAmount >= MIN_CASHOUT_AMOUNT).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
       return inFlight ? derived.filter((o) => o.isInFlight) : derived;
     },
     async *watch(depositId, opts = {}) {
@@ -1451,7 +2085,7 @@ function createCashClient(options) {
       }
     },
     async withdraw(depositId, opts) {
-      const client = signingClient("withdraw", opts);
+      const client = await signingClient("withdraw", opts);
       if (opts.amount !== void 0) {
         const { onchainDepositId: onchainDepositId2, escrowArg: escrowArg2 } = await partialWithdrawContext(
           depositId,
@@ -1549,7 +2183,7 @@ function createCashClient(options) {
       return { txs, steps };
     },
     async topUp(depositId, amount, opts) {
-      const client = signingClient("topUp", opts);
+      const client = await signingClient("topUp", opts);
       const { onchainDepositId, escrowArg } = await topUpContext(depositId, amount);
       const owner = opts.signer.account.address;
       const escrow = escrowArg.escrowAddress ?? client.escrowV2Address ?? client.escrowAddress;
@@ -1604,6 +2238,40 @@ function createCashClient(options) {
   };
 }
 var bigintString = zod.z.string().regex(/^-?\d+$/, "expected a decimal bigint string");
+var nonNegativeBigintString = zod.z.string().regex(/^\d+$/, "expected a non-negative decimal bigint string");
+var relayTransactionJsonSchema = zod.z.object({
+  hash: zod.z.string(),
+  chainId: zod.z.number(),
+  isBatchTx: zod.z.boolean().optional()
+});
+var relayTransactionsJsonSchema = zod.z.object({
+  origin: zod.z.array(relayTransactionJsonSchema),
+  destination: zod.z.array(relayTransactionJsonSchema)
+}).strict();
+var cashAssetJsonSchema = 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()
+});
+var cashChainJsonSchema = 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(cashAssetJsonSchema)
+});
+var cashSourceCapabilitiesJsonSchema = zod.z.object({
+  destination: cashAssetJsonSchema,
+  chains: zod.z.array(cashChainJsonSchema),
+  source: zod.z.literal("relay-sdk"),
+  asOf: zod.z.number()
+});
 var cashOrderStateSchema = zod.z.enum([
   "awaiting-buyer",
   "matched",
@@ -1616,18 +2284,18 @@ var intentStatusSchema = zod.z.enum(["SIGNALED", "FULFILLED", "PRUNED", "MANUALL
 var cashFillJsonSchema = zod.z.object({
   intentHash: zod.z.string(),
   status: intentStatusSchema,
-  amount: bigintString,
+  amount: nonNegativeBigintString,
   buyer: zod.z.string(),
   currency: zod.z.string().optional(),
   currencyHash: zod.z.string().optional(),
   rate: zod.z.number().optional(),
-  conversionRate: bigintString.optional(),
+  conversionRate: nonNegativeBigintString.optional(),
   fiatOwed: zod.z.number().optional(),
   fiatPaid: zod.z.number().optional(),
   paidCurrency: zod.z.string().optional(),
   paymentId: zod.z.string().optional(),
   paidAt: zod.z.number().optional(),
-  releasedAmount: bigintString.optional(),
+  releasedAmount: nonNegativeBigintString.optional(),
   fillLatencySeconds: zod.z.number().optional(),
   isExpired: zod.z.boolean().optional(),
   signaledAt: zod.z.number().optional(),
@@ -1666,10 +2334,10 @@ var cashOrderJsonSchema = zod.z.object({
   depositId: zod.z.string(),
   state: cashOrderStateSchema,
   fills: zod.z.array(cashFillJsonSchema),
-  totalAmount: bigintString,
-  filledAmount: bigintString,
-  pendingAmount: bigintString,
-  returnedAmount: bigintString,
+  totalAmount: nonNegativeBigintString,
+  filledAmount: nonNegativeBigintString,
+  pendingAmount: nonNegativeBigintString,
+  returnedAmount: nonNegativeBigintString,
   nextActions: zod.z.array(cashNextActionSchema),
   primaryIntentHash: zod.z.string().optional(),
   matchedAt: zod.z.number().optional(),
@@ -1684,7 +2352,7 @@ var cashOrderJsonSchema = zod.z.object({
 var cashEstimateJsonSchema = zod.z.object({
   kind: zod.z.literal("oracle-estimate"),
   currency: zod.z.string(),
-  amount: bigintString,
+  amount: nonNegativeBigintString,
   rate: zod.z.number(),
   receiveAmount: zod.z.number(),
   asOf: zod.z.number(),
@@ -1700,7 +2368,7 @@ var cashEstimateJsonSchema = zod.z.object({
       name: zod.z.string().optional(),
       isNative: zod.z.boolean().optional()
     }),
-    inputAmount: bigintString,
+    inputAmount: nonNegativeBigintString,
     relayQuote: zod.z.object({
       requestId: zod.z.string().optional(),
       source: zod.z.object({
@@ -1719,8 +2387,8 @@ var cashEstimateJsonSchema = zod.z.object({
         name: zod.z.string().optional(),
         isNative: zod.z.boolean().optional()
       }),
-      inputAmount: bigintString,
-      outputAmount: bigintString,
+      inputAmount: nonNegativeBigintString,
+      outputAmount: nonNegativeBigintString,
       rate: zod.z.number().optional(),
       timeEstimateSeconds: zod.z.number().optional(),
       fees: zod.z.unknown().optional(),
@@ -1728,7 +2396,7 @@ var cashEstimateJsonSchema = zod.z.object({
         zod.z.object({
           to: zod.z.string(),
           data: zod.z.string(),
-          value: bigintString,
+          value: nonNegativeBigintString,
           chainId: zod.z.number()
         })
       ),
@@ -1743,9 +2411,39 @@ var cashEstimateJsonSchema = zod.z.object({
 var preparedTransactionJsonSchema = zod.z.object({
   to: zod.z.string(),
   data: zod.z.string(),
-  value: bigintString,
+  value: nonNegativeBigintString,
   chainId: zod.z.number()
 });
+var relayQuoteJsonSchema = zod.z.object({
+  requestId: zod.z.string().optional(),
+  source: cashAssetJsonSchema,
+  destination: cashAssetJsonSchema,
+  inputAmount: nonNegativeBigintString,
+  outputAmount: nonNegativeBigintString,
+  rate: zod.z.number().optional(),
+  timeEstimateSeconds: zod.z.number().optional(),
+  fees: zod.z.unknown().optional(),
+  txs: zod.z.array(preparedTransactionJsonSchema),
+  raw: zod.z.unknown()
+});
+var relayStatusJsonSchema = zod.z.object({
+  requestId: zod.z.string(),
+  status: zod.z.enum(["refund", "waiting", "depositing", "failure", "pending", "submitted", "success"]),
+  details: zod.z.string().optional(),
+  inTxHashes: zod.z.array(zod.z.string()),
+  txHashes: zod.z.array(zod.z.string()),
+  updatedAt: zod.z.number().optional(),
+  originChainId: zod.z.number().optional(),
+  destinationChainId: zod.z.number().optional(),
+  quoteCreatedAt: zod.z.number().optional(),
+  raw: zod.z.unknown()
+});
+var relayExecutionResultJsonSchema = zod.z.object({
+  requestId: zod.z.string().optional(),
+  txHashes: zod.z.array(zod.z.string()),
+  transactions: relayTransactionsJsonSchema.optional(),
+  quote: zod.z.unknown()
+});
 var cashPreparedStepJsonSchema = zod.z.object({
   kind: zod.z.enum([
     "approve",
@@ -1761,12 +2459,13 @@ var cashoutResultJsonSchema = zod.z.object({
   depositId: zod.z.string(),
   txHash: zod.z.string(),
   escrowAddress: zod.z.string(),
-  onchainDepositId: bigintString,
+  onchainDepositId: nonNegativeBigintString,
   order: cashOrderJsonSchema,
   source: zod.z.object({
-    amount: bigintString,
+    amount: nonNegativeBigintString,
     requestId: zod.z.string().optional(),
-    txHashes: zod.z.array(zod.z.string())
+    txHashes: zod.z.array(zod.z.string()),
+    transactions: relayTransactionsJsonSchema.optional()
   }).optional()
 });
 var prepareResultJsonSchema = zod.z.object({
@@ -1796,39 +2495,7 @@ 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() })
     }),
-    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()
+    relay: cashSourceCapabilitiesJsonSchema.optional()
   }),
   platforms: zod.z.array(
     zod.z.object({
@@ -1839,15 +2506,98 @@ var cashCapabilitiesJsonSchema = zod.z.object({
     })
   ),
   currencies: zod.z.array(zod.z.string()),
-  amount: zod.z.object({ min: bigintString, recommendedMin: bigintString, max: zod.z.null() }),
+  amount: zod.z.object({
+    min: nonNegativeBigintString,
+    recommendedMin: nonNegativeBigintString,
+    max: zod.z.null()
+  }),
   pricing: zod.z.object({ kind: zod.z.literal("oracle-market-rate"), spreadBps: zod.z.literal(0) })
 });
+function defineCashErrorCodes(codes) {
+  return codes;
+}
+var CASH_ERROR_CODES = defineCashErrorCodes([
+  "ORACLE_UNSUPPORTED_CURRENCY",
+  "ORACLE_READ_FAILED",
+  "UNSUPPORTED_PLATFORM",
+  "UNSUPPORTED_PLATFORM_CURRENCY",
+  "AMOUNT_BELOW_MINIMUM",
+  "INVALID_INTENT_AMOUNT_RANGE",
+  "ACTIVE_INTENT_BLOCKS_WITHDRAWAL",
+  "NOTHING_TO_WITHDRAW",
+  "INSUFFICIENT_AVAILABLE_FUNDS",
+  "INSUFFICIENT_TOKEN_BALANCE",
+  "ORDER_NOT_ACTIVE",
+  "INVALID_DEPOSIT_ID",
+  "ESCROW_PAUSED",
+  "INDEXER_LAG",
+  "INDEXER_UNAVAILABLE",
+  "ORDER_NOT_FOUND",
+  "PAYEE_REGISTRATION_FAILED",
+  "PAYEE_VERIFICATION_REQUIRED",
+  "SOURCE_ROUTE_UNSUPPORTED_IN_PREPARE",
+  "SOURCE_RECIPIENT_MISMATCH",
+  "SOURCE_CAPABILITIES_FAILED",
+  "SOURCE_QUOTE_FAILED",
+  "SOURCE_EXECUTION_FAILED",
+  "SOURCE_STATUS_FAILED",
+  "SOURCE_ROUTE_COMPLETED_CASHOUT_FAILED",
+  "SOURCE_CASHOUT_SUBMISSION_UNKNOWN",
+  "SOURCE_CASHOUT_STATUS_UNKNOWN",
+  "DEPOSIT_RESOLUTION_FAILED",
+  "ALLOWANCE_NOT_VISIBLE",
+  "SIGNER_REQUIRED",
+  "SIGNER_CHAIN_MISMATCH",
+  "SIGNER_CHAIN_UNAVAILABLE",
+  "WATCH_TIMEOUT",
+  "TRANSACTION_FAILED",
+  "TRANSACTION_SUBMISSION_UNKNOWN",
+  "TRANSACTION_STATUS_UNKNOWN"
+]);
+var cashSourceRecoveryJsonShape = {
+  amount: nonNegativeBigintString,
+  requestId: zod.z.string().optional(),
+  txHashes: zod.z.array(zod.z.string()),
+  transactions: relayTransactionsJsonSchema.optional()
+};
+var cashErrorRecoveryJsonSchema = zod.z.discriminatedUnion("kind", [
+  zod.z.object({
+    ...cashSourceRecoveryJsonShape,
+    kind: zod.z.literal("retry-base-usdc-cashout")
+  }).strict(),
+  zod.z.object({
+    ...cashSourceRecoveryJsonShape,
+    kind: zod.z.literal("inspect-base-cashout-transaction"),
+    depositTxHash: zod.z.string()
+  }).strict(),
+  zod.z.object({
+    ...cashSourceRecoveryJsonShape,
+    kind: zod.z.literal("inspect-base-cashout-submission"),
+    depositor: zod.z.string()
+  }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("inspect-relay-route"),
+    requestId: zod.z.string().optional(),
+    txHashes: zod.z.array(zod.z.string()),
+    transactions: relayTransactionsJsonSchema.optional()
+  }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("inspect-base-operation-submission"),
+    operation: zod.z.string()
+  }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("inspect-base-transaction"),
+    transactionHash: zod.z.string(),
+    operation: zod.z.string()
+  }).strict()
+]);
 var cashErrorJsonSchema = zod.z.object({
-  code: zod.z.string(),
+  code: zod.z.enum(CASH_ERROR_CODES),
   message: zod.z.string(),
   retryable: zod.z.boolean(),
-  remediation: zod.z.string()
-});
+  remediation: zod.z.string(),
+  recovery: cashErrorRecoveryJsonSchema.optional()
+}).strict();
 
 // src/codecs/json.ts
 function omitUndefined(obj) {
@@ -1878,35 +2628,38 @@ function fillToJson(fill) {
   });
 }
 function fillFromJson(json) {
+  const parsed = cashFillJsonSchema.parse(json);
   return omitUndefined({
-    ...json,
-    amount: BigInt(json.amount),
-    conversionRate: json.conversionRate !== void 0 ? BigInt(json.conversionRate) : void 0,
-    releasedAmount: json.releasedAmount !== void 0 ? BigInt(json.releasedAmount) : void 0
+    ...parsed,
+    amount: BigInt(parsed.amount),
+    conversionRate: parsed.conversionRate !== void 0 ? BigInt(parsed.conversionRate) : void 0,
+    releasedAmount: parsed.releasedAmount !== void 0 ? BigInt(parsed.releasedAmount) : void 0
   });
 }
 function orderToJson(order) {
-  return omitUndefined({
-    depositId: order.depositId,
-    state: order.state,
-    fills: order.fills.map(fillToJson),
-    totalAmount: order.totalAmount.toString(),
-    filledAmount: order.filledAmount.toString(),
-    pendingAmount: order.pendingAmount.toString(),
-    returnedAmount: order.returnedAmount.toString(),
-    nextActions: order.nextActions,
-    primaryIntentHash: order.primaryIntentHash,
-    matchedAt: order.matchedAt,
-    deliveredAt: order.deliveredAt,
-    updatedAt: order.updatedAt,
-    intentCount: order.intentCount,
-    payouts: order.payouts?.map(
-      (p) => omitUndefined({ ...p, pricing: omitUndefined({ ...p.pricing }) })
-    ),
-    successRateBps: order.successRateBps,
-    isInFlight: order.isInFlight,
-    withdrawn: order.withdrawn
-  });
+  return cashOrderJsonSchema.parse(
+    omitUndefined({
+      depositId: order.depositId,
+      state: order.state,
+      fills: order.fills.map(fillToJson),
+      totalAmount: order.totalAmount.toString(),
+      filledAmount: order.filledAmount.toString(),
+      pendingAmount: order.pendingAmount.toString(),
+      returnedAmount: order.returnedAmount.toString(),
+      nextActions: order.nextActions,
+      primaryIntentHash: order.primaryIntentHash,
+      matchedAt: order.matchedAt,
+      deliveredAt: order.deliveredAt,
+      updatedAt: order.updatedAt,
+      intentCount: order.intentCount,
+      payouts: order.payouts?.map(
+        (p) => omitUndefined({ ...p, pricing: omitUndefined({ ...p.pricing }) })
+      ),
+      successRateBps: order.successRateBps,
+      isInFlight: order.isInFlight,
+      withdrawn: order.withdrawn
+    })
+  );
 }
 function orderFromJson(json) {
   const parsed = cashOrderJsonSchema.parse(json);
@@ -1932,6 +2685,7 @@ function estimateToJson(estimate) {
         inputAmount: estimate.source.relayQuote.inputAmount.toString(),
         outputAmount: estimate.source.relayQuote.outputAmount.toString(),
         txs: estimate.source.relayQuote.txs.map(preparedTxToJson),
+        ...estimate.source.relayQuote.fees !== void 0 ? { fees: sanitizeRelayValue(estimate.source.relayQuote.fees) } : {},
         raw: sanitizeRelayQuoteRaw(estimate.source.relayQuote.raw)
       }
     } : void 0
@@ -1950,11 +2704,108 @@ function estimateFromJson(json) {
         ...parsed.source.relayQuote,
         inputAmount: BigInt(parsed.source.relayQuote.inputAmount),
         outputAmount: BigInt(parsed.source.relayQuote.outputAmount),
-        txs: parsed.source.relayQuote.txs.map(preparedTxFromJson)
+        txs: parsed.source.relayQuote.txs.map(preparedTxFromJson),
+        ...parsed.source.relayQuote.fees !== void 0 ? { fees: restoreRelayValue(parsed.source.relayQuote.fees) } : {},
+        raw: restoreRelayQuoteRaw(parsed.source.relayQuote.raw)
       }
     } : void 0
   });
 }
+function cashAssetFromJson(asset) {
+  return {
+    chainId: asset.chainId,
+    address: asset.address,
+    symbol: asset.symbol,
+    decimals: asset.decimals,
+    ...asset.name !== void 0 ? { name: asset.name } : {},
+    ...asset.isNative !== void 0 ? { isNative: asset.isNative } : {}
+  };
+}
+function relayQuoteToJson(quote) {
+  return relayQuoteJsonSchema.parse({
+    ...quote.requestId !== void 0 ? { requestId: quote.requestId } : {},
+    source: quote.source,
+    destination: quote.destination,
+    inputAmount: quote.inputAmount.toString(),
+    outputAmount: quote.outputAmount.toString(),
+    ...quote.rate !== void 0 ? { rate: quote.rate } : {},
+    ...quote.timeEstimateSeconds !== void 0 ? { timeEstimateSeconds: quote.timeEstimateSeconds } : {},
+    ...quote.fees !== void 0 ? { fees: sanitizeRelayValue(quote.fees) } : {},
+    txs: quote.txs.map(preparedTxToJson),
+    raw: sanitizeRelayQuoteRaw(quote.raw)
+  });
+}
+function relayQuoteFromJson(json) {
+  const parsed = relayQuoteJsonSchema.parse(json);
+  return {
+    ...parsed.requestId !== void 0 ? { requestId: parsed.requestId } : {},
+    source: cashAssetFromJson(parsed.source),
+    destination: cashAssetFromJson(parsed.destination),
+    inputAmount: BigInt(parsed.inputAmount),
+    outputAmount: BigInt(parsed.outputAmount),
+    ...parsed.rate !== void 0 ? { rate: parsed.rate } : {},
+    ...parsed.timeEstimateSeconds !== void 0 ? { timeEstimateSeconds: parsed.timeEstimateSeconds } : {},
+    ...parsed.fees !== void 0 ? { fees: restoreRelayValue(parsed.fees) } : {},
+    txs: parsed.txs.map(preparedTxFromJson),
+    raw: restoreRelayQuoteRaw(parsed.raw)
+  };
+}
+function sourceCapabilitiesToJson(capabilities) {
+  return cashSourceCapabilitiesJsonSchema.parse(capabilities);
+}
+function sourceCapabilitiesFromJson(json) {
+  const parsed = cashSourceCapabilitiesJsonSchema.parse(json);
+  return {
+    destination: cashAssetFromJson(parsed.destination),
+    chains: parsed.chains.map((chain) => ({
+      id: chain.id,
+      name: chain.name,
+      displayName: chain.displayName,
+      disabled: chain.disabled,
+      depositEnabled: chain.depositEnabled,
+      blockProductionLagging: chain.blockProductionLagging,
+      ...chain.vmType !== void 0 ? { vmType: chain.vmType } : {},
+      tokens: chain.tokens.map(cashAssetFromJson)
+    })),
+    source: parsed.source,
+    asOf: parsed.asOf
+  };
+}
+function relayStatusToJson(status) {
+  return relayStatusJsonSchema.parse({ ...status, raw: sanitizeRelayValue(status.raw) });
+}
+function relayStatusFromJson(json) {
+  const parsed = relayStatusJsonSchema.parse(json);
+  return {
+    requestId: parsed.requestId,
+    status: parsed.status,
+    ...parsed.details !== void 0 ? { details: parsed.details } : {},
+    inTxHashes: parsed.inTxHashes,
+    txHashes: parsed.txHashes,
+    ...parsed.updatedAt !== void 0 ? { updatedAt: parsed.updatedAt } : {},
+    ...parsed.originChainId !== void 0 ? { originChainId: parsed.originChainId } : {},
+    ...parsed.destinationChainId !== void 0 ? { destinationChainId: parsed.destinationChainId } : {},
+    ...parsed.quoteCreatedAt !== void 0 ? { quoteCreatedAt: parsed.quoteCreatedAt } : {},
+    raw: restoreRelayValue(parsed.raw)
+  };
+}
+function relayExecutionResultToJson(result) {
+  return relayExecutionResultJsonSchema.parse({
+    ...result.requestId !== void 0 ? { requestId: result.requestId } : {},
+    txHashes: result.txHashes,
+    ...result.transactions !== void 0 ? { transactions: result.transactions } : {},
+    quote: sanitizeRelayQuoteRaw(result.quote)
+  });
+}
+function relayExecutionResultFromJson(json) {
+  const parsed = relayExecutionResultJsonSchema.parse(json);
+  return {
+    ...parsed.requestId !== void 0 ? { requestId: parsed.requestId } : {},
+    txHashes: parsed.txHashes,
+    ...parsed.transactions !== void 0 ? { transactions: parsed.transactions } : {},
+    quote: restoreRelayQuoteRaw(parsed.quote)
+  };
+}
 function preparedTxToJson(tx) {
   return { to: tx.to, data: tx.data, value: tx.value.toString(), chainId: tx.chainId };
 }
@@ -2073,6 +2924,69 @@ function capabilitiesFromJson(json) {
     }
   };
 }
+function cashErrorToJson(error) {
+  return cashErrorJsonSchema.parse({
+    code: error.code,
+    message: error.message,
+    retryable: error.retryable,
+    remediation: error.remediation,
+    ...error.recovery ? { recovery: error.recovery } : {}
+  });
+}
+function cashErrorFromJson(json) {
+  const parsed = cashErrorJsonSchema.parse(json);
+  let recovery;
+  if (parsed.recovery) {
+    if (parsed.recovery.kind === "inspect-base-transaction") {
+      recovery = {
+        kind: parsed.recovery.kind,
+        transactionHash: parsed.recovery.transactionHash,
+        operation: parsed.recovery.operation
+      };
+    } else if (parsed.recovery.kind === "inspect-base-operation-submission") {
+      recovery = {
+        kind: parsed.recovery.kind,
+        operation: parsed.recovery.operation
+      };
+    } else if (parsed.recovery.kind === "inspect-relay-route") {
+      recovery = {
+        kind: parsed.recovery.kind,
+        txHashes: parsed.recovery.txHashes,
+        ...parsed.recovery.requestId !== void 0 ? { requestId: parsed.recovery.requestId } : {},
+        ...parsed.recovery.transactions !== void 0 ? { transactions: parsed.recovery.transactions } : {}
+      };
+    } else {
+      const common = {
+        amount: parsed.recovery.amount,
+        txHashes: parsed.recovery.txHashes,
+        ...parsed.recovery.requestId !== void 0 ? { requestId: parsed.recovery.requestId } : {},
+        ...parsed.recovery.transactions !== void 0 ? { transactions: parsed.recovery.transactions } : {}
+      };
+      if (parsed.recovery.kind === "retry-base-usdc-cashout") {
+        recovery = { ...common, kind: parsed.recovery.kind };
+      } else if (parsed.recovery.kind === "inspect-base-cashout-submission") {
+        recovery = {
+          ...common,
+          kind: parsed.recovery.kind,
+          depositor: parsed.recovery.depositor
+        };
+      } else {
+        recovery = {
+          ...common,
+          kind: parsed.recovery.kind,
+          depositTxHash: parsed.recovery.depositTxHash
+        };
+      }
+    }
+  }
+  return new CashError({
+    code: parsed.code,
+    message: parsed.message,
+    retryable: parsed.retryable,
+    remediation: parsed.remediation,
+    ...recovery ? { recovery } : {}
+  });
+}
 
 exports.BASE_CHAIN_ID = BASE_CHAIN_ID;
 exports.BASE_USDC_ADDRESS = BASE_USDC_ADDRESS;
@@ -2095,9 +3009,14 @@ exports.buyerProfileFromJson = buyerProfileFromJson;
 exports.buyerProfileToJson = buyerProfileToJson;
 exports.capabilitiesFromJson = capabilitiesFromJson;
 exports.capabilitiesToJson = capabilitiesToJson;
+exports.cashAssetJsonSchema = cashAssetJsonSchema;
 exports.cashBuyerProfileJsonSchema = cashBuyerProfileJsonSchema;
 exports.cashCapabilitiesJsonSchema = cashCapabilitiesJsonSchema;
+exports.cashChainJsonSchema = cashChainJsonSchema;
+exports.cashErrorFromJson = cashErrorFromJson;
 exports.cashErrorJsonSchema = cashErrorJsonSchema;
+exports.cashErrorRecoveryJsonSchema = cashErrorRecoveryJsonSchema;
+exports.cashErrorToJson = cashErrorToJson;
 exports.cashEstimateJsonSchema = cashEstimateJsonSchema;
 exports.cashFillJsonSchema = cashFillJsonSchema;
 exports.cashNextActionSchema = cashNextActionSchema;
@@ -2106,6 +3025,7 @@ exports.cashOrderStateSchema = cashOrderStateSchema;
 exports.cashPayoutInfoJsonSchema = cashPayoutInfoJsonSchema;
 exports.cashPayoutPricingJsonSchema = cashPayoutPricingJsonSchema;
 exports.cashPreparedStepJsonSchema = cashPreparedStepJsonSchema;
+exports.cashSourceCapabilitiesJsonSchema = cashSourceCapabilitiesJsonSchema;
 exports.cashoutResultFromJson = cashoutResultFromJson;
 exports.cashoutResultJsonSchema = cashoutResultJsonSchema;
 exports.cashoutResultToJson = cashoutResultToJson;
@@ -2127,6 +3047,7 @@ exports.intentStatusSchema = intentStatusSchema;
 exports.isCashError = isCashError;
 exports.isFillLive = isFillLive;
 exports.isMarketRateSupported = isMarketRateSupported;
+exports.nonNegativeBigintString = nonNegativeBigintString;
 exports.orderFromJson = orderFromJson;
 exports.orderToJson = orderToJson;
 exports.parseCompositeDepositId = parseCompositeDepositId;
@@ -2140,7 +3061,20 @@ exports.preparedTransactionJsonSchema = preparedTransactionJsonSchema;
 exports.preparedTxFromJson = preparedTxFromJson;
 exports.preparedTxToJson = preparedTxToJson;
 exports.rateToNumber = rateToNumber;
+exports.relayExecutionResultFromJson = relayExecutionResultFromJson;
+exports.relayExecutionResultJsonSchema = relayExecutionResultJsonSchema;
+exports.relayExecutionResultToJson = relayExecutionResultToJson;
+exports.relayQuoteFromJson = relayQuoteFromJson;
+exports.relayQuoteJsonSchema = relayQuoteJsonSchema;
+exports.relayQuoteToJson = relayQuoteToJson;
+exports.relayStatusFromJson = relayStatusFromJson;
+exports.relayStatusJsonSchema = relayStatusJsonSchema;
+exports.relayStatusToJson = relayStatusToJson;
+exports.relayTransactionJsonSchema = relayTransactionJsonSchema;
+exports.relayTransactionsJsonSchema = relayTransactionsJsonSchema;
 exports.resolveCashDepositId = resolveCashDepositId;
+exports.sourceCapabilitiesFromJson = sourceCapabilitiesFromJson;
+exports.sourceCapabilitiesToJson = sourceCapabilitiesToJson;
 exports.topUpResultFromJson = topUpResultFromJson;
 exports.topUpResultJsonSchema = topUpResultJsonSchema;
 exports.topUpResultToJson = topUpResultToJson;
@@ -2149,5 +3083,3 @@ exports.withExplain = withExplain;
 exports.withdrawResultFromJson = withdrawResultFromJson;
 exports.withdrawResultJsonSchema = withdrawResultJsonSchema;
 exports.withdrawResultToJson = withdrawResultToJson;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map