@sodax/sdk 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/index.cjs

@@ -19,7 +19,8 @@ var IconSdkRaw = require('icon-sdk-js');
 var sdkTs = require('@injectivelabs/sdk-ts');
 var tx_js = require('cosmjs-types/cosmos/tx/v1beta1/tx.js');
 var networks = require('@injectivelabs/networks');
-var v4 = require('valibot');
+var v2 = require('valibot');
+var swapsApi = require('@sodax/swaps-api');
 var BigNumber5 = require('bignumber.js');
 var swapSdkCore = require('@pancakeswap/swap-sdk-core');
 var v3Sdk = require('@pancakeswap/v3-sdk');
@@ -48,7 +49,7 @@ var rlp__namespace = /*#__PURE__*/_interopNamespace(rlp);
 var ecc__namespace = /*#__PURE__*/_interopNamespace(ecc);
 var BN__default = /*#__PURE__*/_interopDefault(BN);
 var IconSdkRaw__namespace = /*#__PURE__*/_interopNamespace(IconSdkRaw);
-var v4__namespace = /*#__PURE__*/_interopNamespace(v4);
+var v2__namespace = /*#__PURE__*/_interopNamespace(v2);
 var BigNumber5__default = /*#__PURE__*/_interopDefault(BigNumber5);
 
 // src/errors/SodaxError.ts
@@ -121,8 +122,8 @@ function serializeCause(cause, depth) {
 }
 function sanitizeContext(value, depth) {
   const out = {};
-  for (const [key, v6] of Object.entries(value)) {
-    out[key] = sanitizeValue(v6, depth + 1);
+  for (const [key, v4] of Object.entries(value)) {
+    out[key] = sanitizeValue(v4, depth + 1);
   }
   return out;
 }
@@ -133,13 +134,13 @@ function sanitizeValue(value, depth) {
   if (t === "bigint") return value.toString();
   if (t === "string" || t === "number" || t === "boolean") return value;
   if (t === "function" || t === "symbol") return safeString(value);
-  if (Array.isArray(value)) return value.map((v6) => sanitizeValue(v6, depth + 1));
+  if (Array.isArray(value)) return value.map((v4) => sanitizeValue(v4, depth + 1));
   if (value instanceof Date) return value.toISOString();
   if (value instanceof Map) {
-    return Array.from(value.entries()).map(([k, v6]) => [sanitizeValue(k, depth + 1), sanitizeValue(v6, depth + 1)]);
+    return Array.from(value.entries()).map(([k, v4]) => [sanitizeValue(k, depth + 1), sanitizeValue(v4, depth + 1)]);
   }
   if (value instanceof Set) {
-    return Array.from(value.values()).map((v6) => sanitizeValue(v6, depth + 1));
+    return Array.from(value.values()).map((v4) => sanitizeValue(v4, depth + 1));
   }
   if (value instanceof Error) return { name: value.name, message: value.message };
   if (t === "object") {
@@ -151,9 +152,9 @@ function sanitizeValue(value, depth) {
   }
   return safeString(value);
 }
-function safeString(v6) {
+function safeString(v4) {
   try {
-    return String(v6);
+    return String(v4);
   } catch {
     return "[unserializable]";
   }
@@ -161,11 +162,17 @@ function safeString(v6) {
 
 // src/errors/codes.ts
 var CREATE_INTENT_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "UNKNOWN"
 ]);
-var APPROVE_CODES = /* @__PURE__ */ new Set(["VALIDATION_FAILED", "APPROVE_FAILED", "UNKNOWN"]);
+var APPROVE_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
+  "VALIDATION_FAILED",
+  "APPROVE_FAILED",
+  "UNKNOWN"
+]);
 var ALLOWANCE_CHECK_CODES = /* @__PURE__ */ new Set([
   "VALIDATION_FAILED",
   "ALLOWANCE_CHECK_FAILED",
@@ -178,6 +185,7 @@ var GAS_ESTIMATION_CODES = /* @__PURE__ */ new Set([
 ]);
 var LOOKUP_CODES = /* @__PURE__ */ new Set(["VALIDATION_FAILED", "LOOKUP_FAILED", "UNKNOWN"]);
 var SODAX_ERROR_CODES = [
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "EXECUTION_FAILED",
@@ -299,7 +307,8 @@ var ChainKeys = {
   BITCOIN_MAINNET: "bitcoin",
   REDBELLY_MAINNET: "redbelly",
   KAIA_MAINNET: "0x2019.kaia",
-  STACKS_MAINNET: "stacks"
+  STACKS_MAINNET: "stacks",
+  HEDERA_MAINNET: "hedera"
 };
 var CHAIN_KEYS = Object.values(ChainKeys);
 var spokeChainKeysSet = new Set(CHAIN_KEYS);
@@ -336,6 +345,7 @@ var HubVaultSymbols = [
   "sodaKAIA",
   "sodaSTX",
   "sodaUSDS",
+  "sodaHBAR",
   "sodaJITOSOL"
 ];
 var SodaTokens = {
@@ -564,6 +574,15 @@ var SodaTokens = {
     hubAsset: "0x243b0c26c8b38793908d7C64e8510f21B19B4613",
     vault: "0x243b0c26c8b38793908d7C64e8510f21B19B4613"
   },
+  sodaHBAR: {
+    symbol: "sodaHBAR",
+    name: "Soda HBAR",
+    decimals: 18,
+    address: "0x3BB956cc8922E1Ba4148dc10eD1b4Fa19aa599c4",
+    chainKey: ChainKeys.SONIC_MAINNET,
+    hubAsset: "0x3BB956cc8922E1Ba4148dc10eD1b4Fa19aa599c4",
+    vault: "0x3BB956cc8922E1Ba4148dc10eD1b4Fa19aa599c4"
+  },
   sodaJITOSOL: {
     symbol: "sodaJITOSOL",
     name: "Soda JITOSOL",
@@ -2549,6 +2568,44 @@ var kaiaSupportedTokens = {
     vault: SodaTokens.sodaSODA.address
   }
 };
+var hederaSupportedTokens = {
+  HBAR: {
+    symbol: "HBAR",
+    name: "HBAR",
+    decimals: 8,
+    address: "0x0000000000000000000000000000000000000000",
+    chainKey: ChainKeys.HEDERA_MAINNET,
+    hubAsset: "0x5c18c543b6B6EA97dE739F48C49CfC291B3AD465",
+    vault: SodaTokens.sodaHBAR.address
+  },
+  bnUSD: {
+    symbol: "bnUSD",
+    name: "bnUSD",
+    decimals: 8,
+    address: "0x0000000000000000000000000000000000a0286a",
+    chainKey: ChainKeys.HEDERA_MAINNET,
+    hubAsset: "0x44be1984cd279334a630469fa357305c7dba2837",
+    vault: SodaTokens.bnUSD.address
+  },
+  SODA: {
+    symbol: "SODA",
+    name: "SODAX",
+    decimals: 8,
+    address: "0x0000000000000000000000000000000000a02869",
+    chainKey: ChainKeys.HEDERA_MAINNET,
+    hubAsset: "0x1217721376839dbffe78093ddd5d8e50d0239b3f",
+    vault: SodaTokens.sodaSODA.address
+  },
+  USDC: {
+    symbol: "USDC",
+    name: "USD Coin",
+    decimals: 6,
+    address: "0x000000000000000000000000000000000006f89a",
+    chainKey: ChainKeys.HEDERA_MAINNET,
+    hubAsset: "0xafafae0c1476424c4b81f09095bd7dcb858047c8",
+    vault: SodaTokens.sodaUSDC.address
+  }
+};
 var stacksSupportedTokens = {
   STX: {
     symbol: "STX",
@@ -2616,7 +2673,8 @@ var supportedTokensByChain = {
   [ChainKeys.NEAR_MAINNET]: nearSupportedTokens,
   [ChainKeys.ETHEREUM_MAINNET]: ethereumSupportedTokens,
   [ChainKeys.KAIA_MAINNET]: kaiaSupportedTokens,
-  [ChainKeys.STACKS_MAINNET]: stacksSupportedTokens
+  [ChainKeys.STACKS_MAINNET]: stacksSupportedTokens,
+  [ChainKeys.HEDERA_MAINNET]: hederaSupportedTokens
 };
 
 // ../types/dist/chains/chains.js
@@ -2640,7 +2698,8 @@ var RelayChainIdMap = {
   [ChainKeys.BITCOIN_MAINNET]: 627463n,
   [ChainKeys.REDBELLY_MAINNET]: 726564n,
   [ChainKeys.KAIA_MAINNET]: 27489n,
-  [ChainKeys.STACKS_MAINNET]: 60n
+  [ChainKeys.STACKS_MAINNET]: 60n,
+  [ChainKeys.HEDERA_MAINNET]: 18501n
 };
 var INTENT_CHAIN_IDS = Object.values(RelayChainIdMap);
 var IntentRelayChainIdToChainKey = new Map(Object.entries(RelayChainIdMap).map(([chainKey, chainId]) => [chainId, chainKey]));
@@ -2926,6 +2985,20 @@ var baseChainInfo = {
       addressUrl: "https://explorer.hiro.so/address/",
       contractUrl: "https://explorer.hiro.so/txid/"
     }
+  },
+  [ChainKeys.HEDERA_MAINNET]: {
+    name: "Hedera",
+    key: ChainKeys.HEDERA_MAINNET,
+    type: "EVM",
+    chainId: 295,
+    mainnet: true,
+    logo: chainLogo(ChainKeys.HEDERA_MAINNET),
+    explorer: {
+      baseUrl: "https://hashscan.io/mainnet/",
+      txUrl: "https://hashscan.io/mainnet/transaction/",
+      addressUrl: "https://hashscan.io/mainnet/account/",
+      contractUrl: "https://hashscan.io/mainnet/contract/"
+    }
   }
 };
 var filterChainKeysByType = (type) => CHAIN_KEYS.filter((key) => baseChainInfo[key].type === type);
@@ -3321,6 +3394,21 @@ var spokeChainConfig = {
       pollingIntervalMs: 1e4,
       maxTimeoutMs: 12e4
     }
+  },
+  [ChainKeys.HEDERA_MAINNET]: {
+    chain: baseChainInfo[ChainKeys.HEDERA_MAINNET],
+    rpcUrl: "https://mainnet.hashio.io/api",
+    addresses: {
+      assetManager: "0x0df73542cC68bDC01b361d231c60F726B0e0bC05",
+      connection: "0x4555aC13D7338D9E671584C1D118c06B2a3C88eD"
+    },
+    nativeToken: "0x0000000000000000000000000000000000000000",
+    bnUSD: "0x0000000000000000000000000000000000a0286a",
+    supportedTokens: hederaSupportedTokens,
+    pollingConfig: {
+      pollingIntervalMs: 2e3,
+      maxTimeoutMs: 6e4
+    }
   }
 };
 var supportedSpokeChains = Object.keys(spokeChainConfig);
@@ -3571,6 +3659,11 @@ var moneyMarketSupportedTokens = {
   ],
   [ChainKeys.BITCOIN_MAINNET]: [
     spokeChainConfig[ChainKeys.BITCOIN_MAINNET].supportedTokens.BTC
+  ],
+  [ChainKeys.HEDERA_MAINNET]: [
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.bnUSD,
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SODA,
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.USDC
   ]
 };
 var moneyMarketReserveAssets = [
@@ -3980,7 +4073,9 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.STACKS_MAINNET].supportedTokens.SODA,
     spokeChainConfig[ChainKeys.STACKS_MAINNET].supportedTokens.sBTC,
     spokeChainConfig[ChainKeys.STACKS_MAINNET].supportedTokens.USDC
-  ]
+  ],
+  // Hedera is currently staging-only — see stagingSwapSupportedTokens
+  [ChainKeys.HEDERA_MAINNET]: []
 };
 var stagingSwapSupportedTokens = {
   [ChainKeys.SONIC_MAINNET]: [SodaTokens.sodaUSDS],
@@ -4013,7 +4108,13 @@ var stagingSwapSupportedTokens = {
   ],
   [ChainKeys.REDBELLY_MAINNET]: [],
   [ChainKeys.KAIA_MAINNET]: [],
-  [ChainKeys.STACKS_MAINNET]: []
+  [ChainKeys.STACKS_MAINNET]: [],
+  [ChainKeys.HEDERA_MAINNET]: [
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.HBAR,
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.bnUSD,
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.USDC,
+    spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SODA
+  ]
 };
 var swapsConfig = {
   supportedTokens: swapSupportedTokens
@@ -4249,7 +4350,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 217;
+var CONFIG_VERSION = 218;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -4376,11 +4477,11 @@ async function retry(action, retryCount = DEFAULT_MAX_RETRY, delayMs = DEFAULT_R
   throw new Error(`Retry exceeded MAX_RETRY_DEFAULT=${DEFAULT_MAX_RETRY}`);
 }
 function getRandomBytes(length) {
-  const array3 = new Uint8Array(length);
+  const array2 = new Uint8Array(length);
   for (let i = 0; i < length; i++) {
-    array3[i] = Math.floor(Math.random() * 256);
+    array2[i] = Math.floor(Math.random() * 256);
   }
-  return array3;
+  return array2;
 }
 function randomUint256() {
   const bytes = getRandomBytes(32);
@@ -4739,8 +4840,61 @@ function isCodeMember(codes) {
 }
 
 // src/errors/wrappers.ts
-function messageOf(error, fallback) {
-  return error instanceof Error ? error.message : fallback;
+function messageOf(error, fallback2) {
+  return error instanceof Error ? error.message : fallback2;
+}
+var REJECTION_TEXT_PATTERNS = [
+  /user rejected/i,
+  /user denied/i,
+  /user declined/i,
+  /user cancel(?:l)?ed/i,
+  /user abort(?:ed)?/i,
+  /user closed/i,
+  /rejected by user/i,
+  /cancelled by user/i,
+  /canceled by user/i,
+  // `was` is mandatory: matches Phantom / Brave's "Transaction was rejected" (user cancellation)
+  // but NOT bare "Transaction rejected by node / by validator" (network or chain-level reject).
+  /transaction was rejected/i,
+  /signature rejected/i,
+  /request rejected/i,
+  /cancel_signing/i,
+  /cancel_json-rpc/i,
+  /popup ?closed/i
+];
+function matchRejectionText(text) {
+  if (typeof text !== "string" || text.length === 0) return false;
+  for (const pattern of REJECTION_TEXT_PATTERNS) {
+    if (pattern.test(text)) return true;
+  }
+  return false;
+}
+function isWalletRejection(error) {
+  if (error == null) return false;
+  if (isSodaxError(error)) return error.code === "USER_REJECTED";
+  if (typeof error === "string") return matchRejectionText(error);
+  if (typeof error !== "object") return false;
+  const o = error;
+  if (o.name === "UserRejectedRequestError") return true;
+  if (o.name === "WalletSignTransactionError" && matchRejectionText(o.message)) return true;
+  if (o.name === "WalletConnectionError" && matchRejectionText(o.message)) return true;
+  if (o.code === 4001) return true;
+  if (o.code === "ACTION_REJECTED") return true;
+  if (o.code === "CANCEL_SIGNING") return true;
+  if (o.code === "CANCEL_JSON-RPC") return true;
+  if (o.code === -31002) return true;
+  if (matchRejectionText(o.shortMessage)) return true;
+  if (matchRejectionText(o.details)) return true;
+  if (matchRejectionText(o.message)) return true;
+  if (matchRejectionText(o.reason)) return true;
+  return false;
+}
+function userRejected(feature, cause, context) {
+  return new SodaxError("USER_REJECTED", "User rejected the request", {
+    feature,
+    cause,
+    context
+  });
 }
 function lookupFailed(feature, method, cause, context) {
   return new SodaxError("LOOKUP_FAILED", messageOf(cause, `${method} failed`), {
@@ -4757,6 +4911,7 @@ function verifyFailed(feature, cause, context) {
   });
 }
 function intentCreationFailed(feature, cause, context) {
+  if (isWalletRejection(cause)) return userRejected(feature, cause, { phase: "intentCreation", ...context });
   return new SodaxError("INTENT_CREATION_FAILED", messageOf(cause, "Intent creation failed"), {
     feature,
     cause,
@@ -4771,6 +4926,7 @@ function executionFailed(feature, cause, context) {
   });
 }
 function approveFailed(feature, cause, context) {
+  if (isWalletRejection(cause)) return userRejected(feature, cause, { phase: "approve", ...context });
   return new SodaxError("APPROVE_FAILED", messageOf(cause, "Approve failed"), {
     feature,
     cause,
@@ -14055,7 +14211,7 @@ function mergeSodaxConfig(base2, override) {
 }
 function encodeContractCalls(calls) {
   return viem.encodeAbiParameters(viem.parseAbiParameters("(address,uint256,bytes)[]"), [
-    calls.map((v6) => [v6.address, v6.value, v6.data])
+    calls.map((v4) => [v4.address, v4.value, v4.data])
   ]);
 }
 async function waitForTransactionReceipt(hash, provider) {
@@ -14139,6 +14295,8 @@ function getEvmViemChain(key) {
       return chains.redbellyMainnet;
     case ChainKeys.KAIA_MAINNET:
       return chains.kaia;
+    case ChainKeys.HEDERA_MAINNET:
+      return chains.hedera;
     default: {
       const exhaustiveCheck = key;
       console.log(exhaustiveCheck);
@@ -14153,7 +14311,7 @@ var EvmVaultTokenService = class {
    * Fetches token information for a specific token in the vault.
    * @param vault - The address of the vault.
    * @param token - The address of the token.
-   * @param publicClient - PublicClient<HttpTransport>
+   * @param publicClient - PublicClient
    * @returns Token information as a TokenInfo object.
    */
   static async getTokenInfo(vault, token, publicClient) {
@@ -14192,7 +14350,7 @@ var EvmVaultTokenService = class {
   /**
    * Retrieves the reserves of the vault.
    * @param vault - The address of the vault.
-   * @param publicClient - PublicClient<HttpTransport>
+   * @param publicClient - PublicClient
    * @returns An object containing tokens and their balances.
    */
   static async getVaultReserves(vault, publicClient) {
@@ -14210,7 +14368,7 @@ var EvmVaultTokenService = class {
   /**
    * Retrieves all token information for the vault.
    * @param vault - The address of the vault.
-   * @param publicClient - PublicClient<HttpTransport>
+   * @param publicClient - PublicClient
    * @returns A promise that resolves to an object containing tokens, their infos, and reserves.
    */
   static async getAllTokenInfo(vault, publicClient) {
@@ -14570,6 +14728,10 @@ var EvmAssetManagerService = class _EvmAssetManagerService {
     });
   }
 };
+var HEDERA_NATIVE_VALUE_SCALE = 10n ** 10n;
+function scaleNativeMsgValue(chainKey, amount) {
+  return chainKey === ChainKeys.HEDERA_MAINNET ? amount * HEDERA_NATIVE_VALUE_SCALE : amount;
+}
 var EvmSpokeService = class {
   config;
   // map containing the public clients for each evm spoke chain, lazy loaded on demand
@@ -14657,10 +14819,11 @@ var EvmSpokeService = class {
   async deposit(params) {
     const { srcChainKey, srcAddress: from, token, to, amount, data = "0x" } = params;
     const chainConfig = this.config.getChainConfig(srcChainKey);
+    const isNative = token.toLowerCase() === chainConfig.nativeToken.toLowerCase();
     const rawTx = {
       from,
       to: chainConfig.addresses.assetManager,
-      value: token.toLowerCase() === chainConfig.nativeToken.toLowerCase() ? amount : 0n,
+      value: isNative ? scaleNativeMsgValue(srcChainKey, amount) : 0n,
       data: viem.encodeFunctionData({
         abi: spokeAssetManagerAbi,
         functionName: "transfer",
@@ -14949,8 +15112,8 @@ var RadfiApiError = class extends Error {
   code;
   details;
   cause;
-  constructor(status, body, fallback) {
-    super(body?.message || fallback);
+  constructor(status, body, fallback2) {
+    super(body?.message || fallback2);
     this.name = "RadfiApiError";
     this.status = status;
     this.code = body?.code;
@@ -15318,7 +15481,7 @@ var RadfiProvider = class {
    * body as text first and parsing it ourselves lets us raise a `RadfiApiError` carrying the
    * actual status code and a body snippet instead.
    */
-  async parseJsonBody(res, fallback) {
+  async parseJsonBody(res, fallback2) {
     const text = await res.text();
     try {
       return text.length ? JSON.parse(text) : {};
@@ -15327,7 +15490,7 @@ var RadfiProvider = class {
       throw new RadfiApiError(
         res.status,
         { message: `Bound Exchange returned a non-JSON response (HTTP ${res.status})${snippet ? `: ${snippet}` : ""}` },
-        fallback
+        fallback2
       );
     }
   }
@@ -16031,7 +16194,7 @@ function hexToBytes2(hex) {
   const al = hl / 2;
   if (hl % 2)
     throw new Error("hex string expected, got unpadded hex of length " + hl);
-  const array3 = new Uint8Array(al);
+  const array2 = new Uint8Array(al);
   for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
     const n1 = asciiToBase16(hex.charCodeAt(hi));
     const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
@@ -16039,9 +16202,9 @@ function hexToBytes2(hex) {
       const char = hex[hi] + hex[hi + 1];
       throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
     }
-    array3[ai] = n1 * 16 + n2;
+    array2[ai] = n1 * 16 + n2;
   }
-  return array3;
+  return array2;
 }
 function concatBytes(...arrays) {
   let sum = 0;
@@ -16671,22 +16834,22 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   const byte0 = Uint8Array.of(0);
   const byte1 = Uint8Array.of(1);
   const _maxDrbgIters = 1e3;
-  let v6 = u8n(hashLen);
+  let v4 = u8n(hashLen);
   let k = u8n(hashLen);
   let i = 0;
   const reset = () => {
-    v6.fill(1);
+    v4.fill(1);
     k.fill(0);
     i = 0;
   };
-  const h = (...msgs) => hmacFn(k, concatBytes(v6, ...msgs));
+  const h = (...msgs) => hmacFn(k, concatBytes(v4, ...msgs));
   const reseed = (seed = NULL) => {
     k = h(byte0, seed);
-    v6 = h();
+    v4 = h();
     if (seed.length === 0)
       return;
     k = h(byte1, seed);
-    v6 = h();
+    v4 = h();
   };
   const gen = () => {
     if (i++ >= _maxDrbgIters)
@@ -16694,10 +16857,10 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     let len = 0;
     const out = [];
     while (len < qByteLen) {
-      v6 = h();
-      const sl = v6.slice();
+      v4 = h();
+      const sl = v4.slice();
       out.push(sl);
-      len += v6.length;
+      len += v4.length;
     }
     return concatBytes(...out);
   };
@@ -16712,18 +16875,18 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object4, fields = {}, optFields = {}) {
-  if (!object4 || typeof object4 !== "object")
+function validateObject(object2, fields = {}, optFields = {}) {
+  if (!object2 || typeof object2 !== "object")
     throw new Error("expected valid options object");
   function checkField(fieldName, expectedType, isOpt) {
-    const val = object4[fieldName];
+    const val = object2[fieldName];
     if (isOpt && val === void 0)
       return;
     const current = typeof val;
     if (current !== expectedType || val === null)
       throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
   }
-  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v6]) => checkField(k, v6, isOpt));
+  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v4]) => checkField(k, v4, isOpt));
   iter(fields, false);
   iter(optFields, true);
 }
@@ -16762,12 +16925,12 @@ function pow2(x, power, modulo) {
   }
   return res;
 }
-function invert(number4, modulo) {
-  if (number4 === _0n2)
+function invert(number2, modulo) {
+  if (number2 === _0n2)
     throw new Error("invert: expected non-zero number");
   if (modulo <= _0n2)
     throw new Error("invert: expected positive modulus, got " + modulo);
-  let a = mod(number4, modulo);
+  let a = mod(number2, modulo);
   let b = modulo;
   let x = _0n2, u = _1n2;
   while (a !== _0n2) {
@@ -16794,9 +16957,9 @@ function sqrt3mod4(Fp, n) {
 function sqrt5mod8(Fp, n) {
   const p5div8 = (Fp.ORDER - _5n) / _8n;
   const n2 = Fp.mul(n, _2n);
-  const v6 = Fp.pow(n2, p5div8);
-  const nv = Fp.mul(n, v6);
-  const i = Fp.mul(Fp.mul(nv, _2n), v6);
+  const v4 = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v4);
+  const i = Fp.mul(Fp.mul(nv, _2n), v4);
   const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
   assertIsSquare(Fp, root, n);
   return root;
@@ -17271,27 +17434,27 @@ var wNAF = class {
     assert0(n);
     return acc;
   }
-  getPrecomputes(W, point, transform2) {
+  getPrecomputes(W, point, transform) {
     let comp = pointPrecomputes.get(point);
     if (!comp) {
       comp = this.precomputeWindow(point, W);
       if (W !== 1) {
-        if (typeof transform2 === "function")
-          comp = transform2(comp);
+        if (typeof transform === "function")
+          comp = transform(comp);
         pointPrecomputes.set(point, comp);
       }
     }
     return comp;
   }
-  cached(point, scalar, transform2) {
+  cached(point, scalar, transform) {
     const W = getW(point);
-    return this.wNAF(W, this.getPrecomputes(W, point, transform2), scalar);
+    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
   }
-  unsafe(point, scalar, transform2, prev) {
+  unsafe(point, scalar, transform, prev) {
     const W = getW(point);
     if (W === 1)
       return this._unsafeLadder(point, scalar, prev);
-    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform2), scalar, prev);
+    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
   }
   // We calculate precomputes for elliptic curve point multiplication
   // using windowed method. This specifies window size and
@@ -17378,9 +17541,9 @@ function edwards(params, extraOpts = {}) {
   validateObject(extraOpts, {}, { uvRatio: "function" });
   const MASK = _2n2 << BigInt(Fn.BYTES * 8) - _1n4;
   const modP = (n) => Fp.create(n);
-  const uvRatio2 = extraOpts.uvRatio || ((u, v6) => {
+  const uvRatio2 = extraOpts.uvRatio || ((u, v4) => {
     try {
-      return { isValid: true, value: Fp.sqrt(Fp.div(u, v6)) };
+      return { isValid: true, value: Fp.sqrt(Fp.div(u, v4)) };
     } catch (e) {
       return { isValid: false, value: _0n4 };
     }
@@ -17476,8 +17639,8 @@ function edwards(params, extraOpts = {}) {
       aInRange("point.y", y, _0n4, max);
       const y2 = modP(y * y);
       const u = modP(y2 - _1n4);
-      const v6 = modP(d * y2 - a);
-      let { isValid, value: x } = uvRatio2(u, v6);
+      const v4 = modP(d * y2 - a);
+      let { isValid, value: x } = uvRatio2(u, v4);
       if (!isValid)
         throw new Error("bad point: invalid y coordinate");
       const isXOdd = (x & _1n4) === _1n4;
@@ -17817,13 +17980,13 @@ function adjustScalarBytes(bytes) {
   return bytes;
 }
 var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
-function uvRatio(u, v6) {
+function uvRatio(u, v4) {
   const P = ed25519_CURVE_p;
-  const v32 = mod(v6 * v6 * v6, P);
-  const v7 = mod(v32 * v32 * v6, P);
+  const v32 = mod(v4 * v4 * v4, P);
+  const v7 = mod(v32 * v32 * v4, P);
   const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
   let x = mod(u * v32 * pow, P);
-  const vx2 = mod(v6 * x * x, P);
+  const vx2 = mod(v4 * x * x, P);
   const root1 = x;
   const root2 = mod(x * ED25519_SQRT_M1, P);
   const useRoot1 = vx2 === u;
@@ -18154,7 +18317,7 @@ function findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio, protocol
   return findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumStakeRatio);
 }
 function findSeatPriceForProtocolBefore49(validators, numSeats) {
-  const stakes = validators.map((v6) => BigInt(v6.stake)).sort(sortBigIntAsc);
+  const stakes = validators.map((v4) => BigInt(v4.stake)).sort(sortBigIntAsc);
   const num = BigInt(numSeats);
   const stakesSum = stakes.reduce((a, b) => a + b);
   if (stakesSum < num) {
@@ -18183,7 +18346,7 @@ function findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumSt
   if (minimumStakeRatio.length != 2) {
     throw Error("minimumStakeRatio should have 2 elements");
   }
-  const stakes = validators.map((v6) => BigInt(v6.stake)).sort(sortBigIntAsc);
+  const stakes = validators.map((v4) => BigInt(v4.stake)).sort(sortBigIntAsc);
   const stakesSum = stakes.reduce((a, b) => a + b);
   if (validators.length < maxNumberOfSeats) {
     return stakesSum * BigInt(minimumStakeRatio[0]) / BigInt(minimumStakeRatio[1]);
@@ -18355,10 +18518,10 @@ var DER = {
         if (length < 128)
           throw new E("tlv.decode(long): not minimal encoding");
       }
-      const v6 = data.subarray(pos, pos + length);
-      if (v6.length !== length)
+      const v4 = data.subarray(pos, pos + length);
+      if (v4.length !== length)
         throw new E("tlv.decode: wrong value length");
-      return { v: v6, l: data.subarray(pos + length) };
+      return { v: v4, l: data.subarray(pos + length) };
     }
   },
   // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
@@ -18926,9 +19089,9 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     extraEntropy: false
   };
   const hasLargeCofactor = CURVE_ORDER * _2n4 < Fp.ORDER;
-  function isBiggerThanHalfOrder(number4) {
+  function isBiggerThanHalfOrder(number2) {
     const HALF = CURVE_ORDER >> _1n6;
-    return number4 > HALF;
+    return number2 > HALF;
   }
   function validateRS(title, num) {
     if (!Fn.isValidNot0(num))
@@ -19111,8 +19274,8 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
       const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
       if (R.is0())
         return false;
-      const v6 = Fn.create(R.x);
-      return v6 === r;
+      const v4 = Fn.create(R.x);
+      return v4 === r;
     } catch (e) {
       return false;
     }
@@ -22108,6 +22271,15 @@ var NearSpokeService = class {
     };
   }
 };
+function buildEvmRpcTransport(cfg) {
+  const configured = (cfg.rpcUrls ?? []).map((url) => url.trim()).filter((url) => url.length > 0);
+  const urls = [...new Set(configured.length > 0 ? configured : [cfg.rpcUrl])];
+  const rpcOptions = cfg.rpcOptions?.rank && urls.length < 2 ? { ...cfg.rpcOptions, rank: false } : cfg.rpcOptions;
+  return viem.fallback(
+    urls.map((url) => viem.http(url)),
+    rpcOptions
+  );
+}
 
 // src/shared/types/intent-types.ts
 var IntentDataType = /* @__PURE__ */ ((IntentDataType2) => {
@@ -22570,7 +22742,7 @@ var SonicSpokeService = class {
     this.config = config;
     const chainConfig = config.getChainConfig(ChainKeys.SONIC_MAINNET);
     this.publicClient = viem.createPublicClient({
-      transport: viem.http(chainConfig.rpcUrl),
+      transport: buildEvmRpcTransport(chainConfig),
       chain: getEvmViemChain(ChainKeys.SONIC_MAINNET)
     });
     this.pollingIntervalMs = chainConfig.pollingConfig.pollingIntervalMs;
@@ -26169,7 +26341,7 @@ var EvmHubProvider = class {
   hubAddressMap = /* @__PURE__ */ new Map();
   constructor({ config }) {
     this.publicClient = viem.createPublicClient({
-      transport: viem.http(config.sodaxConfig.hub.rpcUrl),
+      transport: buildEvmRpcTransport(config.sodaxConfig.hub),
       chain: getEvmViemChain(config.sodaxConfig.hub.chain.key)
     });
     this.chainConfig = config.sodaxConfig.hub;
@@ -26434,6 +26606,7 @@ var POST_EXECUTION_ERROR_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var SWAP_ERROR_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -26760,7 +26933,7 @@ var SwapService = class {
   /**
    * Backend 2-step swap path (opt-in via `swapsOptions.useBackendSubmitTx`): hand the broadcast
    * intent tx to the swaps API (`POST /swaps/submit-tx`); the backend relays + post-executes
-   * server-side. Polls `getSubmitTxStatus` until `executed`, then reconstructs the same
+   * server-side. Polls `getSubmitTxStatus` until `solved`, then reconstructs the same
    * {@link SwapResponse} the client-side path returns (`result.dstIntentTxHash` → delivery info,
    * `result.intent_hash` → solver response).
    *
@@ -26797,7 +26970,7 @@ var SwapService = class {
         const statusResult = await this.backendApi.swaps.getSubmitTxStatus({ txHash: spokeTxHash, srcChainKey });
         if (statusResult.ok) {
           const { status, result, failureReason, abandonedAt } = statusResult.value.data;
-          if (status === "executed" && result?.dstIntentTxHash && result.intent_hash) {
+          if (status === "solved" && result?.dstIntentTxHash && result.intent_hash) {
             return {
               ok: true,
               value: {
@@ -26822,7 +26995,7 @@ var SwapService = class {
         }
         await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
       }
-      return submitTxFailed(new Error("backend submit-tx polling timed out before reaching executed"));
+      return submitTxFailed(new Error("backend submit-tx polling timed out before reaching solved"));
     } catch (error) {
       return { ok: false, error: unknownFailed("swap", error, { ...baseCtx, action: "swap" }) };
     }
@@ -26893,6 +27066,7 @@ var SwapService = class {
    */
   async approve(_params) {
     const { params } = _params;
+    const wrapApproveFailure = (cause) => approveFailed("swap", cause);
     try {
       if (isHubChainKeyType(params.srcChainKey) || isEvmSpokeOnlyChainKeyType(params.srcChainKey)) {
         invariant(
@@ -26913,7 +27087,7 @@ var SwapService = class {
           walletProvider: _params.walletProvider
         });
         if (!result.ok) {
-          return result;
+          return { ok: false, error: wrapApproveFailure(result.error) };
         }
         return {
           ok: true,
@@ -26941,7 +27115,7 @@ var SwapService = class {
             walletProvider: _params.walletProvider
           }
         );
-        if (!result.ok) return result;
+        if (!result.ok) return { ok: false, error: wrapApproveFailure(result.error) };
         return {
           ok: true,
           value: result.value
@@ -27234,13 +27408,14 @@ var SwapService = class {
         walletProvider: _params.walletProvider
       };
       const txResult = await this.spoke.sendMessage(sendMessageParams);
-      if (!txResult.ok) return txResult;
+      if (!txResult.ok) return { ok: false, error: intentCreationFailed("swap", txResult.error) };
       return {
         ok: true,
         value: txResult.value
       };
     } catch (error) {
-      return { ok: false, error };
+      if (isSwapCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("swap", error) };
     }
   }
   /**
@@ -27294,7 +27469,8 @@ var SwapService = class {
       }
       return { ok: true, value: { srcChainTxHash: cancelTxHash, dstChainTxHash: dstIntentTxHash } };
     } catch (error) {
-      return { ok: false, error };
+      if (isSwapError(error)) return { ok: false, error };
+      return { ok: false, error: executionFailed("swap", error, { action: "cancelIntent" }) };
     }
   }
   /**
@@ -27479,6 +27655,7 @@ var SwapService = class {
 // src/migration/errors.ts
 var migrationInvariant = createInvariant("migration");
 var MIGRATE_ORCH_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -27489,6 +27666,7 @@ var MIGRATE_ORCH_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var REVERT_ORCH_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_SUBMIT_FAILED",
@@ -27498,6 +27676,7 @@ var REVERT_ORCH_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var MIGRATION_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -29550,7 +29729,6 @@ var MigrationService = class {
 };
 
 // src/backendApi/api-utils.ts
-var toJsonBody = (value) => JSON.stringify(value, (_key, val) => typeof val === "bigint" ? val.toString() : val);
 async function makeRequest(params) {
   const { endpoint, config, overrideConfig = {}, logger, serviceLabel } = params;
   const baseURL = overrideConfig.baseURL || config.baseURL || "";
@@ -29586,227 +29764,7 @@ async function makeRequest(params) {
     throw new Error("UNKNOWN_REQUEST_ERROR", { cause: error });
   }
 }
-var SwapTokenSchema = v4__namespace.object({
-  symbol: v4__namespace.string(),
-  name: v4__namespace.string(),
-  decimals: v4__namespace.number(),
-  address: v4__namespace.string(),
-  chainKey: v4__namespace.string(),
-  hubAsset: v4__namespace.string(),
-  vault: v4__namespace.string()
-});
-var IntentResponseSchema = v4__namespace.object({
-  intentId: v4__namespace.string(),
-  creator: v4__namespace.string(),
-  inputToken: v4__namespace.string(),
-  outputToken: v4__namespace.string(),
-  inputAmount: v4__namespace.string(),
-  minOutputAmount: v4__namespace.string(),
-  deadline: v4__namespace.string(),
-  allowPartialFill: v4__namespace.boolean(),
-  srcChain: v4__namespace.string(),
-  dstChain: v4__namespace.string(),
-  srcAddress: v4__namespace.string(),
-  dstAddress: v4__namespace.string(),
-  solver: v4__namespace.string(),
-  data: v4__namespace.string()
-});
-var RelayExtraDataResponseSchema = v4__namespace.object({
-  address: v4__namespace.string(),
-  payload: v4__namespace.string()
-});
-var makeCreateIntentResponseSchema = (txSchema) => v4__namespace.object({
-  tx: txSchema,
-  intent: IntentResponseSchema,
-  relayData: RelayExtraDataResponseSchema
-});
-var GetSwapTokensResponseSchema = v4__namespace.record(v4__namespace.string(), v4__namespace.array(SwapTokenSchema));
-var GetSwapTokensByChainResponseSchema = v4__namespace.array(SwapTokenSchema);
-var makeQuoteResponseSchema = (txSchema) => v4__namespace.object({
-  quotedAmount: v4__namespace.string(),
-  txData: v4__namespace.optional(makeCreateIntentResponseSchema(txSchema))
-});
-var DeadlineResponseSchema = v4__namespace.object({
-  deadline: v4__namespace.string()
-});
-var AllowanceCheckResponseSchema = v4__namespace.object({
-  valid: v4__namespace.boolean()
-});
-var makeApproveResponseSchema = (txSchema) => v4__namespace.object({ tx: txSchema });
-var SubmitIntentResponseSchema = v4__namespace.object({
-  result: v4__namespace.unknown()
-});
-var StatusResponseSchema = v4__namespace.object({
-  status: v4__namespace.picklist([-1, 1, 2, 3, 4]),
-  fillTxHash: v4__namespace.optional(v4__namespace.string())
-});
-var makeCancelIntentResponseSchema = (txSchema) => v4__namespace.object({ tx: txSchema });
-var IntentHashResponseSchema = v4__namespace.object({
-  hash: v4__namespace.string()
-});
-var IntentPacketResponseSchema = v4__namespace.object({
-  srcChainId: v4__namespace.number(),
-  srcTxHash: v4__namespace.string(),
-  srcAddress: v4__namespace.string(),
-  status: v4__namespace.string(),
-  dstChainId: v4__namespace.number(),
-  connSn: v4__namespace.number(),
-  dstAddress: v4__namespace.string(),
-  dstTxHash: v4__namespace.string(),
-  signatures: v4__namespace.array(v4__namespace.string()),
-  payload: v4__namespace.string()
-});
-var IntentStateResponseSchema = v4__namespace.object({
-  exists: v4__namespace.boolean(),
-  remainingInput: v4__namespace.string(),
-  receivedOutput: v4__namespace.string(),
-  pendingPayment: v4__namespace.boolean()
-});
-var GasEstimateResponseSchema = v4__namespace.object({
-  gas: v4__namespace.unknown()
-});
-var FeeResponseSchema = v4__namespace.object({
-  fee: v4__namespace.string()
-});
-var SubmitTxResponseSchema = v4__namespace.object({
-  success: v4__namespace.boolean(),
-  data: v4__namespace.object({
-    status: v4__namespace.picklist(["inserted", "duplicate"]),
-    message: v4__namespace.string()
-  })
-});
-var SubmitSwapTxStatusSchema = v4__namespace.picklist([
-  "pending",
-  "relaying",
-  "relayed",
-  "posting_execution",
-  "executed",
-  "failed"
-]);
-var PacketDataSchema = v4__namespace.object({
-  src_chain_id: v4__namespace.number(),
-  src_tx_hash: v4__namespace.string(),
-  src_address: v4__namespace.string(),
-  status: v4__namespace.picklist(["pending", "validating", "executing", "executed"]),
-  dst_chain_id: v4__namespace.number(),
-  conn_sn: v4__namespace.number(),
-  dst_address: v4__namespace.string(),
-  dst_tx_hash: v4__namespace.string(),
-  signatures: v4__namespace.array(v4__namespace.string()),
-  payload: v4__namespace.string()
-});
-var SubmitTxStatusResultSchema = v4__namespace.object({
-  dstIntentTxHash: v4__namespace.string(),
-  packetData: v4__namespace.optional(PacketDataSchema),
-  intent_hash: v4__namespace.optional(v4__namespace.string())
-});
-var SubmitTxStatusDataSchema = v4__namespace.object({
-  txHash: v4__namespace.string(),
-  srcChainKey: v4__namespace.string(),
-  status: SubmitSwapTxStatusSchema,
-  failedAtStep: v4__namespace.optional(SubmitSwapTxStatusSchema),
-  failureReason: v4__namespace.optional(v4__namespace.string()),
-  processingAttempts: v4__namespace.number(),
-  abandonedAt: v4__namespace.optional(v4__namespace.string()),
-  result: v4__namespace.optional(SubmitTxStatusResultSchema),
-  userMessage: v4__namespace.optional(v4__namespace.string()),
-  intentCancelled: v4__namespace.optional(v4__namespace.boolean())
-});
-var SubmitTxStatusResponseSchema = v4__namespace.object({
-  success: v4__namespace.boolean(),
-  data: SubmitTxStatusDataSchema
-});
-var AddressSchema = v4__namespace.custom((input) => typeof input === "string");
-var HexSchema = v4__namespace.custom((input) => typeof input === "string");
-var BigintFromString = v4__namespace.pipe(v4__namespace.string(), v4__namespace.toBigint());
-var BytesFromIndexRecord = v4__namespace.pipe(
-  v4__namespace.record(v4__namespace.string(), v4__namespace.number()),
-  v4__namespace.transform((indexed) => Uint8Array.from(Object.values(indexed)))
-);
-var EvmRawTxSchema = v4__namespace.object({
-  from: AddressSchema,
-  to: AddressSchema,
-  value: BigintFromString,
-  data: HexSchema
-});
-var SolanaRawTxSchema = v4__namespace.object({
-  from: v4__namespace.string(),
-  to: v4__namespace.string(),
-  value: BigintFromString,
-  data: v4__namespace.string()
-});
-var SuiRawTxSchema = v4__namespace.object({
-  from: HexSchema,
-  to: v4__namespace.string(),
-  value: BigintFromString,
-  data: v4__namespace.string()
-});
-var StellarRawTxSchema = v4__namespace.object({
-  from: v4__namespace.string(),
-  to: v4__namespace.string(),
-  value: BigintFromString,
-  data: v4__namespace.string()
-});
-var InjectiveRawTxSchema = v4__namespace.object({
-  from: HexSchema,
-  to: HexSchema,
-  signedDoc: v4__namespace.object({
-    bodyBytes: BytesFromIndexRecord,
-    authInfoBytes: BytesFromIndexRecord,
-    chainId: v4__namespace.string(),
-    accountNumber: BigintFromString
-  })
-});
-var NearRawTxSchema = v4__namespace.object({
-  signerId: v4__namespace.string(),
-  params: v4__namespace.object({
-    contractId: v4__namespace.string(),
-    method: v4__namespace.string(),
-    args: v4__namespace.custom((input) => typeof input === "object" && input !== null),
-    gas: v4__namespace.optional(BigintFromString),
-    deposit: v4__namespace.optional(BigintFromString)
-  })
-});
-var IconRawTxSchema = v4__namespace.record(
-  v4__namespace.string(),
-  v4__namespace.union([v4__namespace.string(), v4__namespace.custom((input) => typeof input === "object" && input !== null)])
-);
-var StacksRawTxSchema = v4__namespace.object({
-  payload: v4__namespace.string(),
-  estimatedLength: v4__namespace.optional(v4__namespace.number())
-});
-var AnyRawTxSchema = v4__namespace.custom((input) => typeof input === "object" && input !== null);
-function rawTxSchemaForChainKey(chainKey) {
-  let chainType;
-  try {
-    chainType = getChainType(chainKey);
-  } catch {
-    chainType = void 0;
-  }
-  switch (chainType) {
-    case "EVM":
-      return EvmRawTxSchema;
-    case "SOLANA":
-      return SolanaRawTxSchema;
-    case "SUI":
-      return SuiRawTxSchema;
-    case "STELLAR":
-      return StellarRawTxSchema;
-    case "INJECTIVE":
-      return InjectiveRawTxSchema;
-    case "ICON":
-      return IconRawTxSchema;
-    case "STACKS":
-      return StacksRawTxSchema;
-    case "NEAR":
-      return NearRawTxSchema;
-    default:
-      return AnyRawTxSchema;
-  }
-}
-
-// src/backendApi/SwapsApiService.ts
-var SwapsApiService = class {
+var SwapsApiService = class _SwapsApiService {
   // Fully-resolved swaps-API config supplied by the caller (BackendApiService resolves the
   // `ApiConfig` union via `resolveSwapsApiConfig`); this service does not resolve the union.
   config;
@@ -29818,347 +29776,189 @@ var SwapsApiService = class {
     this.logger = logger;
   }
   /**
-   * Issues a single HTTP request, validates the JSON body against `schema`, and
-   * wraps the result in `Result<T>`. The service-level `baseURL`/`timeout`/
-   * `headers` are merged with the optional per-call `overrideConfig` (which takes
-   * precedence) inside {@link makeRequest}. Every public method delegates here.
+   * Build a `@sodax/swaps-api` client for a single call. Maps the SDK's `SwapsApiConfig`
+   * (`baseURL`/`timeout`/`headers`) to the package's config (`baseUrl`/`timeout`/`headers`), layering
+   * the optional per-call `RequestOverrideConfig` on top (override wins per field; headers merge).
+   * `timeout` falls back to the backend-API default so a config that omits it still gets a ceiling
+   * rather than an unbounded request. Constructed per call so `setHeaders` mutations and per-call
+   * overrides both take effect without caching stale state.
    */
-  async request(endpoint, config, schema, overrideConfig) {
+  buildClient(overrideConfig) {
+    const baseUrl = overrideConfig?.baseURL || this.config.baseURL;
+    const timeout = overrideConfig?.timeout ?? this.config.timeout ?? DEFAULT_BACKEND_API_TIMEOUT;
+    const headers = { ...this.headers, ...overrideConfig?.headers };
+    return new swapsApi.SwapsApi({ baseUrl, headers, timeout });
+  }
+  /**
+   * Run one delegated `SwapsApi` call and wrap it in `Result<T>`. A thrown `SwapsApiError`
+   * (network/timeout/HTTP/parse/validation) becomes `{ ok: false }` with a canonical
+   * `SodaxError<'EXTERNAL_API_ERROR'>`; the original error is kept as `cause`, and its
+   * `code`/`status`/`issues` are projected into `context` so consumers can discriminate failure
+   * kinds without unwrapping `cause`. Only a RESPONSE-shape validation failure is tagged
+   * `reason: 'invalid_response_shape'` — a request-side validation error is a caller bug, not a
+   * backend fault.
+   */
+  async toResult(endpoint, call, overrideConfig) {
     try {
-      const raw = await makeRequest({
-        endpoint,
-        config: { baseURL: this.config.baseURL, timeout: this.config.timeout, headers: this.headers, ...config },
-        overrideConfig,
-        logger: this.logger,
-        serviceLabel: "SwapsApiService"
-      });
-      const parsed = v4__namespace.safeParse(schema, raw);
-      if (!parsed.success) {
-        return {
-          ok: false,
-          error: new SodaxError("EXTERNAL_API_ERROR", `Invalid response shape from swaps API for ${endpoint}`, {
-            feature: "backend",
-            context: { api: "swaps", endpoint, reason: "invalid_response_shape", issues: v4__namespace.flatten(parsed.issues) }
-          })
-        };
-      }
-      return { ok: true, value: parsed.output };
+      const value = await call(this.buildClient(overrideConfig));
+      return { ok: true, value };
     } catch (error) {
+      const context = { api: "swaps", endpoint };
+      if (error instanceof swapsApi.SwapsApiError) {
+        context.code = error.code;
+        if (error.code === "VALIDATION_ERROR" && error.context.issues !== void 0) {
+          context.reason = "invalid_response_shape";
+          const issues = error.context.issues;
+          context.issues = issues instanceof v2__namespace.ValiError ? v2__namespace.flatten(issues.issues) : issues;
+        }
+        if (error.context.status !== void 0) context.status = error.context.status;
+      }
+      this.logger.error(`[SwapsApiService] Request to ${endpoint} failed`, error);
       return {
         ok: false,
         error: new SodaxError(
           "EXTERNAL_API_ERROR",
           error instanceof Error ? error.message : `Request to ${endpoint} failed`,
-          {
-            feature: "backend",
-            cause: error,
-            context: { api: "swaps", endpoint }
-          }
+          { feature: "backend", cause: error, context }
         )
       };
     }
   }
+  /**
+   * Drop the SDK-only display field `feeAmount` before an intent reaches the strict wire serializer.
+   * `sodax.swaps.createIntent` returns `Intent & FeeAmount`, which is structurally assignable to the
+   * wire `IntentRequestV2` and so gets passed straight into the intent-carrying endpoints; the extra
+   * bigint would trip `serializeIntentRequest`. This is a no-op for an already-clean `IntentRequestV2`.
+   */
+  static toWireIntent(intent) {
+    const { feeAmount: _feeAmount, ...rest } = intent;
+    return rest;
+  }
   // ──────────────────────────────────────────────────────────────────────
   // Tokens
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Fetch all supported swap tokens grouped by SpokeChainKey.
-   *
-   * @returns `Result<GetSwapTokensResponseV2>` — map of chain key → token list.
-   */
+  /** Fetch all supported swap tokens grouped by SpokeChainKey. */
   async getTokens(config) {
-    return this.request("/swaps/tokens", { method: "GET" }, GetSwapTokensResponseSchema, config);
+    return this.toResult("/swaps/tokens", (c) => c.getTokens(), config);
   }
-  /**
-   * Fetch supported swap tokens for a single SpokeChainKey.
-   *
-   * @param chainKey - SODAX SpokeChainKey (e.g. `0xa4b1.arbitrum`, `solana`).
-   * @returns `Result<GetSwapTokensByChainResponseV2>` — token list for the chain.
-   */
+  /** Fetch supported swap tokens for a single SpokeChainKey. */
   async getTokensByChain(chainKey, config) {
-    return this.request(
-      `/swaps/tokens/${chainKey}`,
-      { method: "GET" },
-      GetSwapTokensByChainResponseSchema,
-      config
-    );
+    return this.toResult(`/swaps/tokens/${chainKey}`, (c) => c.getTokensByChain(chainKey), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Quote · deadline
   // ──────────────────────────────────────────────────────────────────────
   /**
-   * Get a solver quote for a cross-chain swap.
-   *
-   * Pass `query.includeTxData = true` to also build an unsigned create-intent
-   * transaction (`txData`) using the quoted amount as `minOutputAmount`; in that
-   * case `srcAddress`/`dstAddress` are required in the body.
-   *
-   * @returns `Result<QuoteResponseV2>` — `quotedAmount` (decimal string) and optional `txData`.
+   * Get a solver quote for a cross-chain swap. Pass `query.includeTxData = true` to also build an
+   * unsigned create-intent transaction (`txData`); in that case `srcAddress`/`dstAddress` are required.
    */
   async getQuote(body, query, config) {
-    const endpoint = query?.includeTxData ? "/swaps/quote?includeTxData=true" : "/swaps/quote";
-    const txSchema = rawTxSchemaForChainKey(body.tokenSrcChainKey);
-    return this.request(
-      endpoint,
-      { method: "POST", body: toJsonBody(body) },
-      makeQuoteResponseSchema(txSchema),
-      config
-    );
+    return this.toResult("/swaps/quote", (c) => c.getQuote(body, query), config);
   }
-  /**
-   * Compute a swap deadline (hub timestamp + `offsetSeconds`, default 300s).
-   *
-   * @returns `Result<DeadlineResponseV2>` — unix-seconds deadline (decimal string).
-   */
+  /** Compute a swap deadline (hub timestamp + `offsetSeconds`, default 300s). */
   async getDeadline(query, config) {
-    const queryParams = new URLSearchParams();
-    if (query?.offsetSeconds !== void 0) queryParams.append("offsetSeconds", String(query.offsetSeconds));
-    const queryString = queryParams.toString();
-    const endpoint = queryString.length > 0 ? `/swaps/deadline?${queryString}` : "/swaps/deadline";
-    return this.request(endpoint, { method: "GET" }, DeadlineResponseSchema, config);
+    return this.toResult("/swaps/deadline", (c) => c.getDeadline(query), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Allowance · approve · create intent
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Check whether the source token allowance is already sufficient for the intent.
-   *
-   * @returns `Result<AllowanceCheckResponseV2>` — `{ valid }`.
-   */
+  /** Check whether the source token allowance is already sufficient for the intent. */
   async checkAllowance(body, config) {
-    return this.request(
-      "/swaps/allowance/check",
-      { method: "POST", body: toJsonBody(body) },
-      AllowanceCheckResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/allowance/check", (c) => c.checkAllowance(body), config);
   }
-  /**
-   * Build an unsigned token-approval transaction for the source token.
-   *
-   * @returns `Result<ApproveResponseV2>` — `{ tx }` (chain-specific unsigned tx).
-   */
+  /** Build an unsigned token-approval transaction for the source token. */
   async approve(body, config) {
-    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
-    return this.request(
-      "/swaps/approve",
-      { method: "POST", body: toJsonBody(body) },
-      makeApproveResponseSchema(txSchema),
-      config
-    );
+    return this.toResult("/swaps/approve", (c) => c.approve(body), config);
   }
-  /**
-   * Build an unsigned create-intent transaction.
-   *
-   * @returns `Result<CreateIntentResponseV2>` — `{ tx, intent, relayData }`.
-   */
+  /** Build an unsigned create-intent transaction. */
   async createIntent(body, config) {
-    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
-    return this.request(
-      "/swaps/intents",
-      { method: "POST", body: toJsonBody(body) },
-      makeCreateIntentResponseSchema(txSchema),
-      config
-    );
+    return this.toResult("/swaps/intents", (c) => c.createIntent(body), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Intent lifecycle: submit · status · cancel · hash · packet · extra-data
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Submit the broadcast intent tx to the relay.
-   *
-   * @returns `Result<SubmitIntentResponseV2>` — `{ result }` (opaque relay response).
-   */
+  /** Submit the broadcast intent tx to the relay. */
   async submitIntent(body, config) {
-    return this.request(
-      "/swaps/intents/submit",
-      { method: "POST", body: toJsonBody(body) },
-      SubmitIntentResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/intents/submit", (c) => c.submitIntent(body), config);
   }
-  /**
-   * Poll the solver for intent execution status.
-   *
-   * @returns `Result<StatusResponseV2>` — `{ status, fillTxHash? }` (`fillTxHash` set when `status === 3`).
-   */
+  /** Poll the solver for intent execution status. */
   async getStatus(body, config) {
-    return this.request(
-      "/swaps/intents/status",
-      { method: "POST", body: toJsonBody(body) },
-      StatusResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/intents/status", (c) => c.getStatus(body), config);
   }
-  /**
-   * Build an unsigned cancel-intent transaction. The `intent` field carries
-   * `bigint` numerics — {@link toJsonBody} serializes them to decimal strings.
-   *
-   * @returns `Result<CancelIntentResponseV2>` — `{ tx }`.
-   */
+  /** Build an unsigned cancel-intent transaction (the `intent` bigint numerics serialize to strings). */
   async cancelIntent(body, config) {
-    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
-    return this.request(
+    return this.toResult(
       "/swaps/intents/cancel",
-      { method: "POST", body: toJsonBody(body) },
-      makeCancelIntentResponseSchema(txSchema),
+      (c) => c.cancelIntent({ ...body, intent: _SwapsApiService.toWireIntent(body.intent) }),
       config
     );
   }
-  /**
-   * Compute the keccak256 hash of an Intent struct. The `intent` field carries
-   * `bigint` numerics — {@link toJsonBody} serializes them to decimal strings.
-   *
-   * @returns `Result<IntentHashResponseV2>` — `{ hash }`.
-   */
+  /** Compute the keccak256 hash of an Intent struct (bigint numerics serialize to strings). */
   async getIntentHash(body, config) {
-    return this.request(
+    return this.toResult(
       "/swaps/intents/hash",
-      { method: "POST", body: toJsonBody(body) },
-      IntentHashResponseSchema,
+      (c) => c.getIntentHash({ ...body, intent: _SwapsApiService.toWireIntent(body.intent) }),
       config
     );
   }
-  /**
-   * Long-poll the relayer until the fill packet lands on the destination chain.
-   *
-   * @returns `Result<IntentPacketResponseV2>` — delivered packet data.
-   */
+  /** Long-poll the relayer until the fill packet lands on the destination chain. */
   async getSolvedIntentPacket(body, config) {
-    return this.request(
-      "/swaps/intents/packet",
-      { method: "POST", body: toJsonBody(body) },
-      IntentPacketResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/intents/packet", (c) => c.getSolvedIntentPacket(body), config);
   }
-  /**
-   * Recover the relay extra data needed by `/swaps/intents/submit`. Provide
-   * EITHER `txHash` OR `intent` (whose `bigint` numerics {@link toJsonBody} serializes).
-   *
-   * @returns `Result<IntentExtraDataResponseV2>` — `{ address, payload }`.
-   */
+  /** Recover the relay extra data needed by `/swaps/intents/submit` (provide EITHER `txHash` OR `intent`). */
   async getIntentSubmitTxExtraData(body, config) {
-    return this.request(
-      "/swaps/intents/extra-data",
-      { method: "POST", body: toJsonBody(body) },
-      RelayExtraDataResponseSchema,
-      config
-    );
+    const normalized = body.intent ? { ...body, intent: _SwapsApiService.toWireIntent(body.intent) } : body;
+    return this.toResult("/swaps/intents/extra-data", (c) => c.getIntentSubmitTxExtraData(normalized), config);
   }
-  /**
-   * Get the on-chain fill state for an intent by its hub-chain tx hash.
-   *
-   * @returns `Result<IntentStateV2>` — `{ exists, remainingInput, receivedOutput, pendingPayment }`.
-   */
+  /** Get the on-chain fill state for an intent by its hub-chain tx hash. */
   async getFilledIntent(txHash, config) {
-    return this.request(`/swaps/intents/${txHash}/fill`, { method: "GET" }, IntentStateResponseSchema, config);
+    return this.toResult(`/swaps/intents/${txHash}/fill`, (c) => c.getFilledIntent(txHash), config);
   }
-  /**
-   * Look up an Intent struct by its hub-chain creation tx hash.
-   *
-   * @returns `Result<GetIntentResponseV2>` — the decoded intent (bigint fields as decimal strings).
-   */
+  /** Look up an Intent struct by its hub-chain creation tx hash. */
   async getIntent(txHash, config) {
-    return this.request(`/swaps/intents/${txHash}`, { method: "GET" }, IntentResponseSchema, config);
+    return this.toResult(`/swaps/intents/${txHash}`, (c) => c.getIntent(txHash), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Limit orders · gas · fees
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Build an unsigned create-limit-order-intent transaction (same as create-intent
-   * but `deadline` is optional).
-   *
-   * @returns `Result<CreateLimitOrderResponseV2>` — `{ tx, intent, relayData }`.
-   */
+  /** Build an unsigned create-limit-order-intent transaction (create-intent with optional `deadline`). */
   async createLimitOrderIntent(body, config) {
-    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
-    return this.request(
-      "/swaps/limit-orders",
-      { method: "POST", body: toJsonBody(body) },
-      makeCreateIntentResponseSchema(txSchema),
-      config
-    );
+    return this.toResult("/swaps/limit-orders", (c) => c.createLimitOrderIntent(body), config);
   }
-  /**
-   * Estimate gas for a raw transaction on a spoke chain.
-   *
-   * @returns `Result<GasEstimateResponseV2>` — `{ gas }` (chain-specific shape).
-   */
+  /** Estimate gas for a raw transaction on a spoke chain (bigint `tx` numerics serialize to strings). */
   async estimateGas(body, config) {
-    return this.request(
-      "/swaps/gas/estimate",
-      { method: "POST", body: toJsonBody(body) },
-      GasEstimateResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/gas/estimate", (c) => c.estimateGas(body), config);
   }
-  /**
-   * Compute the partner fee for a given input amount.
-   *
-   * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
-   */
+  /** Compute the partner fee for a given input amount. */
   async getPartnerFee(query, config) {
-    const queryParams = new URLSearchParams({ amount: query.amount });
-    return this.request(
-      `/swaps/fees/partner?${queryParams.toString()}`,
-      { method: "GET" },
-      FeeResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/fees/partner", (c) => c.getPartnerFee(query), config);
   }
-  /**
-   * Compute the protocol (solver) fee for a given input amount.
-   *
-   * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
-   */
+  /** Compute the protocol (solver) fee for a given input amount. */
   async getSolverFee(query, config) {
-    const queryParams = new URLSearchParams({ amount: query.amount });
-    return this.request(
-      `/swaps/fees/solver?${queryParams.toString()}`,
-      { method: "GET" },
-      FeeResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/fees/solver", (c) => c.getSolverFee(query), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Submit-tx state machine
   // ──────────────────────────────────────────────────────────────────────
-  /**
-   * Submit a swap transaction to be processed (relay, post-execution, etc.). The
-   * `intent` field carries `bigint` numerics — {@link toJsonBody} serializes them.
-   * Idempotent on `(txHash, srcChainKey)`.
-   *
-   * @returns `Result<SubmitTxResponseV2>` — `{ success, data: { status, message } }`.
-   */
+  /** Submit a swap transaction to be processed (relay, post-execution, etc.). Idempotent on `(txHash, srcChainKey)`. */
   async submitTx(body, config) {
-    return this.request(
+    return this.toResult(
       "/swaps/submit-tx",
-      { method: "POST", body: toJsonBody(body) },
-      SubmitTxResponseSchema,
+      (c) => c.submitTx({ ...body, intent: _SwapsApiService.toWireIntent(body.intent) }),
       config
     );
   }
-  /**
-   * Get the processing status of a submitted swap transaction by `(txHash, srcChainKey)`.
-   *
-   * @returns `Result<SubmitTxStatusResponseV2>` — `{ success, data }` (processing state).
-   */
+  /** Get the processing status of a submitted swap transaction by `(txHash, srcChainKey)`. */
   async getSubmitTxStatus(query, config) {
-    const queryParams = new URLSearchParams({ txHash: query.txHash, srcChainKey: query.srcChainKey });
-    return this.request(
-      `/swaps/submit-tx/status?${queryParams.toString()}`,
-      { method: "GET" },
-      SubmitTxStatusResponseSchema,
-      config
-    );
+    return this.toResult("/swaps/submit-tx/status", (c) => c.getSubmitTxStatus(query), config);
   }
   // ──────────────────────────────────────────────────────────────────────
   // Utilities (parity with BackendApiService)
   // ──────────────────────────────────────────────────────────────────────
   /**
    * Merge additional headers into the service's default header set. Existing
-   * keys are overwritten; keys absent from `headers` are preserved.
+   * keys are overwritten; keys absent from `headers` are preserved. Applied to
+   * every subsequent call (the delegated client is rebuilt per call).
    */
   setHeaders(headers) {
     Object.entries(headers).forEach(([key, value]) => {
@@ -30201,137 +30001,137 @@ function resolveSwapsApiConfig(config) {
   }
   return layerConfigs(config);
 }
-var ChainKeySchema = v4__namespace.custom((input) => typeof input === "string");
-var SpokeChainKeySchema = v4__namespace.custom((input) => typeof input === "string");
-var AddressSchema2 = v4__namespace.custom((input) => typeof input === "string");
-var XTokenSchema = v4__namespace.object({
-  symbol: v4__namespace.string(),
-  name: v4__namespace.string(),
-  decimals: v4__namespace.number(),
-  address: v4__namespace.string(),
+var ChainKeySchema = v2__namespace.custom((input) => typeof input === "string");
+var SpokeChainKeySchema = v2__namespace.custom((input) => typeof input === "string");
+var AddressSchema = v2__namespace.custom((input) => typeof input === "string");
+var XTokenSchema = v2__namespace.object({
+  symbol: v2__namespace.string(),
+  name: v2__namespace.string(),
+  decimals: v2__namespace.number(),
+  address: v2__namespace.string(),
   chainKey: ChainKeySchema,
-  hubAsset: AddressSchema2,
-  vault: AddressSchema2,
-  access: v4__namespace.optional(v4__namespace.picklist(["withdrawOnly", "depositOnly"]))
+  hubAsset: AddressSchema,
+  vault: AddressSchema,
+  access: v2__namespace.optional(v2__namespace.picklist(["withdrawOnly", "depositOnly"]))
 });
-var IntentStructSchema = v4__namespace.object({
-  intentId: v4__namespace.string(),
-  creator: v4__namespace.string(),
-  inputToken: v4__namespace.string(),
-  outputToken: v4__namespace.string(),
-  inputAmount: v4__namespace.string(),
-  minOutputAmount: v4__namespace.string(),
-  deadline: v4__namespace.string(),
-  allowPartialFill: v4__namespace.boolean(),
-  srcChain: v4__namespace.number(),
-  dstChain: v4__namespace.number(),
-  srcAddress: v4__namespace.string(),
-  dstAddress: v4__namespace.string(),
-  solver: v4__namespace.string(),
-  data: v4__namespace.string()
+var IntentStructSchema = v2__namespace.object({
+  intentId: v2__namespace.string(),
+  creator: v2__namespace.string(),
+  inputToken: v2__namespace.string(),
+  outputToken: v2__namespace.string(),
+  inputAmount: v2__namespace.string(),
+  minOutputAmount: v2__namespace.string(),
+  deadline: v2__namespace.string(),
+  allowPartialFill: v2__namespace.boolean(),
+  srcChain: v2__namespace.number(),
+  dstChain: v2__namespace.number(),
+  srcAddress: v2__namespace.string(),
+  dstAddress: v2__namespace.string(),
+  solver: v2__namespace.string(),
+  data: v2__namespace.string()
 });
-var IntentResponseSchema2 = v4__namespace.object({
-  intentHash: v4__namespace.string(),
-  txHash: v4__namespace.string(),
-  logIndex: v4__namespace.number(),
-  chainId: v4__namespace.number(),
-  blockNumber: v4__namespace.number(),
-  open: v4__namespace.boolean(),
+var IntentResponseSchema = v2__namespace.object({
+  intentHash: v2__namespace.string(),
+  txHash: v2__namespace.string(),
+  logIndex: v2__namespace.number(),
+  chainId: v2__namespace.number(),
+  blockNumber: v2__namespace.number(),
+  open: v2__namespace.boolean(),
   intent: IntentStructSchema,
-  events: v4__namespace.array(v4__namespace.unknown())
+  events: v2__namespace.array(v2__namespace.unknown())
 });
-var UserIntentsResponseSchema = v4__namespace.object({
-  total: v4__namespace.number(),
-  offset: v4__namespace.number(),
-  limit: v4__namespace.number(),
-  items: v4__namespace.array(IntentResponseSchema2)
+var UserIntentsResponseSchema = v2__namespace.object({
+  total: v2__namespace.number(),
+  offset: v2__namespace.number(),
+  limit: v2__namespace.number(),
+  items: v2__namespace.array(IntentResponseSchema)
 });
-var OrderbookResponseSchema = v4__namespace.object({
-  total: v4__namespace.number(),
-  data: v4__namespace.array(
-    v4__namespace.object({
-      intentState: v4__namespace.object({
-        exists: v4__namespace.boolean(),
-        remainingInput: v4__namespace.string(),
-        receivedOutput: v4__namespace.string(),
-        pendingPayment: v4__namespace.boolean()
+var OrderbookResponseSchema = v2__namespace.object({
+  total: v2__namespace.number(),
+  data: v2__namespace.array(
+    v2__namespace.object({
+      intentState: v2__namespace.object({
+        exists: v2__namespace.boolean(),
+        remainingInput: v2__namespace.string(),
+        receivedOutput: v2__namespace.string(),
+        pendingPayment: v2__namespace.boolean()
       }),
-      intentData: v4__namespace.object({
-        intentId: v4__namespace.string(),
-        creator: v4__namespace.string(),
-        inputToken: v4__namespace.string(),
-        outputToken: v4__namespace.string(),
-        inputAmount: v4__namespace.string(),
-        minOutputAmount: v4__namespace.string(),
-        deadline: v4__namespace.string(),
-        allowPartialFill: v4__namespace.boolean(),
-        srcChain: v4__namespace.number(),
-        dstChain: v4__namespace.number(),
-        srcAddress: v4__namespace.string(),
-        dstAddress: v4__namespace.string(),
-        solver: v4__namespace.string(),
-        data: v4__namespace.string(),
-        intentHash: v4__namespace.string(),
-        txHash: v4__namespace.string(),
-        blockNumber: v4__namespace.number()
+      intentData: v2__namespace.object({
+        intentId: v2__namespace.string(),
+        creator: v2__namespace.string(),
+        inputToken: v2__namespace.string(),
+        outputToken: v2__namespace.string(),
+        inputAmount: v2__namespace.string(),
+        minOutputAmount: v2__namespace.string(),
+        deadline: v2__namespace.string(),
+        allowPartialFill: v2__namespace.boolean(),
+        srcChain: v2__namespace.number(),
+        dstChain: v2__namespace.number(),
+        srcAddress: v2__namespace.string(),
+        dstAddress: v2__namespace.string(),
+        solver: v2__namespace.string(),
+        data: v2__namespace.string(),
+        intentHash: v2__namespace.string(),
+        txHash: v2__namespace.string(),
+        blockNumber: v2__namespace.number()
       })
     })
   )
 });
-var MoneyMarketPositionSchema = v4__namespace.object({
-  userAddress: v4__namespace.string(),
-  positions: v4__namespace.array(
-    v4__namespace.object({
-      reserveAddress: v4__namespace.string(),
-      aTokenAddress: v4__namespace.string(),
-      variableDebtTokenAddress: v4__namespace.string(),
-      aTokenBalance: v4__namespace.string(),
-      variableDebtTokenBalance: v4__namespace.string(),
-      blockNumber: v4__namespace.number()
+var MoneyMarketPositionSchema = v2__namespace.object({
+  userAddress: v2__namespace.string(),
+  positions: v2__namespace.array(
+    v2__namespace.object({
+      reserveAddress: v2__namespace.string(),
+      aTokenAddress: v2__namespace.string(),
+      variableDebtTokenAddress: v2__namespace.string(),
+      aTokenBalance: v2__namespace.string(),
+      variableDebtTokenBalance: v2__namespace.string(),
+      blockNumber: v2__namespace.number()
     })
   )
 });
-var MoneyMarketAssetSchema = v4__namespace.object({
-  reserveAddress: v4__namespace.string(),
-  aTokenAddress: v4__namespace.string(),
-  totalATokenBalance: v4__namespace.string(),
-  variableDebtTokenAddress: v4__namespace.string(),
-  totalVariableDebtTokenBalance: v4__namespace.string(),
-  liquidityRate: v4__namespace.string(),
-  symbol: v4__namespace.string(),
-  totalSuppliers: v4__namespace.number(),
-  totalBorrowers: v4__namespace.number(),
-  variableBorrowRate: v4__namespace.string(),
-  stableBorrowRate: v4__namespace.string(),
-  liquidityIndex: v4__namespace.string(),
-  variableBorrowIndex: v4__namespace.string(),
-  blockNumber: v4__namespace.number()
+var MoneyMarketAssetSchema = v2__namespace.object({
+  reserveAddress: v2__namespace.string(),
+  aTokenAddress: v2__namespace.string(),
+  totalATokenBalance: v2__namespace.string(),
+  variableDebtTokenAddress: v2__namespace.string(),
+  totalVariableDebtTokenBalance: v2__namespace.string(),
+  liquidityRate: v2__namespace.string(),
+  symbol: v2__namespace.string(),
+  totalSuppliers: v2__namespace.number(),
+  totalBorrowers: v2__namespace.number(),
+  variableBorrowRate: v2__namespace.string(),
+  stableBorrowRate: v2__namespace.string(),
+  liquidityIndex: v2__namespace.string(),
+  variableBorrowIndex: v2__namespace.string(),
+  blockNumber: v2__namespace.number()
 });
-var MoneyMarketAssetsSchema = v4__namespace.array(MoneyMarketAssetSchema);
-var MoneyMarketAssetBorrowersSchema = v4__namespace.object({
-  borrowers: v4__namespace.array(v4__namespace.string()),
-  total: v4__namespace.number(),
-  offset: v4__namespace.number(),
-  limit: v4__namespace.number()
+var MoneyMarketAssetsSchema = v2__namespace.array(MoneyMarketAssetSchema);
+var MoneyMarketAssetBorrowersSchema = v2__namespace.object({
+  borrowers: v2__namespace.array(v2__namespace.string()),
+  total: v2__namespace.number(),
+  offset: v2__namespace.number(),
+  limit: v2__namespace.number()
 });
-var MoneyMarketAssetSuppliersSchema = v4__namespace.object({
-  suppliers: v4__namespace.array(v4__namespace.string()),
-  total: v4__namespace.number(),
-  offset: v4__namespace.number(),
-  limit: v4__namespace.number()
+var MoneyMarketAssetSuppliersSchema = v2__namespace.object({
+  suppliers: v2__namespace.array(v2__namespace.string()),
+  total: v2__namespace.number(),
+  offset: v2__namespace.number(),
+  limit: v2__namespace.number()
 });
-var MoneyMarketBorrowersSchema = v4__namespace.object({
-  borrowers: v4__namespace.array(v4__namespace.string()),
-  total: v4__namespace.number(),
-  offset: v4__namespace.number(),
-  limit: v4__namespace.number()
+var MoneyMarketBorrowersSchema = v2__namespace.object({
+  borrowers: v2__namespace.array(v2__namespace.string()),
+  total: v2__namespace.number(),
+  offset: v2__namespace.number(),
+  limit: v2__namespace.number()
 });
-var GetChainsResponseSchema = v4__namespace.array(SpokeChainKeySchema);
-var TokensByChainMapSchema = v4__namespace.custom(
-  (input) => typeof input === "object" && input !== null && Object.values(input).every((tokens) => Array.isArray(tokens) && tokens.every((t) => v4__namespace.is(XTokenSchema, t)))
+var GetChainsResponseSchema = v2__namespace.array(SpokeChainKeySchema);
+var TokensByChainMapSchema = v2__namespace.custom(
+  (input) => typeof input === "object" && input !== null && Object.values(input).every((tokens) => Array.isArray(tokens) && tokens.every((t) => v2__namespace.is(XTokenSchema, t)))
 );
-var TokensListSchema = v4__namespace.array(XTokenSchema);
-var ReserveAssetsSchema = v4__namespace.array(AddressSchema2);
+var TokensListSchema = v2__namespace.array(XTokenSchema);
+var ReserveAssetsSchema = v2__namespace.array(AddressSchema);
 
 // src/backendApi/BackendApiService.ts
 var BackendApiService = class {
@@ -30393,13 +30193,13 @@ var BackendApiService = class {
         logger: this.logger,
         serviceLabel: "BackendApiService"
       });
-      const parsed = v4__namespace.safeParse(schema, raw);
+      const parsed = v2__namespace.safeParse(schema, raw);
       if (!parsed.success) {
         return {
           ok: false,
           error: new SodaxError("EXTERNAL_API_ERROR", `Invalid response shape from backend API for ${endpoint}`, {
             feature: "backend",
-            context: { api: "backend", endpoint, reason: "invalid_response_shape", issues: v4__namespace.flatten(parsed.issues) }
+            context: { api: "backend", endpoint, reason: "invalid_response_shape", issues: v2__namespace.flatten(parsed.issues) }
           })
         };
       }
@@ -30440,7 +30240,7 @@ var BackendApiService = class {
    *   open/closed state, token amounts, and any fill events.
    */
   async getIntentByTxHash(txHash, config) {
-    return this.request(`/intent/tx/${txHash}`, { ...config, method: "GET" }, IntentResponseSchema2);
+    return this.request(`/intent/tx/${txHash}`, { ...config, method: "GET" }, IntentResponseSchema);
   }
   /**
    * Fetch a swap intent by its canonical intent hash.
@@ -30449,7 +30249,7 @@ var BackendApiService = class {
    * @returns `Result<IntentResponse>` — on success, the full intent details.
    */
   async getIntentByHash(intentHash, config) {
-    return this.request(`/intent/${intentHash}`, { ...config, method: "GET" }, IntentResponseSchema2);
+    return this.request(`/intent/${intentHash}`, { ...config, method: "GET" }, IntentResponseSchema);
   }
   // Solver endpoints
   /**
@@ -30749,6 +30549,7 @@ var BackendApiService = class {
 // src/bridge/errors.ts
 var bridgeInvariant = createInvariant("bridge");
 var ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -30759,6 +30560,7 @@ var ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var BRIDGE_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -31835,6 +31637,7 @@ var StakingLogic = class _StakingLogic {
 // src/staking/errors.ts
 var stakingInvariant = createInvariant("staking");
 var STAKE_ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -31845,6 +31648,7 @@ var STAKE_ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var STAKING_ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_SUBMIT_FAILED",
@@ -31854,6 +31658,7 @@ var STAKING_ORCHESTRATION_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var STAKING_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -33157,6 +32962,14 @@ var StakingService = class {
     });
   }
 };
+
+// src/dex/errors.ts
+var dexInvariant = createInvariant("dex");
+var isDexError = isCodeMember(LOOKUP_CODES);
+var isDexCreateIntentError = isCodeMember(CREATE_INTENT_CODES);
+var isDexApproveError = isCodeMember(APPROVE_CODES);
+
+// src/dex/AssetService.ts
 var AssetService = class {
   relayerApiEndpoint;
   hubProvider;
@@ -33262,7 +33075,7 @@ var AssetService = class {
             walletProvider: _params.walletProvider
           }
         );
-        if (!result.ok) return result;
+        if (!result.ok) return { ok: false, error: approveFailed("dex", result.error) };
         return {
           ok: true,
           value: result.value
@@ -33287,23 +33100,16 @@ var AssetService = class {
           raw: _params.raw,
           walletProvider: _params.walletProvider
         });
-        if (!result.ok) {
-          return result;
-        }
+        if (!result.ok) return { ok: false, error: approveFailed("dex", result.error) };
         return {
           ok: true,
           value: result.value
         };
       }
-      return {
-        ok: false,
-        error: new Error("Approve only supported for EVM/Stellar spoke chains")
-      };
+      dexInvariant(false, "Approve only supported for EVM/Stellar spoke chains");
     } catch (error) {
-      return {
-        ok: false,
-        error
-      };
+      if (isDexApproveError(error)) return { ok: false, error };
+      return { ok: false, error: approveFailed("dex", error) };
     }
   }
   /**
@@ -33361,12 +33167,7 @@ var AssetService = class {
           walletProvider: _params.walletProvider
         }
       );
-      if (!txResult.ok) {
-        return {
-          ok: false,
-          error: txResult.error
-        };
-      }
+      if (!txResult.ok) return { ok: false, error: intentCreationFailed("dex", txResult.error) };
       return {
         ok: true,
         value: {
@@ -33375,10 +33176,8 @@ var AssetService = class {
         }
       };
     } catch (error) {
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -33436,12 +33235,7 @@ var AssetService = class {
         walletProvider: _params.walletProvider
       };
       const txResult = await this.spoke.sendMessage(sendMessageParams);
-      if (!txResult.ok) {
-        return {
-          ok: false,
-          error: txResult.error
-        };
-      }
+      if (!txResult.ok) return { ok: false, error: intentCreationFailed("dex", txResult.error) };
       return {
         ok: true,
         value: {
@@ -33450,10 +33244,8 @@ var AssetService = class {
         }
       };
     } catch (error) {
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -33515,7 +33307,8 @@ var AssetService = class {
       }
       return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
     } catch (error) {
-      return { ok: false, error };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -33551,7 +33344,8 @@ var AssetService = class {
       }
       return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
     } catch (error) {
-      return { ok: false, error };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -33683,10 +33477,10 @@ var AssetService = class {
   async getWrappedAmount(dexToken, assetAmount) {
     try {
       const shares = await Erc4626Service.convertToShares(dexToken, assetAmount, this.hubProvider.publicClient);
-      if (!shares.ok) return shares;
+      if (!shares.ok) return { ok: false, error: lookupFailed("dex", "getWrappedAmount", shares.error) };
       return { ok: true, value: shares.value };
     } catch (error) {
-      return { ok: false, error };
+      return { ok: false, error: lookupFailed("dex", "getWrappedAmount", error) };
     }
   }
   /**
@@ -33702,10 +33496,10 @@ var AssetService = class {
   async getUnwrappedAmount(dexToken, shareAmount) {
     try {
       const assetAmount = await Erc4626Service.convertToAssets(dexToken, shareAmount, this.hubProvider.publicClient);
-      if (!assetAmount.ok) return assetAmount;
+      if (!assetAmount.ok) return { ok: false, error: lookupFailed("dex", "getUnwrappedAmount", assetAmount.error) };
       return { ok: true, value: assetAmount.value };
     } catch (error) {
-      return { ok: false, error };
+      return { ok: false, error: lookupFailed("dex", "getUnwrappedAmount", error) };
     }
   }
   /**
@@ -33731,14 +33525,10 @@ var AssetService = class {
       });
       return { ok: true, value };
     } catch (error) {
-      return { ok: false, error };
+      return { ok: false, error: lookupFailed("dex", "getDeposit", error) };
     }
   }
 };
-
-// src/dex/errors.ts
-var dexInvariant = createInvariant("dex");
-var isDexError = isCodeMember(LOOKUP_CODES);
 var ClService = class _ClService {
   relayerApiEndpoint;
   hubProvider;
@@ -33853,7 +33643,7 @@ var ClService = class _ClService {
         this.config.logger.error("executeSupplyLiquidity error", txResult.error);
         return {
           ok: false,
-          error: txResult.error
+          error: intentCreationFailed("dex", txResult.error)
         };
       }
       return {
@@ -33865,10 +33655,8 @@ var ClService = class _ClService {
       };
     } catch (error) {
       this.config.logger.error("executeSupplyLiquidity error", error);
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -33980,7 +33768,7 @@ var ClService = class _ClService {
       if (!txResult.ok) {
         return {
           ok: false,
-          error: txResult.error
+          error: intentCreationFailed("dex", txResult.error)
         };
       }
       return {
@@ -33991,10 +33779,8 @@ var ClService = class _ClService {
         }
       };
     } catch (error) {
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -34053,7 +33839,7 @@ var ClService = class _ClService {
       if (!txResult.ok) {
         return {
           ok: false,
-          error: txResult.error
+          error: intentCreationFailed("dex", txResult.error)
         };
       }
       return {
@@ -34064,10 +33850,8 @@ var ClService = class _ClService {
         }
       };
     } catch (error) {
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -34142,10 +33926,8 @@ var ClService = class _ClService {
           return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
         } catch (error) {
           this.config.logger.error("supplyLiquidity error", error);
-          return {
-            ok: false,
-            error
-          };
+          if (isDexCreateIntentError(error)) return { ok: false, error };
+          return { ok: false, error: intentCreationFailed("dex", error) };
         }
       },
       {
@@ -34205,10 +33987,8 @@ var ClService = class _ClService {
           }
           return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
         } catch (error) {
-          return {
-            ok: false,
-            error
-          };
+          if (isDexCreateIntentError(error)) return { ok: false, error };
+          return { ok: false, error: intentCreationFailed("dex", error) };
         }
       },
       {
@@ -34269,10 +34049,8 @@ var ClService = class _ClService {
           }
           return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
         } catch (error) {
-          return {
-            ok: false,
-            error
-          };
+          if (isDexCreateIntentError(error)) return { ok: false, error };
+          return { ok: false, error: intentCreationFailed("dex", error) };
         }
       },
       {
@@ -34411,7 +34189,7 @@ var ClService = class _ClService {
         this.config.logger.error("executeClaimRewards error", txResult.error);
         return {
           ok: false,
-          error: txResult.error
+          error: intentCreationFailed("dex", txResult.error)
         };
       }
       return {
@@ -34423,10 +34201,8 @@ var ClService = class _ClService {
       };
     } catch (error) {
       this.config.logger.error("executeClaimRewards error", error);
-      return {
-        ok: false,
-        error
-      };
+      if (isDexCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("dex", error) };
     }
   }
   /**
@@ -34469,10 +34245,8 @@ var ClService = class _ClService {
           return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
         } catch (error) {
           this.config.logger.error("claimRewards error", error);
-          return {
-            ok: false,
-            error
-          };
+          if (isDexCreateIntentError(error)) return { ok: false, error };
+          return { ok: false, error: intentCreationFailed("dex", error) };
         }
       },
       {
@@ -35073,6 +34847,7 @@ var DexService = class {
 // src/moneyMarket/errors.ts
 var mmInvariant = createInvariant("moneyMarket");
 var ORCHESTRATION_CODES2 = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -35083,6 +34858,7 @@ var ORCHESTRATION_CODES2 = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var MONEY_MARKET_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -38839,11 +38615,7 @@ var PartnerFeeClaimService = class {
     } catch (error) {
       return {
         ok: false,
-        error: new SodaxError("APPROVE_FAILED", error instanceof Error ? error.message : "approveToken failed", {
-          feature: "partner",
-          cause: error,
-          context: { phase: "approve" }
-        })
+        error: approveFailed("partner", error)
       };
     }
   }
@@ -39359,6 +39131,7 @@ var RecoveryService = class {
 // src/leverageYield/errors.ts
 var leverageYieldInvariant = createInvariant("leverageYield");
 var LEVERAGE_YIELD_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "APPROVE_FAILED",
@@ -39378,6 +39151,7 @@ var LEVERAGE_YIELD_POST_EXECUTION_CODES = /* @__PURE__ */ new Set([
   "UNKNOWN"
 ]);
 var LEVERAGE_YIELD_SWAP_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "INTENT_CREATION_FAILED",
   "TX_VERIFICATION_FAILED",
@@ -39454,7 +39228,7 @@ var LeverageYieldService = class {
   }
   /** Looks up a vault by its `name` field. Returns `undefined` when not registered. */
   getVault(name) {
-    return this.listVaults().find((v6) => v6.name === name);
+    return this.listVaults().find((v4) => v4.name === name);
   }
   /**
    * Looks up a registered vault by its on-chain proxy address (case-insensitive).
@@ -39462,7 +39236,7 @@ var LeverageYieldService = class {
    */
   getVaultByAddress(address) {
     const normalized = address.toLowerCase();
-    return this.listVaults().find((v6) => v6.vault.toLowerCase() === normalized);
+    return this.listVaults().find((v4) => v4.vault.toLowerCase() === normalized);
   }
   /**
    * Resolves the intent `deadline`: returns the caller-supplied value verbatim, otherwise
@@ -40347,6 +40121,7 @@ var Sodax = class {
 // src/partner/errors.ts
 var partnerInvariant = createInvariant("partner");
 var PARTNER_CODES = /* @__PURE__ */ new Set([
+  "USER_REJECTED",
   "VALIDATION_FAILED",
   "LOOKUP_FAILED",
   "APPROVE_FAILED",
@@ -40372,6 +40147,10 @@ var isPartnerError = isCodeMember(PARTNER_CODES);
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
+Object.defineProperty(exports, "SwapsApiError", {
+  enumerable: true,
+  get: function () { return swapsApi.SwapsApiError; }
+});
 exports.ALLOWANCE_CHECK_CODES = ALLOWANCE_CHECK_CODES;
 exports.APPROVE_CODES = APPROVE_CODES;
 exports.AssetService = AssetService;
@@ -40598,6 +40377,7 @@ exports.getStagingSolverTokens = getStagingSolverTokens;
 exports.getSupportedSolverTokens = getSupportedSolverTokens;
 exports.getTransactionPackets = getTransactionPackets;
 exports.getbnUSDToken = getbnUSDToken;
+exports.hederaSupportedTokens = hederaSupportedTokens;
 exports.hexToBigInt = hexToBigInt;
 exports.hexToSolanaAddress = hexToSolanaAddress;
 exports.hubConfig = hubConfig;
@@ -40617,6 +40397,8 @@ exports.isBridgeError = isBridgeError;
 exports.isBridgeLookupError = isBridgeLookupError;
 exports.isBridgeOrchestrationError = isBridgeOrchestrationError;
 exports.isCodeMember = isCodeMember;
+exports.isDexApproveError = isDexApproveError;
+exports.isDexCreateIntentError = isDexCreateIntentError;
 exports.isDexError = isDexError;
 exports.isEvmChainKey = isEvmChainKey;
 exports.isEvmChainKeyType = isEvmChainKeyType;