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

package/dist/index.cjs

@@ -19,6 +19,7 @@ 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 BigNumber5 = require('bignumber.js');
 var swapSdkCore = require('@pancakeswap/swap-sdk-core');
 var v3Sdk = require('@pancakeswap/v3-sdk');
@@ -47,6 +48,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 BigNumber5__default = /*#__PURE__*/_interopDefault(BigNumber5);
 
 // src/errors/SodaxError.ts
@@ -119,8 +121,8 @@ function serializeCause(cause, depth) {
 }
 function sanitizeContext(value, depth) {
   const out = {};
-  for (const [key, v] of Object.entries(value)) {
-    out[key] = sanitizeValue(v, depth + 1);
+  for (const [key, v6] of Object.entries(value)) {
+    out[key] = sanitizeValue(v6, depth + 1);
   }
   return out;
 }
@@ -131,13 +133,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((v) => sanitizeValue(v, depth + 1));
+  if (Array.isArray(value)) return value.map((v6) => sanitizeValue(v6, depth + 1));
   if (value instanceof Date) return value.toISOString();
   if (value instanceof Map) {
-    return Array.from(value.entries()).map(([k, v]) => [sanitizeValue(k, depth + 1), sanitizeValue(v, depth + 1)]);
+    return Array.from(value.entries()).map(([k, v6]) => [sanitizeValue(k, depth + 1), sanitizeValue(v6, depth + 1)]);
   }
   if (value instanceof Set) {
-    return Array.from(value.values()).map((v) => sanitizeValue(v, depth + 1));
+    return Array.from(value.values()).map((v6) => sanitizeValue(v6, depth + 1));
   }
   if (value instanceof Error) return { name: value.name, message: value.message };
   if (t === "object") {
@@ -149,9 +151,9 @@ function sanitizeValue(value, depth) {
   }
   return safeString(value);
 }
-function safeString(v) {
+function safeString(v6) {
   try {
-    return String(v);
+    return String(v6);
   } catch {
     return "[unserializable]";
   }
@@ -199,6 +201,7 @@ var SODAX_FEATURES = [
   "dex",
   "partner",
   "recovery",
+  "backend",
   "leverageYield"
 ];
 
@@ -2640,7 +2643,7 @@ var RelayChainIdMap = {
   [ChainKeys.STACKS_MAINNET]: 60n
 };
 var INTENT_CHAIN_IDS = Object.values(RelayChainIdMap);
-var IntentRelayChainIdToChainKey = Object.fromEntries(Object.entries(RelayChainIdMap).map(([chainKey, chainId]) => [chainId, chainKey]));
+var IntentRelayChainIdToChainKey = new Map(Object.entries(RelayChainIdMap).map(([chainKey, chainId]) => [chainId, chainKey]));
 var CHAIN_LOGO_BASE_URL = "https://raw.githubusercontent.com/icon-project/sodax-sdks/main/packages/assets/chain";
 var chainLogo = (key) => `${CHAIN_LOGO_BASE_URL}/${key}.png`;
 var baseChainInfo = {
@@ -4246,7 +4249,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 216;
+var CONFIG_VERSION = 217;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -4336,26 +4339,6 @@ function isRawDestinationParams(value) {
   if (typeof obj.dstAddress !== "string") return false;
   return typeof obj.dstChainKey === "string" && spokeChainKeysSet.has(obj.dstChainKey);
 }
-function isSubmitSwapTxResponse(value) {
-  return typeof value === "object" && value !== null && typeof value.success === "boolean" && typeof value.message === "string";
-}
-function isSubmitSwapTxStatusResponse(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  if (typeof obj.success !== "boolean") return false;
-  if (typeof obj.data !== "object" || obj.data === null) return false;
-  const data = obj.data;
-  if (typeof data.txHash !== "string") return false;
-  if (typeof data.srcChainKey !== "string") return false;
-  if (typeof data.status !== "string") return false;
-  if (typeof data.failedAttempts !== "number") return false;
-  if (data.result !== void 0) {
-    if (typeof data.result !== "object" || data.result === null) return false;
-    const result = data.result;
-    if (typeof result.dstIntentTxHash !== "string") return false;
-  }
-  return true;
-}
 function isBitcoinWalletProviderType(wp) {
   return wp.chainType === "BITCOIN";
 }
@@ -4393,11 +4376,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 array = new Uint8Array(length);
+  const array3 = new Uint8Array(length);
   for (let i = 0; i < length; i++) {
-    array[i] = Math.floor(Math.random() * 256);
+    array3[i] = Math.floor(Math.random() * 256);
   }
-  return array;
+  return array3;
 }
 function randomUint256() {
   const bytes = getRandomBytes(32);
@@ -13644,29 +13627,6 @@ var universalRouterAbi = [
   }
 ];
 
-// src/shared/utils/deepMerge.ts
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = target[key];
-    if (sourceVal !== void 0 && typeof sourceVal === "object" && sourceVal !== null && !Array.isArray(sourceVal) && typeof targetVal === "object" && targetVal !== null && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(
-        targetVal,
-        sourceVal
-      );
-    } else if (sourceVal !== void 0) {
-      result[key] = sourceVal;
-    }
-  }
-  return result;
-}
-
-// src/shared/config/mergeSodaxConfig.ts
-function mergeSodaxConfig(base2, override) {
-  return deepMerge(base2, override);
-}
-
 // src/shared/logger.ts
 var consoleLogger = {
   debug: (message, data) => data ? console.debug(message, data) : console.debug(message),
@@ -13759,8 +13719,9 @@ function resolveAnalytics(option) {
 // src/shared/config/ConfigService.ts
 var ConfigService = class {
   sodax;
-  api;
-  userConfig;
+  // TODO(config-v2): restore `api` / `userConfig` when initialize() dynamic fetch is re-enabled.
+  // private readonly api: BackendApiService;
+  // private readonly userConfig?: SodaxOptions;
   /**
    * SDK log sink. Resolved once at construction and kept independent of {@link sodax} so that
    * {@link initialize}'s dynamic-config swap never clobbers it. Read by services via `config.logger`.
@@ -13789,10 +13750,10 @@ var ConfigService = class {
   stakedATokenAddressesSet;
   chainToSupportedTokenAddressMap;
   hubAssetToXTokenMap;
+  // `api` / `userConfig` are accepted but unused while initialize()'s dynamic fetch is disabled
+  // (see TODO(config-v2) below); restore their assignments when re-enabling.
   constructor({ api, config, userConfig, logger, analytics, fee }) {
-    this.api = api;
     this.sodax = config;
-    this.userConfig = userConfig;
     this.logger = logger ?? resolveLogger(void 0);
     this.analytics = analytics ?? noopAnalytics;
     this.fee = fee;
@@ -13800,19 +13761,6 @@ var ConfigService = class {
   }
   async initialize() {
     try {
-      const result = await this.api.getAllConfig();
-      if (!result.ok) return result;
-      const response = result.value;
-      if (!response.version || response.version < CONFIG_VERSION) {
-        this.logger.warn(
-          `Dynamic config version is less than the current version, resorting to the default one. Current version: ${CONFIG_VERSION}, response version: ${response.version}`
-        );
-      } else {
-        const next = this.userConfig ? mergeSodaxConfig(response.config, this.userConfig) : response.config;
-        this.loadSodaxConfigDataStructures(next);
-        this.sodax = next;
-        this.initialized = true;
-      }
       return { ok: true, value: void 0 };
     } catch (error) {
       return { ok: false, error };
@@ -14082,9 +14030,32 @@ function parseTokenArrayFromJson(input) {
   }
   return tokens;
 }
+
+// src/shared/utils/deepMerge.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== void 0 && typeof sourceVal === "object" && sourceVal !== null && !Array.isArray(sourceVal) && typeof targetVal === "object" && targetVal !== null && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+// src/shared/config/mergeSodaxConfig.ts
+function mergeSodaxConfig(base2, override) {
+  return deepMerge(base2, override);
+}
 function encodeContractCalls(calls) {
   return viem.encodeAbiParameters(viem.parseAbiParameters("(address,uint256,bytes)[]"), [
-    calls.map((v) => [v.address, v.value, v.data])
+    calls.map((v6) => [v6.address, v6.value, v6.data])
   ]);
 }
 async function waitForTransactionReceipt(hash, provider) {
@@ -15765,6 +15736,32 @@ var BitcoinSpokeService = class {
       throw error;
     }
   }
+  /**
+   * Sign and submit a TRADING-wallet raw transaction — the Bound-built *unsigned* PSBT returned by
+   * `deposit({ raw: true })` / the Swaps API (`createIntent().tx.data`). Signs it with the wallet
+   * provider's key, then sends it to Bound Exchange to co-sign with the second 2-of-2 key and
+   * broadcast. Returns the broadcast tx id.
+   *
+   * This is the client-side completion of the TRADING deposit flow: the backend builds the PSBT
+   * (it can't broadcast — the user's signature is missing), the client signs here, and Bound
+   * co-signs + broadcasts. `relayData` ({ address, payload }) is the relay identity returned by
+   * `createIntent()`; forwarding it lets Bound auto-resubmit a stuck relay. It is **not** recoverable
+   * from `rawTx` (whose `to` is the asset manager, not the hub wallet), so callers must supply it.
+   *
+   * @throws if the chain is not in `TRADING` wallet mode (raw txs only exist in TRADING mode).
+   */
+  async signAndSubmitRawTransaction(params) {
+    if (this.walletMode !== "TRADING") {
+      throw new Error("signAndSubmitRawTransaction requires TRADING wallet mode.");
+    }
+    const { rawTx, walletProvider, relayData, accessToken = this.radfi.accessToken } = params;
+    if (!rawTx?.data || !rawTx?.from) {
+      throw new Error("signAndSubmitRawTransaction: rawTx.data (PSBT) and rawTx.from are required.");
+    }
+    const signedTx = await walletProvider.signTransaction(rawTx.data, false);
+    const signedBase64Tx = normalizePsbtToBase64(signedTx);
+    return this.radfi.requestRadfiSignature({ userAddress: rawTx.from, signedBase64Tx, relayData }, accessToken);
+  }
   /**
    * Build deposit PSBT with embedded cross-chain data
    */
@@ -16034,7 +16031,7 @@ function hexToBytes2(hex) {
   const al = hl / 2;
   if (hl % 2)
     throw new Error("hex string expected, got unpadded hex of length " + hl);
-  const array = new Uint8Array(al);
+  const array3 = 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));
@@ -16042,9 +16039,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);
     }
-    array[ai] = n1 * 16 + n2;
+    array3[ai] = n1 * 16 + n2;
   }
-  return array;
+  return array3;
 }
 function concatBytes(...arrays) {
   let sum = 0;
@@ -16674,22 +16671,22 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   const byte0 = Uint8Array.of(0);
   const byte1 = Uint8Array.of(1);
   const _maxDrbgIters = 1e3;
-  let v = u8n(hashLen);
+  let v6 = u8n(hashLen);
   let k = u8n(hashLen);
   let i = 0;
   const reset = () => {
-    v.fill(1);
+    v6.fill(1);
     k.fill(0);
     i = 0;
   };
-  const h = (...msgs) => hmacFn(k, concatBytes(v, ...msgs));
+  const h = (...msgs) => hmacFn(k, concatBytes(v6, ...msgs));
   const reseed = (seed = NULL) => {
     k = h(byte0, seed);
-    v = h();
+    v6 = h();
     if (seed.length === 0)
       return;
     k = h(byte1, seed);
-    v = h();
+    v6 = h();
   };
   const gen = () => {
     if (i++ >= _maxDrbgIters)
@@ -16697,10 +16694,10 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     let len = 0;
     const out = [];
     while (len < qByteLen) {
-      v = h();
-      const sl = v.slice();
+      v6 = h();
+      const sl = v6.slice();
       out.push(sl);
-      len += v.length;
+      len += v6.length;
     }
     return concatBytes(...out);
   };
@@ -16715,18 +16712,18 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object, fields = {}, optFields = {}) {
-  if (!object || typeof object !== "object")
+function validateObject(object4, fields = {}, optFields = {}) {
+  if (!object4 || typeof object4 !== "object")
     throw new Error("expected valid options object");
   function checkField(fieldName, expectedType, isOpt) {
-    const val = object[fieldName];
+    const val = object4[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, v]) => checkField(k, v, isOpt));
+  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v6]) => checkField(k, v6, isOpt));
   iter(fields, false);
   iter(optFields, true);
 }
@@ -16765,12 +16762,12 @@ function pow2(x, power, modulo) {
   }
   return res;
 }
-function invert(number, modulo) {
-  if (number === _0n2)
+function invert(number4, modulo) {
+  if (number4 === _0n2)
     throw new Error("invert: expected non-zero number");
   if (modulo <= _0n2)
     throw new Error("invert: expected positive modulus, got " + modulo);
-  let a = mod(number, modulo);
+  let a = mod(number4, modulo);
   let b = modulo;
   let x = _0n2, u = _1n2;
   while (a !== _0n2) {
@@ -16797,9 +16794,9 @@ function sqrt3mod4(Fp, n) {
 function sqrt5mod8(Fp, n) {
   const p5div8 = (Fp.ORDER - _5n) / _8n;
   const n2 = Fp.mul(n, _2n);
-  const v = Fp.pow(n2, p5div8);
-  const nv = Fp.mul(n, v);
-  const i = Fp.mul(Fp.mul(nv, _2n), v);
+  const v6 = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v6);
+  const i = Fp.mul(Fp.mul(nv, _2n), v6);
   const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
   assertIsSquare(Fp, root, n);
   return root;
@@ -17274,27 +17271,27 @@ var wNAF = class {
     assert0(n);
     return acc;
   }
-  getPrecomputes(W, point, transform) {
+  getPrecomputes(W, point, transform2) {
     let comp = pointPrecomputes.get(point);
     if (!comp) {
       comp = this.precomputeWindow(point, W);
       if (W !== 1) {
-        if (typeof transform === "function")
-          comp = transform(comp);
+        if (typeof transform2 === "function")
+          comp = transform2(comp);
         pointPrecomputes.set(point, comp);
       }
     }
     return comp;
   }
-  cached(point, scalar, transform) {
+  cached(point, scalar, transform2) {
     const W = getW(point);
-    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+    return this.wNAF(W, this.getPrecomputes(W, point, transform2), scalar);
   }
-  unsafe(point, scalar, transform, prev) {
+  unsafe(point, scalar, transform2, prev) {
     const W = getW(point);
     if (W === 1)
       return this._unsafeLadder(point, scalar, prev);
-    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform2), scalar, prev);
   }
   // We calculate precomputes for elliptic curve point multiplication
   // using windowed method. This specifies window size and
@@ -17381,9 +17378,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, v) => {
+  const uvRatio2 = extraOpts.uvRatio || ((u, v6) => {
     try {
-      return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
+      return { isValid: true, value: Fp.sqrt(Fp.div(u, v6)) };
     } catch (e) {
       return { isValid: false, value: _0n4 };
     }
@@ -17479,8 +17476,8 @@ function edwards(params, extraOpts = {}) {
       aInRange("point.y", y, _0n4, max);
       const y2 = modP(y * y);
       const u = modP(y2 - _1n4);
-      const v = modP(d * y2 - a);
-      let { isValid, value: x } = uvRatio2(u, v);
+      const v6 = modP(d * y2 - a);
+      let { isValid, value: x } = uvRatio2(u, v6);
       if (!isValid)
         throw new Error("bad point: invalid y coordinate");
       const isXOdd = (x & _1n4) === _1n4;
@@ -17820,13 +17817,13 @@ function adjustScalarBytes(bytes) {
   return bytes;
 }
 var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
-function uvRatio(u, v) {
+function uvRatio(u, v6) {
   const P = ed25519_CURVE_p;
-  const v3 = mod(v * v * v, P);
-  const v7 = mod(v3 * v3 * v, P);
+  const v32 = mod(v6 * v6 * v6, P);
+  const v7 = mod(v32 * v32 * v6, P);
   const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
-  let x = mod(u * v3 * pow, P);
-  const vx2 = mod(v * x * x, P);
+  let x = mod(u * v32 * pow, P);
+  const vx2 = mod(v6 * x * x, P);
   const root1 = x;
   const root2 = mod(x * ED25519_SQRT_M1, P);
   const useRoot1 = vx2 === u;
@@ -18157,7 +18154,7 @@ function findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio, protocol
   return findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumStakeRatio);
 }
 function findSeatPriceForProtocolBefore49(validators, numSeats) {
-  const stakes = validators.map((v) => BigInt(v.stake)).sort(sortBigIntAsc);
+  const stakes = validators.map((v6) => BigInt(v6.stake)).sort(sortBigIntAsc);
   const num = BigInt(numSeats);
   const stakesSum = stakes.reduce((a, b) => a + b);
   if (stakesSum < num) {
@@ -18186,7 +18183,7 @@ function findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumSt
   if (minimumStakeRatio.length != 2) {
     throw Error("minimumStakeRatio should have 2 elements");
   }
-  const stakes = validators.map((v) => BigInt(v.stake)).sort(sortBigIntAsc);
+  const stakes = validators.map((v6) => BigInt(v6.stake)).sort(sortBigIntAsc);
   const stakesSum = stakes.reduce((a, b) => a + b);
   if (validators.length < maxNumberOfSeats) {
     return stakesSum * BigInt(minimumStakeRatio[0]) / BigInt(minimumStakeRatio[1]);
@@ -18358,10 +18355,10 @@ var DER = {
         if (length < 128)
           throw new E("tlv.decode(long): not minimal encoding");
       }
-      const v = data.subarray(pos, pos + length);
-      if (v.length !== length)
+      const v6 = data.subarray(pos, pos + length);
+      if (v6.length !== length)
         throw new E("tlv.decode: wrong value length");
-      return { v, l: data.subarray(pos + length) };
+      return { v: v6, l: data.subarray(pos + length) };
     }
   },
   // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
@@ -18929,9 +18926,9 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     extraEntropy: false
   };
   const hasLargeCofactor = CURVE_ORDER * _2n4 < Fp.ORDER;
-  function isBiggerThanHalfOrder(number) {
+  function isBiggerThanHalfOrder(number4) {
     const HALF = CURVE_ORDER >> _1n6;
-    return number > HALF;
+    return number4 > HALF;
   }
   function validateRS(title, num) {
     if (!Fn.isValidNot0(num))
@@ -19108,14 +19105,14 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
         return false;
       const { r, s } = sig;
       const h = bits2int_modN(message);
-      const is = Fn.inv(s);
-      const u1 = Fn.create(h * is);
-      const u2 = Fn.create(r * is);
+      const is2 = Fn.inv(s);
+      const u1 = Fn.create(h * is2);
+      const u2 = Fn.create(r * is2);
       const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
       if (R.is0())
         return false;
-      const v = Fn.create(R.x);
-      return v === r;
+      const v6 = Fn.create(R.x);
+      return v6 === r;
     } catch (e) {
       return false;
     }
@@ -26461,13 +26458,18 @@ var SwapService = class {
   solver;
   partnerFee;
   relayerApiEndpoint;
-  constructor({ config, hubProvider, spoke }) {
+  // backend swaps-API client + opt-in 2-step submit-tx flag
+  backendApi;
+  useBackendSubmitTx;
+  constructor({ config, hubProvider, spoke, backendApi, useBackendSubmitTx }) {
     this.solver = config.solver;
     this.partnerFee = config.swapPartnerFee;
     this.relayerApiEndpoint = config.relay.relayerApiEndpoint;
     this.config = config;
     this.hubProvider = hubProvider;
     this.spoke = spoke;
+    this.backendApi = backendApi;
+    this.useBackendSubmitTx = useBackendSubmitTx ?? false;
   }
   /**
    * Estimates the gas cost for a raw (unsigned) transaction on a spoke chain.
@@ -26611,14 +26613,22 @@ var SwapService = class {
   /**
    * Executes a full end-to-end cross-chain swap.
    *
-   * Orchestrates the complete swap lifecycle:
-   * 1. Calls `createIntent` to submit the intent transaction on the source spoke chain.
-   * 2. Verifies the spoke transaction landed on-chain.
-   * 3. For non-hub source chains: submits the spoke tx to the relayer and waits for the
-   *    relay packet to land on the hub (Sonic). Skipped when `srcChainKey` is the hub.
-   * 4. Calls `postExecution` to notify the solver, triggering it to fill the intent.
-   *
-   * @param _params - Swap action params including intent parameters, wallet provider, and optional timeout.
+   * Orchestrates the complete swap lifecycle. `createIntent` first submits the intent transaction on
+   * the source spoke chain; completion then runs via one of two paths, both bounded by a single
+   * shared `timeout` budget:
+   *
+   * - **Client-side (default), {@link fallbackSwapSteps}:** verifies the spoke tx landed on-chain,
+   *   relays it to the hub (Sonic) and waits for the packet — skipped when `srcChainKey` is the hub,
+   *   where the spoke tx already is the hub tx — then calls `postExecution` to notify the solver,
+   *   triggering it to fill the intent.
+   * - **Backend 2-step (opt-in via `swapsOptions.useBackendSubmitTx`), {@link submitTx}:** hands the
+   *   broadcast tx to the swaps API, which verifies, relays and post-executes server-side, then polls
+   *   for completion. On ANY non-success it transparently falls back to the client-side path above —
+   *   safe because re-relaying / re-posting an already-processed swap is idempotent (no double-fill).
+   *
+   * @param _params - Swap action params including intent parameters, wallet provider, and an optional
+   *   `timeout` — the single shared budget for the whole completion flow (relay/poll plus any
+   *   fallback), so total wall-clock never exceeds it.
    * @returns A `Result<SwapResponse, SwapError>`. On success:
    *   - `solverExecutionResponse` — solver acknowledgement (`{ answer: 'OK', intent_hash }`).
    *   - `intent` — the on-chain intent object that was created.
@@ -26647,59 +26657,23 @@ var SwapService = class {
       "swap",
       async () => {
         try {
-          const timeout = _params.timeout;
           const createIntentResult = await this.createIntent(_params);
           if (!createIntentResult.ok) {
             return { ok: false, error: createIntentResult.error };
           }
-          const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
-          const verifyTxHashResult = await this.spoke.verifyTxHash({
-            txHash: spokeTxHash,
-            chainKey: srcChainKey
-          });
-          if (!verifyTxHashResult.ok) {
-            return { ok: false, error: verifyFailed("swap", verifyTxHashResult.error, { ...baseCtx, action: "swap" }) };
-          }
-          let dstIntentTxHash;
-          if (isHubChainKeyType(srcChainKey)) {
-            dstIntentTxHash = spokeTxHash;
-          } else {
-            const packet = await relayTxAndWaitPacket({
-              srcTxHash: spokeTxHash,
-              data: relayData,
-              chainKey: srcChainKey,
-              relayerApiEndpoint: this.relayerApiEndpoint,
-              timeout
-            });
-            if (!packet.ok) {
-              return {
-                ok: false,
-                error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx })
-              };
-            }
-            dstIntentTxHash = packet.value.dst_tx_hash;
-          }
-          const postExecResult = await this.postExecution({
-            intent_tx_hash: dstIntentTxHash
-          });
-          if (!postExecResult.ok) {
-            return { ok: false, error: postExecResult.error };
-          }
-          return {
-            ok: true,
-            value: {
-              solverExecutionResponse: postExecResult.value,
-              intent,
-              intentDeliveryInfo: {
-                srcChainKey,
-                srcTxHash: spokeTxHash,
-                srcAddress: params.srcAddress,
-                dstChainKey: params.dstChainKey,
-                dstTxHash: dstIntentTxHash,
-                dstAddress: params.dstAddress
+          const created = createIntentResult.value;
+          const deadline = Date.now() + (_params.timeout ?? DEFAULT_RELAY_TX_TIMEOUT);
+          if (this.useBackendSubmitTx) {
+            const submitted = await this.submitTx(_params, created, deadline);
+            if (submitted.ok) return submitted;
+            this.config.logger.warn(
+              "[swap] backend submit-tx did not complete; falling back to the client-side relay",
+              {
+                error: submitted.error
               }
-            }
-          };
+            );
+          }
+          return this.fallbackSwapSteps(_params, created, deadline);
         } catch (error) {
           if (isSwapError(error)) return { ok: false, error };
           return {
@@ -26725,6 +26699,134 @@ var SwapService = class {
       }
     );
   }
+  /**
+   * Client-side swap completion (the default path): relay the broadcast intent tx to the hub — or
+   * use it directly when the source IS the hub — then notify the solver via post-execution and
+   * build the {@link SwapResponse}. Extracted verbatim from `swap()` so the opt-in backend 2-step
+   * path ({@link submitTx}) can fall back to it on any non-success.
+   */
+  async fallbackSwapSteps(_params, created, deadline) {
+    const { params } = _params;
+    const srcChainKey = params.srcChainKey;
+    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey };
+    const { tx: spokeTxHash, intent, relayData } = created;
+    const verifyTxHashResult = await this.spoke.verifyTxHash({
+      txHash: created.tx,
+      chainKey: srcChainKey
+    });
+    if (!verifyTxHashResult.ok) {
+      return { ok: false, error: verifyFailed("swap", verifyTxHashResult.error, { ...baseCtx, action: "swap" }) };
+    }
+    let dstIntentTxHash;
+    if (isHubChainKeyType(srcChainKey)) {
+      dstIntentTxHash = spokeTxHash;
+    } else {
+      const packet = await relayTxAndWaitPacket({
+        srcTxHash: spokeTxHash,
+        data: relayData,
+        chainKey: srcChainKey,
+        relayerApiEndpoint: this.relayerApiEndpoint,
+        // Remaining shared budget: ≈ full `timeout` on the flag-off path (called immediately), or
+        // the reserve `submitTx` left on the backend path. Floor keeps a stalled-backend fallback viable.
+        timeout: Math.max(deadline - Date.now(), 5e3)
+      });
+      if (!packet.ok) {
+        return { ok: false, error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx }) };
+      }
+      dstIntentTxHash = packet.value.dst_tx_hash;
+    }
+    const postExecResult = await this.postExecution({
+      intent_tx_hash: dstIntentTxHash
+    });
+    if (!postExecResult.ok) {
+      return { ok: false, error: postExecResult.error };
+    }
+    return {
+      ok: true,
+      value: {
+        solverExecutionResponse: postExecResult.value,
+        intent,
+        intentDeliveryInfo: {
+          srcChainKey,
+          srcTxHash: spokeTxHash,
+          srcAddress: params.srcAddress,
+          dstChainKey: params.dstChainKey,
+          dstTxHash: dstIntentTxHash,
+          dstAddress: params.dstAddress
+        }
+      }
+    };
+  }
+  /**
+   * 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
+   * {@link SwapResponse} the client-side path returns (`result.dstIntentTxHash` → delivery info,
+   * `result.intent_hash` → solver response).
+   *
+   * Never throws — returns `{ ok: false }` on any non-success (submit `!ok`, terminal `failed` /
+   * abandoned, or poll timeout) so `swap()` falls back to {@link fallbackSwapSteps}.
+   *
+   * Falling back is safe: re-relaying / re-posting an already-processed swap is idempotent — the
+   * relay dedups and returns the existing `executed` packet, and the solver re-affirms the intent
+   * (no double-fill). Verified live by `e2e-tests/e2e-relay.test.ts`. Polling stops at
+   * `deadline - reserve` so the fallback keeps a guaranteed slice of the shared `swap` budget.
+   */
+  async submitTx(_params, created, deadline) {
+    const { params } = _params;
+    const srcChainKey = params.srcChainKey;
+    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey };
+    const { tx: spokeTxHash, intent, relayData } = created;
+    const submitTxFailed = (cause) => ({
+      ok: false,
+      error: executionFailed("swap", cause, { ...baseCtx, action: "swap" })
+    });
+    try {
+      const submitted = await this.backendApi.swaps.submitTx({
+        txHash: spokeTxHash,
+        srcChainKey,
+        walletAddress: params.srcAddress,
+        intent,
+        relayData: relayData.payload
+      });
+      if (!submitted.ok) return submitTxFailed(submitted.error);
+      const reserveMs = Math.min(Math.ceil((deadline - Date.now()) / 3), 2e4);
+      const pollDeadline = deadline - reserveMs;
+      const pollIntervalMs = 1e3;
+      while (Date.now() < pollDeadline) {
+        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) {
+            return {
+              ok: true,
+              value: {
+                // Backend serializes the hex intent_hash as a plain string; brand it at the boundary.
+                solverExecutionResponse: { answer: "OK", intent_hash: result.intent_hash },
+                intent,
+                intentDeliveryInfo: {
+                  srcChainKey,
+                  srcTxHash: spokeTxHash,
+                  srcAddress: params.srcAddress,
+                  dstChainKey: params.dstChainKey,
+                  dstTxHash: result.dstIntentTxHash,
+                  dstAddress: params.dstAddress
+                }
+              }
+            };
+          }
+          if (status === "failed" || abandonedAt) {
+            const reason = failureReason ? `: ${failureReason}` : "";
+            return submitTxFailed(new Error(`backend submit-tx ${status}${reason}`));
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      }
+      return submitTxFailed(new Error("backend submit-tx polling timed out before reaching executed"));
+    } catch (error) {
+      return { ok: false, error: unknownFailed("swap", error, { ...baseCtx, action: "swap" }) };
+    }
+  }
   /**
    * Checks whether the relevant spender contract is already approved to spend the input token amount.
    *
@@ -29447,71 +29549,883 @@ var MigrationService = class {
   }
 };
 
-// src/backendApi/BackendApiService.ts
-var BackendApiService = 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 || "";
+  const url = `${baseURL}${endpoint}`;
+  const headers = { ...config.headers, ...overrideConfig.headers };
+  const controller = new AbortController();
+  const timeout = overrideConfig.timeout ?? config.timeout ?? DEFAULT_BACKEND_API_TIMEOUT;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: config.method,
+      headers,
+      body: config.body,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error("HTTP_REQUEST_FAILED", { cause: new Error(`HTTP ${response.status}: ${errorText}`) });
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new Error("REQUEST_TIMEOUT", { cause: new Error(`Request timeout after ${timeout}ms`) });
+      }
+      logger.error(`[${serviceLabel}] Request error`, error);
+      throw error;
+    }
+    logger.error(`[${serviceLabel}] Unknown error`, error);
+    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 {
+  // Fully-resolved swaps-API config supplied by the caller (BackendApiService resolves the
+  // `ApiConfig` union via `resolveSwapsApiConfig`); this service does not resolve the union.
+  config;
+  headers;
+  logger;
   constructor(config, logger = consoleLogger) {
     this.config = config;
     this.headers = { ...config.headers };
     this.logger = logger;
   }
-  headers;
-  logger;
   /**
-   * Execute a single HTTP request and return the parsed JSON body.
-   *
-   * Applies an `AbortController`-backed timeout (falls back to `this.config.timeout`
-   * when `config.timeout` is absent). Throws on non-2xx status codes or when the
-   * request exceeds the timeout, so callers should use {@link request} instead of
-   * calling this directly.
-   *
-   * @throws `Error('HTTP_REQUEST_FAILED')` on non-2xx responses.
-   * @throws `Error('REQUEST_TIMEOUT')` when the request exceeds the timeout.
-   * @throws `Error('UNKNOWN_REQUEST_ERROR')` for any other unexpected failure.
+   * 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.
    */
-  async makeRequest(endpoint, config) {
-    const url = config.baseURL ? `${config.baseURL}${endpoint}` : `${this.config.baseURL}${endpoint}`;
-    const headers = { ...this.headers, ...config.headers };
-    const controller = new AbortController();
-    const timeout = config.timeout ?? this.config.timeout;
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
+  async request(endpoint, config, schema, overrideConfig) {
     try {
-      const response = await fetch(url, {
-        method: config.method,
-        headers,
-        body: config.body,
-        signal: controller.signal
+      const raw = await makeRequest({
+        endpoint,
+        config: { baseURL: this.config.baseURL, timeout: this.config.timeout, headers: this.headers, ...config },
+        overrideConfig,
+        logger: this.logger,
+        serviceLabel: "SwapsApiService"
       });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error("HTTP_REQUEST_FAILED", { cause: new Error(`HTTP ${response.status}: ${errorText}`) });
+      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) }
+          })
+        };
       }
-      const data = await response.json();
-      return data;
+      return { ok: true, value: parsed.output };
     } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new Error("REQUEST_TIMEOUT", { cause: new Error(`Request timeout after ${timeout}ms`) });
-        }
-        this.logger.error("[BackendApiService] Request error", error);
-        throw error;
-      }
-      this.logger.error("[BackendApiService] Unknown error", error);
-      throw new Error("UNKNOWN_REQUEST_ERROR", { cause: 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 }
+          }
+        )
+      };
     }
   }
+  // ──────────────────────────────────────────────────────────────────────
+  // Tokens
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch all supported swap tokens grouped by SpokeChainKey.
+   *
+   * @returns `Result<GetSwapTokensResponseV2>` — map of chain key → token list.
+   */
+  async getTokens(config) {
+    return this.request("/swaps/tokens", { method: "GET" }, GetSwapTokensResponseSchema, 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.
+   */
+  async getTokensByChain(chainKey, config) {
+    return this.request(
+      `/swaps/tokens/${chainKey}`,
+      { method: "GET" },
+      GetSwapTokensByChainResponseSchema,
+      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`.
+   */
+  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
+    );
+  }
+  /**
+   * Compute a swap deadline (hub timestamp + `offsetSeconds`, default 300s).
+   *
+   * @returns `Result<DeadlineResponseV2>` — unix-seconds deadline (decimal string).
+   */
+  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);
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Allowance · approve · create intent
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Check whether the source token allowance is already sufficient for the intent.
+   *
+   * @returns `Result<AllowanceCheckResponseV2>` — `{ valid }`.
+   */
+  async checkAllowance(body, config) {
+    return this.request(
+      "/swaps/allowance/check",
+      { method: "POST", body: toJsonBody(body) },
+      AllowanceCheckResponseSchema,
+      config
+    );
+  }
+  /**
+   * Build an unsigned token-approval transaction for the source token.
+   *
+   * @returns `Result<ApproveResponseV2>` — `{ tx }` (chain-specific unsigned tx).
+   */
+  async approve(body, config) {
+    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
+    return this.request(
+      "/swaps/approve",
+      { method: "POST", body: toJsonBody(body) },
+      makeApproveResponseSchema(txSchema),
+      config
+    );
+  }
+  /**
+   * Build an unsigned create-intent transaction.
+   *
+   * @returns `Result<CreateIntentResponseV2>` — `{ tx, intent, relayData }`.
+   */
+  async createIntent(body, config) {
+    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
+    return this.request(
+      "/swaps/intents",
+      { method: "POST", body: toJsonBody(body) },
+      makeCreateIntentResponseSchema(txSchema),
+      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).
+   */
+  async submitIntent(body, config) {
+    return this.request(
+      "/swaps/intents/submit",
+      { method: "POST", body: toJsonBody(body) },
+      SubmitIntentResponseSchema,
+      config
+    );
+  }
+  /**
+   * Poll the solver for intent execution status.
+   *
+   * @returns `Result<StatusResponseV2>` — `{ status, fillTxHash? }` (`fillTxHash` set when `status === 3`).
+   */
+  async getStatus(body, config) {
+    return this.request(
+      "/swaps/intents/status",
+      { method: "POST", body: toJsonBody(body) },
+      StatusResponseSchema,
+      config
+    );
+  }
+  /**
+   * Build an unsigned cancel-intent transaction. The `intent` field carries
+   * `bigint` numerics — {@link toJsonBody} serializes them to decimal strings.
+   *
+   * @returns `Result<CancelIntentResponseV2>` — `{ tx }`.
+   */
+  async cancelIntent(body, config) {
+    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
+    return this.request(
+      "/swaps/intents/cancel",
+      { method: "POST", body: toJsonBody(body) },
+      makeCancelIntentResponseSchema(txSchema),
+      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 }`.
+   */
+  async getIntentHash(body, config) {
+    return this.request(
+      "/swaps/intents/hash",
+      { method: "POST", body: toJsonBody(body) },
+      IntentHashResponseSchema,
+      config
+    );
+  }
+  /**
+   * Long-poll the relayer until the fill packet lands on the destination chain.
+   *
+   * @returns `Result<IntentPacketResponseV2>` — delivered packet data.
+   */
+  async getSolvedIntentPacket(body, config) {
+    return this.request(
+      "/swaps/intents/packet",
+      { method: "POST", body: toJsonBody(body) },
+      IntentPacketResponseSchema,
+      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 }`.
+   */
+  async getIntentSubmitTxExtraData(body, config) {
+    return this.request(
+      "/swaps/intents/extra-data",
+      { method: "POST", body: toJsonBody(body) },
+      RelayExtraDataResponseSchema,
+      config
+    );
+  }
+  /**
+   * Get the on-chain fill state for an intent by its hub-chain tx hash.
+   *
+   * @returns `Result<IntentStateV2>` — `{ exists, remainingInput, receivedOutput, pendingPayment }`.
+   */
+  async getFilledIntent(txHash, config) {
+    return this.request(`/swaps/intents/${txHash}/fill`, { method: "GET" }, IntentStateResponseSchema, config);
+  }
+  /**
+   * Look up an Intent struct by its hub-chain creation tx hash.
+   *
+   * @returns `Result<GetIntentResponseV2>` — the decoded intent (bigint fields as decimal strings).
+   */
+  async getIntent(txHash, config) {
+    return this.request(`/swaps/intents/${txHash}`, { method: "GET" }, IntentResponseSchema, 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 }`.
+   */
+  async createLimitOrderIntent(body, config) {
+    const txSchema = rawTxSchemaForChainKey(body.srcChainKey);
+    return this.request(
+      "/swaps/limit-orders",
+      { method: "POST", body: toJsonBody(body) },
+      makeCreateIntentResponseSchema(txSchema),
+      config
+    );
+  }
+  /**
+   * Estimate gas for a raw transaction on a spoke chain.
+   *
+   * @returns `Result<GasEstimateResponseV2>` — `{ gas }` (chain-specific shape).
+   */
+  async estimateGas(body, config) {
+    return this.request(
+      "/swaps/gas/estimate",
+      { method: "POST", body: toJsonBody(body) },
+      GasEstimateResponseSchema,
+      config
+    );
+  }
+  /**
+   * Compute the partner fee for a given input amount.
+   *
+   * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
+   */
+  async getPartnerFee(query, config) {
+    const queryParams = new URLSearchParams({ amount: query.amount });
+    return this.request(
+      `/swaps/fees/partner?${queryParams.toString()}`,
+      { method: "GET" },
+      FeeResponseSchema,
+      config
+    );
+  }
+  /**
+   * Compute the protocol (solver) fee for a given input amount.
+   *
+   * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
+   */
+  async getSolverFee(query, config) {
+    const queryParams = new URLSearchParams({ amount: query.amount });
+    return this.request(
+      `/swaps/fees/solver?${queryParams.toString()}`,
+      { method: "GET" },
+      FeeResponseSchema,
+      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 } }`.
+   */
+  async submitTx(body, config) {
+    return this.request(
+      "/swaps/submit-tx",
+      { method: "POST", body: toJsonBody(body) },
+      SubmitTxResponseSchema,
+      config
+    );
+  }
+  /**
+   * Get the processing status of a submitted swap transaction by `(txHash, srcChainKey)`.
+   *
+   * @returns `Result<SubmitTxStatusResponseV2>` — `{ success, data }` (processing state).
+   */
+  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
+    );
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Utilities (parity with BackendApiService)
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Merge additional headers into the service's default header set. Existing
+   * keys are overwritten; keys absent from `headers` are preserved.
+   */
+  setHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      this.headers[key] = value;
+    });
+  }
+  /** Return the base URL the service is currently pointing at. */
+  getBaseURL() {
+    return this.config.baseURL;
+  }
+};
+
+// src/backendApi/apiConfig.ts
+function isCustomApiConfig(config) {
+  return "baseApiConfig" in config || "swapsApiConfig" in config;
+}
+function layerConfigs(...slices) {
+  return slices.reduce(
+    (acc, slice) => slice ? {
+      baseURL: slice.baseURL ?? acc.baseURL,
+      timeout: slice.timeout ?? acc.timeout,
+      headers: { ...acc.headers, ...slice.headers }
+    } : acc,
+    {
+      baseURL: DEFAULT_BACKEND_API_ENDPOINT,
+      timeout: DEFAULT_BACKEND_API_TIMEOUT,
+      headers: { ...DEFAULT_BACKEND_API_HEADERS }
+    }
+  );
+}
+function resolveBaseApiConfig(config) {
+  if (isCustomApiConfig(config)) {
+    return layerConfigs(config.baseApiConfig);
+  }
+  return layerConfigs(config);
+}
+function resolveSwapsApiConfig(config) {
+  if (isCustomApiConfig(config)) {
+    return layerConfigs(config.baseApiConfig, config.swapsApiConfig);
+  }
+  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(),
+  chainKey: ChainKeySchema,
+  hubAsset: AddressSchema2,
+  vault: AddressSchema2,
+  access: v4__namespace.optional(v4__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 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(),
+  intent: IntentStructSchema,
+  events: v4__namespace.array(v4__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 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()
+      }),
+      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()
+      })
+    })
+  )
+});
+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 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 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 MoneyMarketAssetSuppliersSchema = v4__namespace.object({
+  suppliers: v4__namespace.array(v4__namespace.string()),
+  total: v4__namespace.number(),
+  offset: v4__namespace.number(),
+  limit: v4__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 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 TokensListSchema = v4__namespace.array(XTokenSchema);
+var ReserveAssetsSchema = v4__namespace.array(AddressSchema2);
+
+// src/backendApi/BackendApiService.ts
+var BackendApiService = class {
+  // sub-services exposing domain-specific APIs
+  swaps;
+  // resolved base-API slice of the ApiConfig union (flat config, or its `baseApiConfig`)
+  config;
+  headers;
+  logger;
+  constructor(config, logger = consoleLogger) {
+    this.config = resolveBaseApiConfig(config);
+    this.headers = { ...this.config.headers };
+    this.logger = logger;
+    this.swaps = new SwapsApiService(resolveSwapsApiConfig(config), this.logger);
+  }
   /**
    * Wraps {@link makeRequest} in a `Result<T>` so all errors are captured rather
    * than propagated as thrown exceptions. Every public endpoint method delegates
    * here instead of calling `makeRequest` directly.
    */
-  async request(endpoint, config) {
+  /**
+   * Fold any per-call override (carried on `config` alongside `method`/`body`) over the service
+   * defaults: baseURL truthy-fallback (an empty-string override defers to the default), timeout
+   * nullish-fallback, headers merged (override wins per key). Mirrors the original makeRequest merge.
+   */
+  resolveRequestConfig(config) {
+    const { baseURL, timeout, headers, ...rest } = config;
+    return {
+      ...rest,
+      baseURL: baseURL || this.config.baseURL,
+      timeout: timeout ?? this.config.timeout,
+      headers: { ...this.headers, ...headers }
+    };
+  }
+  /**
+   * Wrap a thrown transport failure (HTTP_REQUEST_FAILED / REQUEST_TIMEOUT / network error) as the
+   * canonical backend `SodaxError` — identical shape to SwapsApiService; the underlying failure is
+   * preserved on `error.cause`.
+   */
+  toExternalApiError(endpoint, error) {
+    return new SodaxError(
+      "EXTERNAL_API_ERROR",
+      error instanceof Error ? error.message : `Backend API request to ${endpoint} failed`,
+      { feature: "backend", cause: error, context: { api: "backend", endpoint } }
+    );
+  }
+  /**
+   * Issue a request and validate the JSON body against `schema`, wrapping the result in `Result<T>`.
+   * Mirrors {@link SwapsApiService}: a 2xx body that fails the schema is surfaced as
+   * `EXTERNAL_API_ERROR` (`context.reason: 'invalid_response_shape'`) rather than returned untyped.
+   * Every data/token/money-market method delegates here; the config/relay reads use
+   * {@link requestUnvalidated} instead.
+   */
+  async request(endpoint, config, schema) {
+    try {
+      const raw = await makeRequest({
+        endpoint,
+        config: this.resolveRequestConfig(config),
+        logger: this.logger,
+        serviceLabel: "BackendApiService"
+      });
+      const parsed = v4__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) }
+          })
+        };
+      }
+      return { ok: true, value: parsed.output };
+    } catch (error) {
+      return { ok: false, error: this.toExternalApiError(endpoint, error) };
+    }
+  }
+  /**
+   * Issue a request WITHOUT response-shape validation (passthrough typing). Reserved for the
+   * config/relay reads whose shapes are too large/brittle to schema-validate (`SodaxConfig` via
+   * `getAllConfig`, `SpokeChainConfigMap` via `getSpokeChainConfig`) or carry `bigint` values that
+   * cannot survive JSON validation (`getRelayChainIdMap`). `ConfigService` version-gates and falls
+   * back to packaged defaults, so it relies on no response-shape guarantee from these endpoints.
+   */
+  async requestUnvalidated(endpoint, config) {
     try {
-      const value = await this.makeRequest(endpoint, config);
+      const value = await makeRequest({
+        endpoint,
+        config: this.resolveRequestConfig(config),
+        logger: this.logger,
+        serviceLabel: "BackendApiService"
+      });
       return { ok: true, value };
     } catch (error) {
-      return { ok: false, error };
+      return { ok: false, error: this.toExternalApiError(endpoint, error) };
     }
   }
   // Intent endpoints
@@ -29526,7 +30440,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" });
+    return this.request(`/intent/tx/${txHash}`, { ...config, method: "GET" }, IntentResponseSchema2);
   }
   /**
    * Fetch a swap intent by its canonical intent hash.
@@ -29535,58 +30449,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" });
-  }
-  // Swap submit-tx endpoints
-  /**
-   * Submit a signed spoke-chain swap transaction to the backend for processing.
-   *
-   * The backend relays the transaction to the hub chain, posts execution data
-   * to the solver, and advances the intent through its lifecycle. The response
-   * shape is validated at runtime via a type guard; an invalid shape is
-   * returned as `{ ok: false }`.
-   *
-   * @param params - The signed transaction hash, source chain key, sender wallet
-   *   address, intent data, and relay data required to process the swap.
-   * @returns `Result<SubmitSwapTxResponse>` — on success, a confirmation object
-   *   with `success: true` and a human-readable `message`.
-   */
-  async submitSwapTx(params, config) {
-    const result = await this.request("/swaps/submit-tx", {
-      ...config,
-      method: "POST",
-      body: JSON.stringify(params)
-    });
-    if (!result.ok) return result;
-    if (!isSubmitSwapTxResponse(result.value)) {
-      return { ok: false, error: new Error("Invalid submitSwapTx response: unexpected response shape") };
-    }
-    return { ok: true, value: result.value };
-  }
-  /**
-   * Poll the backend relay pipeline for the current status of a previously
-   * submitted swap transaction.
-   *
-   * Status progresses through: `pending` → `verifying` → `verified` →
-   * `relaying` → `relayed` → `posting_execution` → `executed` (or `failed`).
-   *
-   * @param params - Object containing the source-chain transaction hash and,
-   *   optionally, the source chain key to disambiguate cross-chain hashes.
-   * @returns `Result<SubmitSwapTxStatusResponse>` — on success, includes the
-   *   current `status`, any `failureReason`, and (once executed) the
-   *   `dstIntentTxHash` on the hub chain.
-   */
-  async getSubmitSwapTxStatus(params, config) {
-    const queryParams = new URLSearchParams();
-    queryParams.append("txHash", params.txHash);
-    if (params.srcChainKey) queryParams.append("srcChainKey", params.srcChainKey);
-    const endpoint = `/swaps/submit-tx/status?${queryParams.toString()}`;
-    const result = await this.request(endpoint, { ...config, method: "GET" });
-    if (!result.ok) return result;
-    if (!isSubmitSwapTxStatusResponse(result.value)) {
-      return { ok: false, error: new Error("Invalid submitSwapTxStatus response: unexpected response shape") };
-    }
-    return { ok: true, value: result.value };
+    return this.request(`/intent/${intentHash}`, { ...config, method: "GET" }, IntentResponseSchema2);
   }
   // Solver endpoints
   /**
@@ -29603,7 +30466,7 @@ var BackendApiService = class {
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/solver/orderbook?${queryString}`;
-    return this.request(endpoint, { ...config, method: "GET" });
+    return this.request(endpoint, { ...config, method: "GET" }, OrderbookResponseSchema);
   }
   /**
    * Fetch all swap intents created by a specific wallet address, with optional
@@ -29629,7 +30492,7 @@ var BackendApiService = class {
     if (offset) queryParams.append("offset", offset);
     const queryString = queryParams.toString();
     const endpoint = queryString.length > 0 ? `/intent/user/${userAddress}?${queryString}` : `/intent/user/${userAddress}`;
-    return this.request(endpoint, { ...config, method: "GET" });
+    return this.request(endpoint, { ...config, method: "GET" }, UserIntentsResponseSchema);
   }
   // Money Market endpoints
   /**
@@ -29644,7 +30507,11 @@ var BackendApiService = class {
    *   position across all active reserves.
    */
   async getMoneyMarketPosition(userAddress, config) {
-    return this.request(`/moneymarket/position/${userAddress}`, { ...config, method: "GET" });
+    return this.request(
+      `/moneymarket/position/${userAddress}`,
+      { ...config, method: "GET" },
+      MoneyMarketPositionSchema
+    );
   }
   /**
    * Fetch the on-chain state for every active money market reserve asset.
@@ -29653,7 +30520,7 @@ var BackendApiService = class {
    *   snapshots including interest rates, liquidity indices, and participant counts.
    */
   async getAllMoneyMarketAssets(config) {
-    return this.request("/moneymarket/asset/all", { ...config, method: "GET" });
+    return this.request("/moneymarket/asset/all", { ...config, method: "GET" }, MoneyMarketAssetsSchema);
   }
   /**
    * Fetch the on-chain state for a single money market reserve asset.
@@ -29663,7 +30530,11 @@ var BackendApiService = class {
    *   including interest rates, total balances, and liquidity indices.
    */
   async getMoneyMarketAsset(reserveAddress, config) {
-    return this.request(`/moneymarket/asset/${reserveAddress}`, { ...config, method: "GET" });
+    return this.request(
+      `/moneymarket/asset/${reserveAddress}`,
+      { ...config, method: "GET" },
+      MoneyMarketAssetSchema
+    );
   }
   /**
    * Fetch a paginated list of wallets that currently have an outstanding borrow
@@ -29680,7 +30551,7 @@ var BackendApiService = class {
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/asset/${reserveAddress}/borrowers?${queryString}`;
-    return this.request(endpoint, { ...config, method: "GET" });
+    return this.request(endpoint, { ...config, method: "GET" }, MoneyMarketAssetBorrowersSchema);
   }
   /**
    * Fetch a paginated list of wallets that currently have an active supply
@@ -29697,7 +30568,7 @@ var BackendApiService = class {
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/asset/${reserveAddress}/suppliers?${queryString}`;
-    return this.request(endpoint, { ...config, method: "GET" });
+    return this.request(endpoint, { ...config, method: "GET" }, MoneyMarketAssetSuppliersSchema);
   }
   /**
    * Fetch a paginated list of all wallet addresses that hold an active borrow
@@ -29713,7 +30584,7 @@ var BackendApiService = class {
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/borrowers?${queryString}`;
-    return this.request(endpoint, { ...config, method: "GET" });
+    return this.request(endpoint, { ...config, method: "GET" }, MoneyMarketBorrowersSchema);
   }
   /**
    * Fetch the complete SODAX runtime configuration in a single request.
@@ -29726,7 +30597,7 @@ var BackendApiService = class {
    *   `config` is the current `SodaxConfig` used by all SDK services.
    */
   async getAllConfig(config) {
-    return this.request("/config/all", { ...config, method: "GET" });
+    return this.requestUnvalidated("/config/all", { ...config, method: "GET" });
   }
   /**
    * Fetch the list of spoke chain keys that are currently supported by the
@@ -29739,7 +30610,7 @@ var BackendApiService = class {
    *   `SpokeChainKey` strings (e.g. `["ethereum", "arbitrum", "solana", …]`).
    */
   async getChains(config) {
-    return this.request("/config/spoke/chains", { ...config, method: "GET" });
+    return this.request("/config/spoke/chains", { ...config, method: "GET" }, GetChainsResponseSchema);
   }
   /**
    * Fetch the full map of tokens available for swapping, keyed by spoke chain.
@@ -29751,7 +30622,7 @@ var BackendApiService = class {
    *   supported spoke chain key to its list of swappable `XToken` definitions.
    */
   async getSwapTokens(config) {
-    return this.request("/config/swap/tokens", { ...config, method: "GET" });
+    return this.request("/config/swap/tokens", { ...config, method: "GET" }, TokensByChainMapSchema);
   }
   /**
    * Fetch the list of tokens available for swapping on a specific spoke chain.
@@ -29763,10 +30634,7 @@ var BackendApiService = class {
    *   array of `XToken` definitions supported for swapping on that chain.
    */
   async getSwapTokensByChainId(chainId, config) {
-    return this.request(`/config/swap/${chainId}/tokens`, {
-      ...config,
-      method: "GET"
-    });
+    return this.request(`/config/swap/${chainId}/tokens`, { ...config, method: "GET" }, TokensListSchema);
   }
   /**
    * Fetch the full map of tokens available in the money market (lending/borrowing),
@@ -29778,10 +30646,7 @@ var BackendApiService = class {
    *   each supported spoke chain key to its list of money-market `XToken` definitions.
    */
   async getMoneyMarketTokens(config) {
-    return this.request("/config/money-market/tokens", {
-      ...config,
-      method: "GET"
-    });
+    return this.request("/config/money-market/tokens", { ...config, method: "GET" }, TokensByChainMapSchema);
   }
   /**
    * Fetch the list of hub-chain reserve asset addresses registered in the
@@ -29795,10 +30660,11 @@ var BackendApiService = class {
    *   readonly array of reserve `Address` strings.
    */
   async getMoneyMarketReserveAssets(config) {
-    return this.request("/config/money-market/reserve-assets", {
-      ...config,
-      method: "GET"
-    });
+    return this.request(
+      "/config/money-market/reserve-assets",
+      { ...config, method: "GET" },
+      ReserveAssetsSchema
+    );
   }
   /**
    * Fetch the list of tokens available for lending/borrowing on a specific
@@ -29811,10 +30677,11 @@ var BackendApiService = class {
    *   readonly array of `XToken` definitions supported in the money market on that chain.
    */
   async getMoneyMarketTokensByChainId(chainId, config) {
-    return this.request(`/config/money-market/${chainId}/tokens`, {
-      ...config,
-      method: "GET"
-    });
+    return this.request(
+      `/config/money-market/${chainId}/tokens`,
+      { ...config, method: "GET" },
+      TokensListSchema
+    );
   }
   /**
    * Fetch the mapping from spoke chain keys to the numeric chain IDs used by
@@ -29828,7 +30695,7 @@ var BackendApiService = class {
    *   `IntentRelayChainIdMap` record mapping each spoke chain key to its relay chain ID.
    */
   async getRelayChainIdMap(config) {
-    return this.request("/config/relay/chain-id-map", {
+    return this.requestUnvalidated("/config/relay/chain-id-map", {
       ...config,
       method: "GET"
     });
@@ -29845,7 +30712,7 @@ var BackendApiService = class {
    *   `SpokeChainConfigMap` for all currently enabled spoke chains.
    */
   async getSpokeChainConfig(config) {
-    return this.request("/config/spoke/all-chains-configs", {
+    return this.requestUnvalidated("/config/spoke/all-chains-configs", {
       ...config,
       method: "GET"
     });
@@ -29857,12 +30724,17 @@ var BackendApiService = class {
    * without constructing a new service instance. Existing header keys are
    * overwritten; keys absent from `headers` are preserved.
    *
+   * The headers are also fanned out to the sub-services (`swaps`), which hold
+   * their own header copies — so a token set here applies to every request made
+   * through this client, including `swaps.*`.
+   *
    * @param headers - Key-value pairs to add or overwrite in the default headers.
    */
   setHeaders(headers) {
     Object.entries(headers).forEach(([key, value]) => {
       this.headers[key] = value;
     });
+    this.swaps.setHeaders(headers);
   }
   /**
    * Return the base URL the service is currently pointing at.
@@ -38582,7 +39454,7 @@ var LeverageYieldService = class {
   }
   /** Looks up a vault by its `name` field. Returns `undefined` when not registered. */
   getVault(name) {
-    return this.listVaults().find((v) => v.name === name);
+    return this.listVaults().find((v6) => v6.name === name);
   }
   /**
    * Looks up a registered vault by its on-chain proxy address (case-insensitive).
@@ -38590,7 +39462,7 @@ var LeverageYieldService = class {
    */
   getVaultByAddress(address) {
     const normalized = address.toLowerCase();
-    return this.listVaults().find((v) => v.vault.toLowerCase() === normalized);
+    return this.listVaults().find((v6) => v6.vault.toLowerCase() === normalized);
   }
   /**
    * Resolves the intent `deadline`: returns the caller-supplied value verbatim, otherwise
@@ -39383,6 +40255,8 @@ var Sodax = class {
   // ICX migration service enabling ICX migration to SODA
   backendApi;
   // backend API service enabling backend API endpoints
+  api;
+  // syntactic sugar for backend API service
   bridge;
   // Bridge service enabling cross-chain transfers
   staking;
@@ -39405,8 +40279,10 @@ var Sodax = class {
     const logger = resolveLogger(options?.logger);
     const analytics = resolveAnalytics(options?.analytics);
     const fee = options?.fee;
+    const useBackendSubmitTx = options?.swapsOptions?.useBackendSubmitTx ?? false;
     this.instanceConfig = options ? mergeSodaxConfig(sodaxConfig, options) : sodaxConfig;
     this.backendApi = new BackendApiService(this.instanceConfig.api, logger);
+    this.api = this.backendApi;
     this.config = new ConfigService({
       api: this.backendApi,
       config: this.instanceConfig,
@@ -39420,7 +40296,9 @@ var Sodax = class {
     this.swaps = new SwapService({
       config: this.config,
       hubProvider: this.hubProvider,
-      spoke: this.spoke
+      spoke: this.spoke,
+      backendApi: this.backendApi,
+      useBackendSubmitTx
     });
     this.moneyMarket = new MoneyMarketService({
       config: this.config,
@@ -39620,6 +40498,7 @@ exports.StellarSpokeService = StellarSpokeService;
 exports.SuiSpokeService = SuiSpokeService;
 exports.SupportedMigrationTokens = SupportedMigrationTokens;
 exports.SwapService = SwapService;
+exports.SwapsApiService = SwapsApiService;
 exports.USD_DECIMALS = USD_DECIMALS;
 exports.UiPoolDataProviderService = UiPoolDataProviderService;
 exports.VAULT_TOKEN_DECIMALS = VAULT_TOKEN_DECIMALS;
@@ -39820,8 +40699,6 @@ exports.isStakingOrchestrationError = isStakingOrchestrationError;
 exports.isStellarChainKey = isStellarChainKey;
 exports.isStellarChainKeyType = isStellarChainKeyType;
 exports.isStellarWalletProviderType = isStellarWalletProviderType;
-exports.isSubmitSwapTxResponse = isSubmitSwapTxResponse;
-exports.isSubmitSwapTxStatusResponse = isSubmitSwapTxStatusResponse;
 exports.isSuiChainKey = isSuiChainKey;
 exports.isSuiChainKeyType = isSuiChainKeyType;
 exports.isSupportedBitcoinAddressType = isSupportedBitcoinAddressType;