@sodax/sdk 2.0.0-rc.17 → 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 = 215;
+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);
@@ -10649,6 +10632,144 @@ var ProtocolIntentsAbi = [
       }
     ],
     stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "cancelIntent",
+    inputs: [
+      {
+        name: "fromToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "toToken",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getUserIntent",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "fromToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "toToken",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "intentHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getIntentDetails",
+    inputs: [
+      {
+        name: "intentHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "intent",
+        type: "tuple",
+        internalType: "struct Intents.Intent",
+        components: [
+          {
+            name: "intentId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "creator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "inputToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "outputToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "inputAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "minOutputAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "deadline",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "allowPartialFill",
+            type: "bool",
+            internalType: "bool"
+          },
+          {
+            name: "srcChain",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "dstChain",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "srcAddress",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "dstAddress",
+            type: "bytes",
+            internalType: "bytes"
+          },
+          {
+            name: "solver",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "data",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
   }
 ];
 
@@ -13506,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),
@@ -13556,16 +13654,85 @@ function resolveLogger(option) {
   return option;
 }
 
+// src/shared/analytics.ts
+var noopAnalytics = {
+  isEnabled: () => false,
+  emit: () => {
+  },
+  trackResult: (_feature, _action, run) => run()
+};
+var LEVEL_RANK = { basic: 0, detailed: 1 };
+function normalizeFeatures(features) {
+  if (features === void 0) return null;
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(features)) {
+    for (const feature of features) map.set(feature, true);
+  } else {
+    for (const [feature, scope] of Object.entries(features)) {
+      if (scope === true) map.set(feature, true);
+      else if (scope) map.set(feature, new Set(scope.actions));
+    }
+  }
+  return map;
+}
+function resolveAnalytics(option) {
+  if (!option) return noopAnalytics;
+  const { tracker, level: configuredLevel = "basic", features } = option;
+  const maxRank = LEVEL_RANK[configuredLevel];
+  const allow = normalizeFeatures(features);
+  const isEnabled = (feature, action, level = "basic") => {
+    if (LEVEL_RANK[level] > maxRank) return false;
+    if (allow === null) return true;
+    const scope = allow.get(feature);
+    if (scope === void 0) return false;
+    if (scope === true) return true;
+    if (action === void 0) return scope.size > 0;
+    return scope.has(action);
+  };
+  const emit = (feature, action, phase, build, level = "basic") => {
+    if (!isEnabled(feature, action, level)) return;
+    try {
+      tracker({ feature, action, phase, level, data: build?.() });
+    } catch {
+    }
+  };
+  const trackResult = async (feature, action, run, data) => {
+    emit(feature, action, "start", data?.start);
+    try {
+      const result = await run();
+      if (result.ok) {
+        const build = data?.success;
+        emit(feature, action, "success", build ? () => build(result.value) : void 0);
+      } else {
+        const build = data?.failure;
+        emit(feature, action, "failure", build ? () => build(result.error) : void 0);
+      }
+      return result;
+    } catch (error) {
+      emit(feature, action, "failure", () => ({ error: error instanceof Error ? error.message : String(error) }));
+      throw error;
+    }
+  };
+  return { isEnabled, emit, trackResult };
+}
+
 // 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`.
    */
   logger;
+  /**
+   * Analytics emitter. 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.analytics`;
+   * disabled (no-op) unless the consumer passed an `analytics` config to `new Sodax(...)`.
+   */
+  analytics;
   /**
    * Global partner fee. Resolved once at construction and kept independent of {@link sodax} so that
    * {@link initialize}'s dynamic-config swap never clobbers it. The backend never supplies it — it is
@@ -13583,29 +13750,17 @@ var ConfigService = class {
   stakedATokenAddressesSet;
   chainToSupportedTokenAddressMap;
   hubAssetToXTokenMap;
-  constructor({ api, config, userConfig, logger, fee }) {
-    this.api = api;
+  // `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.sodax = config;
-    this.userConfig = userConfig;
     this.logger = logger ?? resolveLogger(void 0);
+    this.analytics = analytics ?? noopAnalytics;
     this.fee = fee;
     this.loadSodaxConfigDataStructures(config);
   }
   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 };
@@ -13638,6 +13793,16 @@ var ConfigService = class {
   getOriginalAssetAddress(chainId, hubAsset) {
     return this.hubAssetToXTokenMap.get(hubAsset.toLowerCase())?.address;
   }
+  /**
+   * Resolves the {@link XToken} descriptor (hub asset, vault, decimals) for a hub-asset address.
+   *
+   * Useful when a caller holds a hub asset directly on Sonic that has no spoke-token entry under
+   * the hub chain — e.g. a partner BTC fee held as the BTC hub asset, which only exists as a spoke
+   * token on Bitcoin. Returns `undefined` when the address is not a known hub asset.
+   */
+  getXTokenFromHubAsset(hubAsset) {
+    return this.hubAssetToXTokenMap.get(hubAsset.toLowerCase());
+  }
   getSpokeTokenFromOriginalAssetAddress(chainId, originalAssetAddress) {
     return this.supportedTokensPerChain.get(chainId)?.find((token) => token.address.toLowerCase() === originalAssetAddress.toLowerCase());
   }
@@ -13865,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) {
@@ -15548,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
    */
@@ -15817,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));
@@ -15825,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;
@@ -16457,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)
@@ -16480,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);
   };
@@ -16498,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);
 }
@@ -16548,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) {
@@ -16580,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;
@@ -17057,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
@@ -17164,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 };
     }
@@ -17262,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;
@@ -17603,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;
@@ -17940,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) {
@@ -17969,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]);
@@ -18141,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,
@@ -18712,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))
@@ -18891,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;
     }
@@ -26244,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.
@@ -26394,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.
@@ -26425,63 +26652,179 @@ var SwapService = class {
     const { params } = _params;
     const srcChainKey = params.srcChainKey;
     const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey };
-    try {
-      const timeout = _params.timeout;
-      const createIntentResult = await this.createIntent(_params);
-      if (!createIntentResult.ok) {
-        return { ok: false, error: createIntentResult.error };
+    return this.config.analytics.trackResult(
+      "swap",
+      "swap",
+      async () => {
+        try {
+          const createIntentResult = await this.createIntent(_params);
+          if (!createIntentResult.ok) {
+            return { ok: false, error: createIntentResult.error };
+          }
+          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 {
+            ok: false,
+            error: unknownFailed("swap", error, { ...baseCtx, action: "swap" })
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey,
+          dstChainKey: params.dstChainKey,
+          srcAddress: params.srcAddress,
+          dstAddress: params.dstAddress
+        }),
+        success: (value) => ({
+          srcChainKey,
+          dstChainKey: params.dstChainKey,
+          srcTxHash: value.intentDeliveryInfo.srcTxHash,
+          dstTxHash: value.intentDeliveryInfo.dstTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
-      const verifyTxHashResult = await this.spoke.verifyTxHash({
-        txHash: spokeTxHash,
-        chainKey: srcChainKey
+    );
+  }
+  /**
+   * 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 (!verifyTxHashResult.ok) {
-        return { ok: false, error: verifyFailed("swap", verifyTxHashResult.error, { ...baseCtx, action: "swap" }) };
+      if (!packet.ok) {
+        return { ok: false, error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx }) };
       }
-      let dstIntentTxHash;
-      if (isHubChainKeyType(srcChainKey)) {
-        dstIntentTxHash = spokeTxHash;
-      } else {
-        const packet = await relayTxAndWaitPacket({
+      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,
-          data: relayData,
-          chainKey: srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packet.ok) {
-          return { ok: false, error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx }) };
+          srcAddress: params.srcAddress,
+          dstChainKey: params.dstChainKey,
+          dstTxHash: dstIntentTxHash,
+          dstAddress: params.dstAddress
         }
-        dstIntentTxHash = packet.value.dst_tx_hash;
       }
-      const postExecResult = await this.postExecution({
-        intent_tx_hash: dstIntentTxHash
+    };
+  }
+  /**
+   * 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 (!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
+      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) {
-      if (isSwapError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: unknownFailed("swap", error, { ...baseCtx, action: "swap" })
-      };
+      return { ok: false, error: unknownFailed("swap", error, { ...baseCtx, action: "swap" }) };
     }
   }
   /**
@@ -28528,72 +28871,94 @@ var MigrationService = class {
    * }
    */
   async migratebnUSD(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = {
-      srcChainKey: params.srcChainKey,
-      dstChainKey: params.dstChainKey,
-      action: "migratebnUSD"
-    };
-    try {
-      const intentResult = await this.createMigratebnUSDIntent(_params);
-      if (!intentResult.ok) return { ok: false, error: intentResult.error };
-      const { tx: spokeTxHash, relayData: extraData } = intentResult.value;
-      const verifyTxHashResult = await this.spoke.verifyTxHash({
-        txHash: spokeTxHash,
-        chainKey: params.srcChainKey
-      });
-      if (!verifyTxHashResult.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("migration", verifyTxHashResult.error, baseCtx)
-        };
-      }
-      const packetResult = await relayTxAndWaitPacket({
-        srcTxHash: spokeTxHash,
-        data: extraData,
-        chainKey: params.srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packetResult.ok) {
-        return {
-          ok: false,
-          error: mapRelayFailure(packetResult.error, {
-            feature: "migration",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
+    return this.config.analytics.trackResult(
+      "migration",
+      "migratebnUSD",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = {
+          srcChainKey: params.srcChainKey,
+          dstChainKey: params.dstChainKey,
+          action: "migratebnUSD"
         };
-      }
-      if (!(params.srcChainKey === ChainKeys.SONIC_MAINNET || params.dstChainKey === ChainKeys.SONIC_MAINNET)) {
-        const execResult = await waitUntilIntentExecuted({
-          intentRelayChainId: getIntentRelayChainId(ChainKeys.SONIC_MAINNET).toString(),
-          srcTxHash: packetResult.value.dst_tx_hash,
-          timeout,
-          apiUrl: this.relayerApiEndpoint
-        });
-        if (!execResult.ok) {
+        try {
+          const intentResult = await this.createMigratebnUSDIntent(_params);
+          if (!intentResult.ok) return { ok: false, error: intentResult.error };
+          const { tx: spokeTxHash, relayData: extraData } = intentResult.value;
+          const verifyTxHashResult = await this.spoke.verifyTxHash({
+            txHash: spokeTxHash,
+            chainKey: params.srcChainKey
+          });
+          if (!verifyTxHashResult.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("migration", verifyTxHashResult.error, baseCtx)
+            };
+          }
+          const packetResult = await relayTxAndWaitPacket({
+            srcTxHash: spokeTxHash,
+            data: extraData,
+            chainKey: params.srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packetResult.ok) {
+            return {
+              ok: false,
+              error: mapRelayFailure(packetResult.error, {
+                feature: "migration",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          }
+          if (!(params.srcChainKey === ChainKeys.SONIC_MAINNET || params.dstChainKey === ChainKeys.SONIC_MAINNET)) {
+            const execResult = await waitUntilIntentExecuted({
+              intentRelayChainId: getIntentRelayChainId(ChainKeys.SONIC_MAINNET).toString(),
+              srcTxHash: packetResult.value.dst_tx_hash,
+              timeout,
+              apiUrl: this.relayerApiEndpoint
+            });
+            if (!execResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(execResult.error, {
+                  feature: "migration",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey,
+                  dstChainKey: baseCtx.dstChainKey,
+                  phase: "destinationExecution"
+                })
+              };
+            }
+          }
+          return { ok: true, value: { srcChainTxHash: spokeTxHash, dstChainTxHash: packetResult.value.dst_tx_hash } };
+        } catch (error) {
+          if (isMigrateOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(execResult.error, {
-              feature: "migration",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey,
-              dstChainKey: baseCtx.dstChainKey,
-              phase: "destinationExecution"
-            })
+            error: executionFailed("migration", error, baseCtx)
           };
         }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          dstChainKey: _params.params.dstChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstAddress: _params.params.dstAddress,
+          srcbnUSD: _params.params.srcbnUSD,
+          dstbnUSD: _params.params.dstbnUSD,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: spokeTxHash, dstChainTxHash: packetResult.value.dst_tx_hash } };
-    } catch (error) {
-      if (isMigrateOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("migration", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Migrates ICX or wICX tokens from ICON to SODA on the hub chain (Sonic), including relay.
@@ -28608,37 +28973,57 @@ var MigrationService = class {
    *   check fails, the deposit reverts, or the relay times out.
    */
   async migrateIcxToSoda(_params) {
-    const { timeout } = _params;
-    const baseCtx = { srcChainKey: _params.params.srcChainKey, action: "migrateIcxToSoda" };
-    try {
-      const txResult = await this.createMigrateIcxToSodaIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const { tx, relayData } = txResult.value;
-      const packetResult = await relayTxAndWaitPacket({
-        srcTxHash: tx,
-        data: relayData,
-        chainKey: _params.params.srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packetResult.ok) {
-        return {
-          ok: false,
-          error: mapRelayFailure(packetResult.error, {
-            feature: "migration",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey
-          })
-        };
+    return this.config.analytics.trackResult(
+      "migration",
+      "migrateIcxToSoda",
+      async () => {
+        const { timeout } = _params;
+        const baseCtx = { srcChainKey: _params.params.srcChainKey, action: "migrateIcxToSoda" };
+        try {
+          const txResult = await this.createMigrateIcxToSodaIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const { tx, relayData } = txResult.value;
+          const packetResult = await relayTxAndWaitPacket({
+            srcTxHash: tx,
+            data: relayData,
+            chainKey: _params.params.srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packetResult.ok) {
+            return {
+              ok: false,
+              error: mapRelayFailure(packetResult.error, {
+                feature: "migration",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey
+              })
+            };
+          }
+          return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
+        } catch (error) {
+          if (isMigrateOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("migration", error, baseCtx)
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstAddress: _params.params.dstAddress,
+          address: _params.params.address,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
-    } catch (error) {
-      if (isMigrateOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("migration", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Reverts a previous ICX→SODA migration by swapping SODA back to wICX on the hub and
@@ -28656,37 +29041,56 @@ var MigrationService = class {
    *   Sonic deposit transaction and `dstChainTxHash` is the hub-side packet receipt.
    */
   async revertMigrateSodaToIcx(_params) {
-    const { timeout } = _params;
-    const baseCtx = { srcChainKey: ChainKeys.SONIC_MAINNET, action: "revertMigrateSodaToIcx" };
-    try {
-      const txResult = await this.createRevertSodaToIcxMigrationIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const { tx, relayData } = txResult.value;
-      const packetResult = await relayTxAndWaitPacket({
-        srcTxHash: tx,
-        data: relayData,
-        chainKey: ChainKeys.SONIC_MAINNET,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packetResult.ok) {
-        return {
-          ok: false,
-          error: mapRelayFailure(packetResult.error, {
-            feature: "migration",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey
-          })
-        };
+    return this.config.analytics.trackResult(
+      "migration",
+      "revertMigrateSodaToIcx",
+      async () => {
+        const { timeout } = _params;
+        const baseCtx = { srcChainKey: ChainKeys.SONIC_MAINNET, action: "revertMigrateSodaToIcx" };
+        try {
+          const txResult = await this.createRevertSodaToIcxMigrationIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const { tx, relayData } = txResult.value;
+          const packetResult = await relayTxAndWaitPacket({
+            srcTxHash: tx,
+            data: relayData,
+            chainKey: ChainKeys.SONIC_MAINNET,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packetResult.ok) {
+            return {
+              ok: false,
+              error: mapRelayFailure(packetResult.error, {
+                feature: "migration",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey
+              })
+            };
+          }
+          return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
+        } catch (error) {
+          if (isRevertMigrationOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("migration", error, baseCtx)
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstAddress: _params.params.dstAddress,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
-    } catch (error) {
-      if (isRevertMigrationOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("migration", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Migrates BALN tokens from ICON to SODA on the hub chain (Sonic), including relay.
@@ -28703,37 +29107,58 @@ var MigrationService = class {
    *   ICON deposit transaction and `dstChainTxHash` is the hub-side packet receipt.
    */
   async migrateBaln(_params) {
-    const { timeout } = _params;
-    const baseCtx = { srcChainKey: ChainKeys.ICON_MAINNET, action: "migrateBaln" };
-    try {
-      const txResult = await this.createMigrateBalnIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const { tx, relayData } = txResult.value;
-      const packetResult = await relayTxAndWaitPacket({
-        srcTxHash: tx,
-        data: relayData,
-        chainKey: ChainKeys.ICON_MAINNET,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packetResult.ok) {
-        return {
-          ok: false,
-          error: mapRelayFailure(packetResult.error, {
-            feature: "migration",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey
-          })
-        };
+    return this.config.analytics.trackResult(
+      "migration",
+      "migrateBaln",
+      async () => {
+        const { timeout } = _params;
+        const baseCtx = { srcChainKey: ChainKeys.ICON_MAINNET, action: "migrateBaln" };
+        try {
+          const txResult = await this.createMigrateBalnIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const { tx, relayData } = txResult.value;
+          const packetResult = await relayTxAndWaitPacket({
+            srcTxHash: tx,
+            data: relayData,
+            chainKey: ChainKeys.ICON_MAINNET,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packetResult.ok) {
+            return {
+              ok: false,
+              error: mapRelayFailure(packetResult.error, {
+                feature: "migration",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey
+              })
+            };
+          }
+          return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
+        } catch (error) {
+          if (isMigrateOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("migration", error, baseCtx)
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstAddress: _params.params.dstAddress,
+          amount: _params.params.amount,
+          lockupPeriod: _params.params.lockupPeriod,
+          stake: _params.params.stake
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: tx, dstChainTxHash: packetResult.value.dst_tx_hash } };
-    } catch (error) {
-      if (isMigrateOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("migration", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Builds and submits the spoke-side deposit for a BALN→SODA migration without relaying.
@@ -29124,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
@@ -29203,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.
@@ -29212,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
   /**
@@ -29280,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
@@ -29306,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
   /**
@@ -29321,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.
@@ -29330,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.
@@ -29340,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
@@ -29357,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
@@ -29374,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
@@ -29390,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.
@@ -29403,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
@@ -29416,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.
@@ -29428,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.
@@ -29440,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),
@@ -29455,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
@@ -29472,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
@@ -29488,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
@@ -29505,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"
     });
@@ -29522,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"
     });
@@ -29534,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.
@@ -29787,49 +30982,71 @@ var BridgeService = class {
    * }
    */
   async bridge(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, dstChainKey: params.dstChainKey };
-    try {
-      const txResult = await this.createBridgeIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verifyTxHashResult = await this.spoke.verifyTxHash({
-        txHash: txResult.value.tx,
-        chainKey: params.srcChainKey
-      });
-      if (!verifyTxHashResult.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("bridge", verifyTxHashResult.error, baseCtx)
-        };
+    return this.config.analytics.trackResult(
+      "bridge",
+      "bridge",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, dstChainKey: params.dstChainKey };
+        try {
+          const txResult = await this.createBridgeIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verifyTxHashResult = await this.spoke.verifyTxHash({
+            txHash: txResult.value.tx,
+            chainKey: params.srcChainKey
+          });
+          if (!verifyTxHashResult.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("bridge", verifyTxHashResult.error, baseCtx)
+            };
+          }
+          const packetResult = await relayTxAndWaitPacket({
+            srcTxHash: txResult.value.tx,
+            data: txResult.value.relayData,
+            chainKey: params.srcChainKey,
+            relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
+            timeout
+          });
+          if (!packetResult.ok)
+            return {
+              ok: false,
+              error: mapRelayFailure(packetResult.error, {
+                feature: "bridge",
+                action: "bridge",
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          return {
+            ok: true,
+            value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packetResult.value.dst_tx_hash }
+          };
+        } catch (error) {
+          if (isBridgeOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("bridge", error, baseCtx)
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          dstChainKey: _params.params.dstChainKey,
+          srcToken: _params.params.srcToken,
+          dstToken: _params.params.dstToken,
+          amount: _params.params.amount,
+          srcAddress: _params.params.srcAddress,
+          recipient: _params.params.recipient
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      const packetResult = await relayTxAndWaitPacket({
-        srcTxHash: txResult.value.tx,
-        data: txResult.value.relayData,
-        chainKey: params.srcChainKey,
-        relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
-        timeout
-      });
-      if (!packetResult.ok)
-        return {
-          ok: false,
-          error: mapRelayFailure(packetResult.error, {
-            feature: "bridge",
-            action: "bridge",
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
-        };
-      return {
-        ok: true,
-        value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packetResult.value.dst_tx_hash }
-      };
-    } catch (error) {
-      if (isBridgeOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("bridge", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the spoke-side deposit transaction that initiates a bridge transfer,
@@ -29858,8 +31075,8 @@ var BridgeService = class {
     const baseCtx = { srcChainKey: params.srcChainKey, dstChainKey: params.dstChainKey };
     try {
       bridgeInvariant(params.amount > 0n, "Amount must be greater than 0", { ...baseCtx, field: "amount" });
-      const srcToken = this.config.getSpokeTokenFromOriginalAssetAddress(params.srcChainKey, params.srcToken);
-      const dstToken = this.config.getSpokeTokenFromOriginalAssetAddress(params.dstChainKey, params.dstToken);
+      const srcToken = this.resolveBridgeEndpointToken(params.srcChainKey, params.srcToken);
+      const dstToken = this.resolveBridgeEndpointToken(params.dstChainKey, params.dstToken);
       bridgeInvariant(srcToken, `Unsupported spoke chain (${params.srcChainKey}) token: ${params.srcToken}`, {
         ...baseCtx,
         field: "srcToken"
@@ -29927,6 +31144,20 @@ var BridgeService = class {
       };
     }
   }
+  /**
+   * Resolves a bridge endpoint's {@link XToken} descriptor from a chain key + token address.
+   *
+   * Spoke endpoints (and hub-native tokens such as USDC/WETH/S whose on-chain address equals their
+   * hub asset) resolve by original asset address. On the hub a caller may instead hold a hub asset
+   * that has no spoke-token entry under the hub chain — e.g. a partner BTC fee held as the BTC hub
+   * asset, whose only spoke-token entry lives on Bitcoin. Resolve those by hub-asset address so the
+   * Sonic-sourced "withdraw directly" bridge can find the matching vault/decimals.
+   */
+  resolveBridgeEndpointToken(chainKey, token) {
+    const spokeToken = this.config.getSpokeTokenFromOriginalAssetAddress(chainKey, token);
+    if (spokeToken) return spokeToken;
+    return isHubChainKeyType(chainKey) ? this.config.getXTokenFromHubAsset(token) : void 0;
+  }
   /**
    * Encodes the hub-side execution payload for a bridge operation.
    *
@@ -30809,52 +32040,71 @@ var StakingService = class {
    * @returns `{ ok: true, value: { srcChainTxHash, dstChainTxHash } }` on success.
    */
   async stake(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, action: "stake" };
-    try {
-      const txResult = await this.createStakeIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verifyTxHashResult = await this.spoke.verifyTxHash({
-        txHash: txResult.value.tx,
-        chainKey: params.srcChainKey
-      });
-      if (!verifyTxHashResult.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("staking", verifyTxHashResult.error, baseCtx)
-        };
-      }
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) {
+    return this.config.analytics.trackResult(
+      "staking",
+      "stake",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, action: "stake" };
+        try {
+          const txResult = await this.createStakeIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verifyTxHashResult = await this.spoke.verifyTxHash({
+            txHash: txResult.value.tx,
+            chainKey: params.srcChainKey
+          });
+          if (!verifyTxHashResult.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("staking", verifyTxHashResult.error, baseCtx)
+            };
+          }
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packetResult.error, {
+                  feature: "staking",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey
+                })
+              };
+            }
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          if (isStakeOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packetResult.error, {
-              feature: "staking",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey
-            })
+            error: executionFailed("staking", error, baseCtx)
           };
         }
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          amount: _params.params.amount,
+          minReceive: _params.params.minReceive
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      if (isStakeOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("staking", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the stake transaction on the spoke chain without relaying to the hub.
@@ -30959,42 +32209,60 @@ var StakingService = class {
    * @returns `{ ok: true, value: { srcChainTxHash, dstChainTxHash } }` on success.
    */
   async unstake(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, action: "unstake" };
-    try {
-      const txResult = await this.createUnstakeIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) {
+    return this.config.analytics.trackResult(
+      "staking",
+      "unstake",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, action: "unstake" };
+        try {
+          const txResult = await this.createUnstakeIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packetResult.error, {
+                  feature: "staking",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey
+                })
+              };
+            }
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          if (isStakingOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packetResult.error, {
-              feature: "staking",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey
-            })
+            error: executionFailed("staking", error, baseCtx)
           };
         }
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      if (isStakingOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("staking", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the unstake transaction on the spoke chain without relaying to the hub.
@@ -31090,42 +32358,61 @@ var StakingService = class {
    * @returns `{ ok: true, value: { srcChainTxHash, dstChainTxHash } }` on success.
    */
   async instantUnstake(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, action: "instantUnstake" };
-    try {
-      const txResult = await this.createInstantUnstakeIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) {
+    return this.config.analytics.trackResult(
+      "staking",
+      "instantUnstake",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, action: "instantUnstake" };
+        try {
+          const txResult = await this.createInstantUnstakeIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packetResult.error, {
+                  feature: "staking",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey
+                })
+              };
+            }
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          if (isStakingOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packetResult.error, {
-              feature: "staking",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey
-            })
+            error: executionFailed("staking", error, baseCtx)
           };
         }
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          amount: _params.params.amount,
+          minAmount: _params.params.minAmount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      if (isStakingOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("staking", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the instant-unstake transaction on the spoke chain without relaying to the hub.
@@ -31233,42 +32520,61 @@ var StakingService = class {
    * @returns `{ ok: true, value: { srcChainTxHash, dstChainTxHash } }` on success.
    */
   async claim(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, action: "claim" };
-    try {
-      const txResult = await this.createClaimIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) {
+    return this.config.analytics.trackResult(
+      "staking",
+      "claim",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, action: "claim" };
+        try {
+          const txResult = await this.createClaimIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packetResult.error, {
+                  feature: "staking",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey
+                })
+              };
+            }
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          if (isStakingOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packetResult.error, {
-              feature: "staking",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey
-            })
+            error: executionFailed("staking", error, baseCtx)
           };
         }
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          requestId: _params.params.requestId,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      if (isStakingOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("staking", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the claim transaction on the spoke chain without relaying to the hub.
@@ -31382,42 +32688,60 @@ var StakingService = class {
    * @returns `{ ok: true, value: { srcChainTxHash, dstChainTxHash } }` on success.
    */
   async cancelUnstake(_params) {
-    const { params, timeout } = _params;
-    const baseCtx = { srcChainKey: params.srcChainKey, action: "cancelUnstake" };
-    try {
-      const txResult = await this.createCancelUnstakeIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) {
+    return this.config.analytics.trackResult(
+      "staking",
+      "cancelUnstake",
+      async () => {
+        const { params, timeout } = _params;
+        const baseCtx = { srcChainKey: params.srcChainKey, action: "cancelUnstake" };
+        try {
+          const txResult = await this.createCancelUnstakeIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packetResult.error, {
+                  feature: "staking",
+                  action: baseCtx.action,
+                  srcChainKey: baseCtx.srcChainKey
+                })
+              };
+            }
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          if (isStakingOrchestrationError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packetResult.error, {
-              feature: "staking",
-              action: baseCtx.action,
-              srcChainKey: baseCtx.srcChainKey
-            })
+            error: executionFailed("staking", error, baseCtx)
           };
         }
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          requestId: _params.params.requestId
+        }),
+        success: (value) => ({
+          srcChainTxHash: value.srcChainTxHash,
+          dstChainTxHash: value.dstChainTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      if (isStakingOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("staking", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Submits the cancel-unstake transaction on the spoke chain without relaying to the hub.
@@ -32791,34 +34115,56 @@ var ClService = class _ClService {
    *   `dstChainTxHash` (hub) once the packet has been confirmed.
    */
   async supplyLiquidity(_params) {
-    const { params, timeout } = _params;
-    try {
-      const txResult = await this.executeSupplyLiquidity(_params);
-      if (!txResult.ok) {
-        return txResult;
-      }
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) return packetResult;
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+    return this.config.analytics.trackResult(
+      "dex",
+      "supplyLiquidity",
+      async () => {
+        const { params, timeout } = _params;
+        try {
+          const txResult = await this.executeSupplyLiquidity(_params);
+          if (!txResult.ok) {
+            return txResult;
+          }
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) return packetResult;
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          this.config.logger.error("supplyLiquidity error", error);
+          return {
+            ok: false,
+            error
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          currency0: _params.params.poolKey.currency0,
+          currency1: _params.params.poolKey.currency1,
+          fee: _params.params.poolKey.fee,
+          tickLower: _params.params.tickLower,
+          tickUpper: _params.params.tickUpper,
+          liquidity: _params.params.liquidity,
+          amount0Max: _params.params.amount0Max,
+          amount1Max: _params.params.amount1Max
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      this.config.logger.error("supplyLiquidity error", error);
-      return {
-        ok: false,
-        error
-      };
-    }
+    );
   }
   /**
    * Add liquidity to an existing position and wait for the cross-chain relay to complete.
@@ -32833,33 +34179,56 @@ var ClService = class _ClService {
    *   `dstChainTxHash` (hub) once the packet has been confirmed.
    */
   async increaseLiquidity(_params) {
-    const { params, timeout } = _params;
-    try {
-      const txResult = await this.executeIncreaseLiquidity(_params);
-      if (!txResult.ok) {
-        return txResult;
-      }
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) return packetResult;
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+    return this.config.analytics.trackResult(
+      "dex",
+      "increaseLiquidity",
+      async () => {
+        const { params, timeout } = _params;
+        try {
+          const txResult = await this.executeIncreaseLiquidity(_params);
+          if (!txResult.ok) {
+            return txResult;
+          }
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) return packetResult;
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          return {
+            ok: false,
+            error
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          currency0: _params.params.poolKey.currency0,
+          currency1: _params.params.poolKey.currency1,
+          fee: _params.params.poolKey.fee,
+          tokenId: _params.params.tokenId,
+          tickLower: _params.params.tickLower,
+          tickUpper: _params.params.tickUpper,
+          liquidity: _params.params.liquidity,
+          amount0Max: _params.params.amount0Max,
+          amount1Max: _params.params.amount1Max
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      return {
-        ok: false,
-        error
-      };
-    }
+    );
   }
   /**
    * Remove liquidity from an existing position and wait for the cross-chain relay to complete.
@@ -32874,33 +34243,54 @@ var ClService = class _ClService {
    *   `dstChainTxHash` (hub) once the packet has been confirmed.
    */
   async decreaseLiquidity(_params) {
-    const { params, timeout } = _params;
-    try {
-      const txResult = await this.executeDecreaseLiquidity(_params);
-      if (!txResult.ok) {
-        return txResult;
-      }
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) return packetResult;
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+    return this.config.analytics.trackResult(
+      "dex",
+      "decreaseLiquidity",
+      async () => {
+        const { params, timeout } = _params;
+        try {
+          const txResult = await this.executeDecreaseLiquidity(_params);
+          if (!txResult.ok) {
+            return txResult;
+          }
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) return packetResult;
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          return {
+            ok: false,
+            error
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          currency0: _params.params.poolKey.currency0,
+          currency1: _params.params.poolKey.currency1,
+          fee: _params.params.poolKey.fee,
+          tokenId: _params.params.tokenId,
+          liquidity: _params.params.liquidity,
+          amount0Min: _params.params.amount0Min,
+          amount1Min: _params.params.amount1Min
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      return {
-        ok: false,
-        error
-      };
-    }
+    );
   }
   /**
    * Fetch the reward configuration stored in the pool's hook contract.
@@ -33052,34 +34442,54 @@ var ClService = class _ClService {
    *   `dstChainTxHash` (hub) once the packet has been confirmed.
    */
   async claimRewards(_params) {
-    const { params, timeout } = _params;
-    try {
-      const txResult = await this.executeClaimRewards(_params);
-      if (!txResult.ok) {
-        return txResult;
-      }
-      let hubTxHash;
-      if (!isHubChainKeyType(params.srcChainKey)) {
-        const packetResult = await relayTxAndWaitPacket({
-          srcTxHash: txResult.value.tx,
-          data: txResult.value.relayData,
-          chainKey: params.srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packetResult.ok) return packetResult;
-        hubTxHash = packetResult.value.dst_tx_hash;
-      } else {
-        hubTxHash = txResult.value.tx;
+    return this.config.analytics.trackResult(
+      "dex",
+      "claimRewards",
+      async () => {
+        const { params, timeout } = _params;
+        try {
+          const txResult = await this.executeClaimRewards(_params);
+          if (!txResult.ok) {
+            return txResult;
+          }
+          let hubTxHash;
+          if (!isHubChainKeyType(params.srcChainKey)) {
+            const packetResult = await relayTxAndWaitPacket({
+              srcTxHash: txResult.value.tx,
+              data: txResult.value.relayData,
+              chainKey: params.srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packetResult.ok) return packetResult;
+            hubTxHash = packetResult.value.dst_tx_hash;
+          } else {
+            hubTxHash = txResult.value.tx;
+          }
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
+        } catch (error) {
+          this.config.logger.error("claimRewards error", error);
+          return {
+            ok: false,
+            error
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          currency0: _params.params.poolKey.currency0,
+          currency1: _params.params.poolKey.currency1,
+          fee: _params.params.poolKey.fee,
+          tokenId: _params.params.tokenId,
+          tickLower: _params.params.tickLower,
+          tickUpper: _params.params.tickUpper
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: hubTxHash } };
-    } catch (error) {
-      this.config.logger.error("claimRewards error", error);
-      return {
-        ok: false,
-        error
-      };
-    }
+    );
   }
   /**
    * Return the list of configured concentrated-liquidity pool keys for the SODAX DEX.
@@ -36002,50 +37412,68 @@ var MoneyMarketService = class _MoneyMarketService {
    * @returns A pair of transaction hashes — `srcChainTxHash` (spoke) and `dstChainTxHash` (hub).
    */
   async supply(_params) {
-    const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
-    const srcChainKey = params.srcChainKey;
-    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "supply" };
-    try {
-      const txResult = await this.createSupplyIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
-      if (!verify.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("moneyMarket", verify.error, baseCtx)
-        };
-      }
-      if (isHubChainKeyType(srcChainKey)) {
-        return {
-          ok: true,
-          value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
-        };
+    return this.config.analytics.trackResult(
+      "moneyMarket",
+      "supply",
+      async () => {
+        const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
+        const srcChainKey = params.srcChainKey;
+        const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "supply" };
+        try {
+          const txResult = await this.createSupplyIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
+          if (!verify.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("moneyMarket", verify.error, baseCtx)
+            };
+          }
+          if (isHubChainKeyType(srcChainKey)) {
+            return {
+              ok: true,
+              value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
+            };
+          }
+          const packet = await relayTxAndWaitPacket({
+            srcTxHash: txResult.value.tx,
+            data: txResult.value.relayData,
+            chainKey: srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packet.ok)
+            return {
+              ok: false,
+              error: mapRelayFailure(packet.error, {
+                feature: "moneyMarket",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packet.value.dst_tx_hash } };
+        } catch (error) {
+          if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstChainKey: _params.params.dstChainKey,
+          dstAddress: _params.params.dstAddress,
+          token: _params.params.token,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: error.code })
       }
-      const packet = await relayTxAndWaitPacket({
-        srcTxHash: txResult.value.tx,
-        data: txResult.value.relayData,
-        chainKey: srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packet.ok)
-        return {
-          ok: false,
-          error: mapRelayFailure(packet.error, {
-            feature: "moneyMarket",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
-        };
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packet.value.dst_tx_hash } };
-    } catch (error) {
-      if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
-      };
-    }
+    );
   }
   /**
    * Build and optionally broadcast the spoke-side supply transaction without waiting for the
@@ -36162,58 +37590,76 @@ var MoneyMarketService = class _MoneyMarketService {
    *   `dstChainTxHash` (hub delivery or relay destination).
    */
   async borrow(_params) {
-    const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
-    const srcChainKey = params.srcChainKey;
-    const hubChainId = this.hubProvider.chainConfig.chain.key;
-    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "borrow" };
-    try {
-      const txResult = await this.createBorrowIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
-      if (!verify.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("moneyMarket", verify.error, baseCtx)
-        };
-      }
-      const needsRelay = srcChainKey !== hubChainId || params.dstChainKey != null && params.dstAddress != null && params.dstChainKey !== hubChainId;
-      if (!needsRelay) {
-        return {
-          ok: true,
-          value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
-        };
-      }
-      const relayIdentity = this.buildRelayIdentity(srcChainKey, txResult.value.tx, txResult.value.relayData);
-      const packet = await relayTxAndWaitPacket({
-        ...relayIdentity,
-        chainKey: srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packet.ok)
-        return {
-          ok: false,
-          error: mapRelayFailure(packet.error, {
-            feature: "moneyMarket",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
-        };
-      return {
-        ok: true,
-        value: {
-          srcChainTxHash: relayIdentity.pollTxHash ?? txResult.value.tx,
-          dstChainTxHash: packet.value.dst_tx_hash
+    return this.config.analytics.trackResult(
+      "moneyMarket",
+      "borrow",
+      async () => {
+        const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
+        const srcChainKey = params.srcChainKey;
+        const hubChainId = this.hubProvider.chainConfig.chain.key;
+        const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "borrow" };
+        try {
+          const txResult = await this.createBorrowIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
+          if (!verify.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("moneyMarket", verify.error, baseCtx)
+            };
+          }
+          const needsRelay = srcChainKey !== hubChainId || params.dstChainKey != null && params.dstAddress != null && params.dstChainKey !== hubChainId;
+          if (!needsRelay) {
+            return {
+              ok: true,
+              value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
+            };
+          }
+          const relayIdentity = this.buildRelayIdentity(srcChainKey, txResult.value.tx, txResult.value.relayData);
+          const packet = await relayTxAndWaitPacket({
+            ...relayIdentity,
+            chainKey: srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packet.ok)
+            return {
+              ok: false,
+              error: mapRelayFailure(packet.error, {
+                feature: "moneyMarket",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          return {
+            ok: true,
+            value: {
+              srcChainTxHash: relayIdentity.pollTxHash ?? txResult.value.tx,
+              dstChainTxHash: packet.value.dst_tx_hash
+            }
+          };
+        } catch (error) {
+          if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
+          };
         }
-      };
-    } catch (error) {
-      if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
-      };
-    }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstChainKey: _params.params.dstChainKey,
+          dstAddress: _params.params.dstAddress,
+          token: _params.params.token,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: error.code })
+      }
+    );
   }
   /**
    * Build and optionally broadcast the spoke-side borrow message without waiting for the
@@ -36311,59 +37757,77 @@ var MoneyMarketService = class _MoneyMarketService {
    *   `dstChainTxHash` (hub or relay destination).
    */
   async withdraw(_params) {
-    const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
-    const srcChainKey = params.srcChainKey;
-    const hubChainId = this.hubProvider.chainConfig.chain.key;
-    const walletRouter = this.hubProvider.chainConfig.addresses.walletRouter;
-    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "withdraw" };
-    try {
-      const txResult = await this.createWithdrawIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
-      if (!verify.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("moneyMarket", verify.error, baseCtx)
-        };
-      }
-      const needsRelay = srcChainKey !== hubChainId || params.dstChainKey != null && params.dstAddress != null && params.dstChainKey !== hubChainId && params.dstAddress !== walletRouter;
-      if (!needsRelay) {
-        return {
-          ok: true,
-          value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
-        };
-      }
-      const relayIdentity = this.buildRelayIdentity(srcChainKey, txResult.value.tx, txResult.value.relayData);
-      const packet = await relayTxAndWaitPacket({
-        ...relayIdentity,
-        chainKey: srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packet.ok)
-        return {
-          ok: false,
-          error: mapRelayFailure(packet.error, {
-            feature: "moneyMarket",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
-        };
-      return {
-        ok: true,
-        value: {
-          srcChainTxHash: relayIdentity.pollTxHash ?? txResult.value.tx,
-          dstChainTxHash: packet.value.dst_tx_hash
+    return this.config.analytics.trackResult(
+      "moneyMarket",
+      "withdraw",
+      async () => {
+        const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
+        const srcChainKey = params.srcChainKey;
+        const hubChainId = this.hubProvider.chainConfig.chain.key;
+        const walletRouter = this.hubProvider.chainConfig.addresses.walletRouter;
+        const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "withdraw" };
+        try {
+          const txResult = await this.createWithdrawIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
+          if (!verify.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("moneyMarket", verify.error, baseCtx)
+            };
+          }
+          const needsRelay = srcChainKey !== hubChainId || params.dstChainKey != null && params.dstAddress != null && params.dstChainKey !== hubChainId && params.dstAddress !== walletRouter;
+          if (!needsRelay) {
+            return {
+              ok: true,
+              value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
+            };
+          }
+          const relayIdentity = this.buildRelayIdentity(srcChainKey, txResult.value.tx, txResult.value.relayData);
+          const packet = await relayTxAndWaitPacket({
+            ...relayIdentity,
+            chainKey: srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packet.ok)
+            return {
+              ok: false,
+              error: mapRelayFailure(packet.error, {
+                feature: "moneyMarket",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          return {
+            ok: true,
+            value: {
+              srcChainTxHash: relayIdentity.pollTxHash ?? txResult.value.tx,
+              dstChainTxHash: packet.value.dst_tx_hash
+            }
+          };
+        } catch (error) {
+          if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
+          };
         }
-      };
-    } catch (error) {
-      if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
-      };
-    }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstChainKey: _params.params.dstChainKey,
+          dstAddress: _params.params.dstAddress,
+          token: _params.params.token,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: error.code })
+      }
+    );
   }
   /**
    * Build and optionally broadcast the spoke-side withdraw message without waiting for the
@@ -36459,50 +37923,68 @@ var MoneyMarketService = class _MoneyMarketService {
    * @returns A pair of transaction hashes — `srcChainTxHash` (spoke) and `dstChainTxHash` (hub).
    */
   async repay(_params) {
-    const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
-    const srcChainKey = params.srcChainKey;
-    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "repay" };
-    try {
-      const txResult = await this.createRepayIntent(_params);
-      if (!txResult.ok) return { ok: false, error: txResult.error };
-      const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
-      if (!verify.ok) {
-        return {
-          ok: false,
-          error: verifyFailed("moneyMarket", verify.error, baseCtx)
-        };
-      }
-      if (isHubChainKeyType(srcChainKey)) {
-        return {
-          ok: true,
-          value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
-        };
+    return this.config.analytics.trackResult(
+      "moneyMarket",
+      "repay",
+      async () => {
+        const { params, timeout = DEFAULT_RELAY_TX_TIMEOUT } = _params;
+        const srcChainKey = params.srcChainKey;
+        const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "repay" };
+        try {
+          const txResult = await this.createRepayIntent(_params);
+          if (!txResult.ok) return { ok: false, error: txResult.error };
+          const verify = await this.spoke.verifyTxHash({ txHash: txResult.value.tx, chainKey: srcChainKey });
+          if (!verify.ok) {
+            return {
+              ok: false,
+              error: verifyFailed("moneyMarket", verify.error, baseCtx)
+            };
+          }
+          if (isHubChainKeyType(srcChainKey)) {
+            return {
+              ok: true,
+              value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: txResult.value.tx }
+            };
+          }
+          const packet = await relayTxAndWaitPacket({
+            srcTxHash: txResult.value.tx,
+            data: txResult.value.relayData,
+            chainKey: srcChainKey,
+            relayerApiEndpoint: this.relayerApiEndpoint,
+            timeout
+          });
+          if (!packet.ok)
+            return {
+              ok: false,
+              error: mapRelayFailure(packet.error, {
+                feature: "moneyMarket",
+                action: baseCtx.action,
+                srcChainKey: baseCtx.srcChainKey,
+                dstChainKey: baseCtx.dstChainKey
+              })
+            };
+          return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packet.value.dst_tx_hash } };
+        } catch (error) {
+          if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstChainKey: _params.params.dstChainKey,
+          dstAddress: _params.params.dstAddress,
+          token: _params.params.token,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({ srcChainTxHash: value.srcChainTxHash, dstChainTxHash: value.dstChainTxHash }),
+        failure: (error) => ({ code: error.code })
       }
-      const packet = await relayTxAndWaitPacket({
-        srcTxHash: txResult.value.tx,
-        data: txResult.value.relayData,
-        chainKey: srcChainKey,
-        relayerApiEndpoint: this.relayerApiEndpoint,
-        timeout
-      });
-      if (!packet.ok)
-        return {
-          ok: false,
-          error: mapRelayFailure(packet.error, {
-            feature: "moneyMarket",
-            action: baseCtx.action,
-            srcChainKey: baseCtx.srcChainKey,
-            dstChainKey: baseCtx.dstChainKey
-          })
-        };
-      return { ok: true, value: { srcChainTxHash: txResult.value.tx, dstChainTxHash: packet.value.dst_tx_hash } };
-    } catch (error) {
-      if (isMoneyMarketOrchestrationError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: executionFailed("moneyMarket", error, { ...baseCtx, phase: "intentCreation" })
-      };
-    }
+    );
   }
   /**
    * Build and optionally broadcast the spoke-side repay transaction without waiting for the
@@ -37203,50 +38685,67 @@ var PartnerFeeClaimService = class {
    *   unsigned raw transaction (`raw: true`). Returns an error on failure.
    */
   async setSwapPreference(_params) {
-    const { params, walletProvider, raw } = _params;
-    try {
-      invariant(isHubChainKeyType(params.srcChainKey), "PartnerFeeClaimService only supports Sonic spoke provider");
-      invariant(this.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
-      const outputToken = params.dstChainKey !== this.hubProvider.chainConfig.chain.key ? this.hubProvider.config.getSpokeTokenFromOriginalAssetAddress(params.dstChainKey, params.outputToken)?.hubAsset : params.outputToken;
-      invariant(
-        outputToken,
-        `hub asset not found for spoke chain token (params.outputToken): ${params.outputToken} with chain key: ${params.dstChainKey}`
-      );
-      const rawTx = {
-        from: params.srcAddress,
-        to: this.protocolIntentsContract,
-        value: 0n,
-        data: viem.encodeFunctionData({
-          abi: ProtocolIntentsAbi,
-          functionName: "setAutoSwapPreferences",
-          args: [
+    return this.config.analytics.trackResult(
+      "partner",
+      "setSwapPreference",
+      async () => {
+        const { params, walletProvider, raw } = _params;
+        try {
+          invariant(isHubChainKeyType(params.srcChainKey), "PartnerFeeClaimService only supports Sonic spoke provider");
+          invariant(this.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+          const outputToken = params.dstChainKey !== this.hubProvider.chainConfig.chain.key ? this.hubProvider.config.getSpokeTokenFromOriginalAssetAddress(params.dstChainKey, params.outputToken)?.hubAsset : params.outputToken;
+          invariant(
             outputToken,
-            BigInt(getIntentRelayChainId(params.dstChainKey)),
-            encodeAddress(params.dstChainKey, params.dstAddress)
-          ]
-        })
-      };
-      if (raw) {
-        return {
-          ok: true,
-          value: rawTx
-        };
+            `hub asset not found for spoke chain token (params.outputToken): ${params.outputToken} with chain key: ${params.dstChainKey}`
+          );
+          const rawTx = {
+            from: params.srcAddress,
+            to: this.protocolIntentsContract,
+            value: 0n,
+            data: viem.encodeFunctionData({
+              abi: ProtocolIntentsAbi,
+              functionName: "setAutoSwapPreferences",
+              args: [
+                outputToken,
+                BigInt(getIntentRelayChainId(params.dstChainKey)),
+                encodeAddress(params.dstChainKey, params.dstAddress)
+              ]
+            })
+          };
+          if (raw) {
+            return {
+              ok: true,
+              value: rawTx
+            };
+          }
+          invariant(
+            isEvmWalletProviderType(walletProvider),
+            "PartnerFeeClaimService only supports Evm (sonic) wallet provider"
+          );
+          const txHash = await walletProvider.sendTransaction(rawTx);
+          return {
+            ok: true,
+            value: txHash
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            error
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          outputToken: _params.params.outputToken,
+          dstChainKey: _params.params.dstChainKey,
+          dstAddress: _params.params.dstAddress
+        }),
+        success: (value) => ({ txHash: value }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      invariant(
-        isEvmWalletProviderType(walletProvider),
-        "PartnerFeeClaimService only supports Evm (sonic) wallet provider"
-      );
-      const txHash = await walletProvider.sendTransaction(rawTx);
-      return {
-        ok: true,
-        value: txHash
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        error
-      };
-    }
+    );
   }
   /**
    * Checks whether a hub-chain ERC-20 token is already approved for the ProtocolIntents contract.
@@ -37358,6 +38857,11 @@ var PartnerFeeClaimService = class {
    * This is the low-level building block. Use `swap` for the full flow that also waits for
    * the solver to execute the intent.
    *
+   * Guards against same-token intents: if the configured output token equals `fromToken` the solver
+   * cannot fill the swap, so the call is rejected with `VALIDATION_FAILED` before any transaction is
+   * built. The guard fails closed — if the preference lookup fails the call returns that error rather
+   * than submitting an intent that may become unfillable.
+   *
    * @param _params - Action descriptor containing:
    *   - `params.srcChainKey` — must be the hub chain key (Sonic).
    *   - `params.srcAddress` — partner's EVM address; also used as the intent creator.
@@ -37381,6 +38885,25 @@ var PartnerFeeClaimService = class {
         this.config.solver.protocolIntentsContract,
         "protocolIntentsContract is not configured in solver config"
       );
+      const prefs = await this.getAutoSwapPreferences(params.srcAddress);
+      if (!prefs.ok) return prefs;
+      if (prefs.value.outputToken.toLowerCase() === params.fromToken.toLowerCase()) {
+        return {
+          ok: false,
+          error: new SodaxError(
+            "VALIDATION_FAILED",
+            "Auto-swap output token equals the fee token; the solver cannot swap a token into itself. Withdraw the fee token directly (bridge/transfer) or change the swap preference before claiming.",
+            {
+              feature: "partner",
+              context: {
+                action: "createIntentAutoSwap",
+                fromToken: params.fromToken,
+                outputToken: prefs.value.outputToken
+              }
+            }
+          )
+        };
+      }
       const minOutputAmount = 0n;
       const rawTx = {
         from: params.srcAddress,
@@ -37428,47 +38951,218 @@ var PartnerFeeClaimService = class {
    *
    *   On failure the `error` is tagged:
    *   - `WAIT_INTENT_AUTO_SWAP_FAILED` — transaction was submitted but receipt polling failed.
-   *   - Error from `createIntentAutoSwap` — if the initial submission failed.
+   *   - Error from `createIntentAutoSwap` — if the initial submission failed, including
+   *     `VALIDATION_FAILED` when the output token equals the fee token (same-token guard) or the
+   *     preference lookup that backs the guard fails.
    *   - Error from `SolverApiService.postExecution` — if the solver notification failed.
    */
   async swap(_params) {
-    try {
-      const txHash = await this.createIntentAutoSwap(_params);
-      if (!txHash.ok) {
-        return txHash;
+    return this.config.analytics.trackResult(
+      "partner",
+      "swap",
+      async () => {
+        try {
+          const txHash = await this.createIntentAutoSwap(_params);
+          if (!txHash.ok) {
+            return txHash;
+          }
+          let intentTxHash;
+          try {
+            const receipt = await this.hubProvider.publicClient.waitForTransactionReceipt({ hash: txHash.value });
+            intentTxHash = receipt.transactionHash;
+          } catch (error) {
+            return {
+              ok: false,
+              error: new SodaxError(
+                "EXECUTION_FAILED",
+                error instanceof Error ? error.message : "waitIntentAutoSwap failed",
+                { feature: "partner", cause: error, context: { action: "waitAutoSwap", phase: "execution" } }
+              )
+            };
+          }
+          const solverExecutionResponse = await SolverApiService.postExecution(
+            { intent_tx_hash: intentTxHash },
+            this.config.solver,
+            this.config.logger
+          );
+          if (!solverExecutionResponse.ok) {
+            return solverExecutionResponse;
+          }
+          return {
+            ok: true,
+            value: {
+              srcTxHash: txHash.value,
+              solverExecutionResponse: solverExecutionResponse.value,
+              intentTxHash
+            }
+          };
+        } catch (error) {
+          return { ok: false, error };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          fromToken: _params.params.fromToken,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({
+          srcTxHash: value.srcTxHash,
+          intentTxHash: value.intentTxHash
+        }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
       }
-      let intentTxHash;
-      try {
-        const receipt = await this.hubProvider.publicClient.waitForTransactionReceipt({ hash: txHash.value });
-        intentTxHash = receipt.transactionHash;
-      } catch (error) {
+    );
+  }
+  /**
+   * Cancels a partner fee-claim auto-swap intent and refunds the input token to the partner.
+   *
+   * This targets the ProtocolIntents contract's own `cancelIntent(fromToken, toToken)`, which is
+   * the only authorized cancel path for partner auto-swap intents: the intent's `creator` is the
+   * ProtocolIntents contract (not the partner), so the generic `SwapService.cancelIntent` reverts
+   * with `Unauthorized()`. ProtocolIntents looks up the caller's intent for the token pair, cancels
+   * it in the main intents contract (as the creator), and transfers the locked `inputAmount` back
+   * to the partner (`msg.sender`).
+   *
+   * Use this to recover funds stuck in an unfillable intent — most commonly a same-token claim
+   * (`fromToken === toToken`) the solver refused to fill (see the guard in {@link swap}).
+   *
+   * @param _params - Action descriptor containing:
+   *   - `params.srcChainKey` — must be the hub chain key (Sonic).
+   *   - `params.srcAddress` — the partner's EVM address; must match the intent's owner.
+   *   - `params.fromToken` — the stuck intent's input (fee) token, hub-chain address.
+   *   - `params.toToken` — the stuck intent's output token, hub-chain address.
+   *   - `raw` — when `true`, returns the unsigned transaction object instead of submitting it.
+   *   - `walletProvider` — required when `raw` is `false`; must be an EVM wallet provider.
+   * @returns A `Result` containing the submitted transaction hash (`raw: false`) or the unsigned
+   *   raw transaction (`raw: true`).
+   */
+  async cancelIntent(_params) {
+    return this.config.analytics.trackResult(
+      "partner",
+      "cancelIntent",
+      async () => {
+        const { params } = _params;
+        try {
+          invariant(isHubChainKeyType(params.srcChainKey), "PartnerFeeClaimService only supports Hub srcChainKey");
+          invariant(
+            isOptionalEvmWalletProviderType(_params.walletProvider),
+            "PartnerFeeClaimService only supports Evm wallet provider"
+          );
+          invariant(this.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+          const rawTx = {
+            from: params.srcAddress,
+            to: this.protocolIntentsContract,
+            value: 0n,
+            data: viem.encodeFunctionData({
+              abi: ProtocolIntentsAbi,
+              functionName: "cancelIntent",
+              args: [params.fromToken, params.toToken]
+            })
+          };
+          if (_params.raw) {
+            return {
+              ok: true,
+              value: rawTx
+            };
+          }
+          const txHash = await _params.walletProvider.sendTransaction(rawTx);
+          return {
+            ok: true,
+            value: txHash
+          };
+        } catch (error) {
+          return { ok: false, error };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          fromToken: _params.params.fromToken,
+          toToken: _params.params.toToken
+        }),
+        success: (value) => ({ txHash: value }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
+      }
+    );
+  }
+  /**
+   * Returns the stored intent hash for a partner's `(user, fromToken, toToken)` token pair.
+   *
+   * A non-zero hash means an auto-swap intent currently exists for that pair (e.g. an unfilled
+   * same-token claim) and can be cancelled via {@link cancelIntent}. A zero hash
+   * (`0x000…0`) means there is no open intent for the pair.
+   *
+   * @param params.user - The partner's EVM address on Sonic.
+   * @param params.fromToken - Input (fee) token, hub-chain address.
+   * @param params.toToken - Output token, hub-chain address.
+   * @returns A `Result` containing the intent hash, or an `Error` tagged `LOOKUP_FAILED`.
+   */
+  async getUserIntent({ user, fromToken, toToken }) {
+    try {
+      invariant(this.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const intentHash = await this.hubProvider.publicClient.readContract({
+        address: this.protocolIntentsContract,
+        abi: ProtocolIntentsAbi,
+        functionName: "getUserIntent",
+        args: [user, fromToken, toToken]
+      });
+      return { ok: true, value: intentHash };
+    } catch (error) {
+      return { ok: false, error: lookupFailed("partner", "getUserIntent", error) };
+    }
+  }
+  /**
+   * Reads the full {@link Intent} details for a stored intent hash from the ProtocolIntents contract.
+   *
+   * Useful for displaying a stuck intent before cancelling it — e.g. the locked `inputAmount` and
+   * `inputToken`. Pair with {@link getUserIntent} to resolve the hash from a token pair.
+   *
+   * @param intentHash - The intent hash (from {@link getUserIntent}).
+   * @returns A `Result` containing the `Intent`, or an `Error` tagged `LOOKUP_FAILED`.
+   */
+  async getIntentDetails(intentHash) {
+    try {
+      invariant(this.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
+      const intent = await this.hubProvider.publicClient.readContract({
+        address: this.protocolIntentsContract,
+        abi: ProtocolIntentsAbi,
+        functionName: "getIntentDetails",
+        args: [intentHash]
+      });
+      if (!this.config.isValidIntentRelayChainId(intent.srcChain) || !this.config.isValidIntentRelayChainId(intent.dstChain)) {
         return {
           ok: false,
-          error: new SodaxError(
-            "EXECUTION_FAILED",
-            error instanceof Error ? error.message : "waitIntentAutoSwap failed",
-            { feature: "partner", cause: error, context: { action: "waitAutoSwap", phase: "execution" } }
+          error: lookupFailed(
+            "partner",
+            "getIntentDetails",
+            new Error(`Invalid intent relay chain id: ${intent.srcChain} or ${intent.dstChain}`)
           )
         };
       }
-      const solverExecutionResponse = await SolverApiService.postExecution(
-        { intent_tx_hash: intentTxHash },
-        this.config.solver,
-        this.config.logger
-      );
-      if (!solverExecutionResponse.ok) {
-        return solverExecutionResponse;
-      }
       return {
         ok: true,
         value: {
-          srcTxHash: txHash.value,
-          solverExecutionResponse: solverExecutionResponse.value,
-          intentTxHash
+          intentId: intent.intentId,
+          creator: intent.creator,
+          inputToken: intent.inputToken,
+          outputToken: intent.outputToken,
+          inputAmount: intent.inputAmount,
+          minOutputAmount: intent.minOutputAmount,
+          deadline: intent.deadline,
+          allowPartialFill: intent.allowPartialFill,
+          srcChain: intent.srcChain,
+          dstChain: intent.dstChain,
+          srcAddress: intent.srcAddress,
+          dstAddress: intent.dstAddress,
+          solver: intent.solver,
+          data: intent.data
         }
       };
     } catch (error) {
-      return { ok: false, error };
+      return { ok: false, error: lookupFailed("partner", "getIntentDetails", error) };
     }
   }
 };
@@ -37603,42 +39297,62 @@ var RecoveryService = class {
    *   transaction object when `raw: true`, or the broadcast transaction hash when `raw: false`.
    */
   async withdrawHubAsset(_params) {
-    const { params } = _params;
-    try {
-      const hubWallet = await this.hubProvider.getUserHubWalletAddress(params.srcAddress, params.srcChainKey);
-      const payload = EvmAssetManagerService.withdrawAssetData(
-        {
-          token: params.token,
-          to: encodeAddress(params.srcChainKey, params.srcAddress),
-          amount: params.amount
-        },
-        this.hubProvider,
-        params.srcChainKey
-      );
-      const coreParams = {
-        srcChainKey: params.srcChainKey,
-        srcAddress: params.srcAddress,
-        dstChainKey: this.hubProvider.chainConfig.chain.key,
-        dstAddress: hubWallet,
-        payload
-      };
-      const sendMessageParams = _params.raw ? { ...coreParams, raw: true } : { ...coreParams, raw: false, walletProvider: _params.walletProvider };
-      const txResult = await this.spoke.sendMessage(sendMessageParams);
-      if (!txResult.ok) return txResult;
-      return {
-        ok: true,
-        value: txResult.value
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        error: new SodaxError("EXECUTION_FAILED", error instanceof Error ? error.message : "withdrawHubAsset failed", {
-          feature: "recovery",
-          cause: error,
-          context: { action: "withdrawHubAsset", phase: "execution" }
-        })
-      };
-    }
+    return this.config.analytics.trackResult(
+      "recovery",
+      "withdrawHubAsset",
+      async () => {
+        const { params } = _params;
+        try {
+          const hubWallet = await this.hubProvider.getUserHubWalletAddress(params.srcAddress, params.srcChainKey);
+          const payload = EvmAssetManagerService.withdrawAssetData(
+            {
+              token: params.token,
+              to: encodeAddress(params.srcChainKey, params.srcAddress),
+              amount: params.amount
+            },
+            this.hubProvider,
+            params.srcChainKey
+          );
+          const coreParams = {
+            srcChainKey: params.srcChainKey,
+            srcAddress: params.srcAddress,
+            dstChainKey: this.hubProvider.chainConfig.chain.key,
+            dstAddress: hubWallet,
+            payload
+          };
+          const sendMessageParams = _params.raw ? { ...coreParams, raw: true } : {
+            ...coreParams,
+            raw: false,
+            walletProvider: _params.walletProvider
+          };
+          const txResult = await this.spoke.sendMessage(sendMessageParams);
+          if (!txResult.ok) return txResult;
+          return {
+            ok: true,
+            value: txResult.value
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            error: new SodaxError(
+              "EXECUTION_FAILED",
+              error instanceof Error ? error.message : "withdrawHubAsset failed",
+              { feature: "recovery", cause: error, context: { action: "withdrawHubAsset", phase: "execution" } }
+            )
+          };
+        }
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          srcAddress: _params.params.srcAddress,
+          token: _params.params.token,
+          amount: _params.params.amount
+        }),
+        success: (value) => ({ txHash: typeof value === "string" ? value : void 0 }),
+        failure: (error) => ({ code: isSodaxError(error) ? error.code : void 0 })
+      }
+    );
   }
 };
 
@@ -37740,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).
@@ -37748,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
@@ -38098,70 +39812,93 @@ var LeverageYieldService = class {
     const { params } = _params;
     const srcChainKey = params.srcChainKey;
     const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "vaultSwap" };
-    try {
-      const timeout = _params.timeout;
-      const createIntentResult = await this.createVaultIntent(_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("leverageYield", verifyTxHashResult.error, baseCtx)
-        };
-      }
-      let dstIntentTxHash;
-      if (isHubChainKeyType(srcChainKey)) {
-        dstIntentTxHash = spokeTxHash;
-      } else {
-        const packet = await relayTxAndWaitPacket({
-          srcTxHash: spokeTxHash,
-          data: relayData,
-          chainKey: srcChainKey,
-          relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
-          timeout
-        });
-        if (!packet.ok) {
+    return this.config.analytics.trackResult(
+      "leverageYield",
+      "vaultSwap",
+      async () => {
+        try {
+          const timeout = _params.timeout;
+          const createIntentResult = await this.createVaultIntent(_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("leverageYield", verifyTxHashResult.error, baseCtx)
+            };
+          }
+          let dstIntentTxHash;
+          if (isHubChainKeyType(srcChainKey)) {
+            dstIntentTxHash = spokeTxHash;
+          } else {
+            const packet = await relayTxAndWaitPacket({
+              srcTxHash: spokeTxHash,
+              data: relayData,
+              chainKey: srcChainKey,
+              relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
+              timeout
+            });
+            if (!packet.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packet.error, { feature: "leverageYield", ...baseCtx })
+              };
+            }
+            dstIntentTxHash = packet.value.dst_tx_hash;
+          }
+          const postExecResult = await this.notifySolver({
+            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
+              }
+            }
+          };
+        } catch (error) {
+          if (isLeverageYieldSwapError(error)) return { ok: false, error };
           return {
             ok: false,
-            error: mapRelayFailure(packet.error, { feature: "leverageYield", ...baseCtx })
+            error: unknownFailed("leverageYield", error, baseCtx)
           };
         }
-        dstIntentTxHash = packet.value.dst_tx_hash;
-      }
-      const postExecResult = await this.notifySolver({
-        intent_tx_hash: dstIntentTxHash
-      });
-      if (!postExecResult.ok) {
-        return { ok: false, error: postExecResult.error };
+      },
+      {
+        start: () => ({
+          srcChainKey: _params.params.srcChainKey,
+          dstChainKey: _params.params.dstChainKey,
+          srcAddress: _params.params.srcAddress,
+          dstAddress: _params.params.dstAddress,
+          inputToken: _params.params.inputToken,
+          outputToken: _params.params.outputToken,
+          inputAmount: _params.params.inputAmount
+        }),
+        success: (value) => ({
+          intentId: value.intent.intentId,
+          srcTxHash: value.intentDeliveryInfo.srcTxHash,
+          dstTxHash: value.intentDeliveryInfo.dstTxHash
+        }),
+        failure: (error) => ({ code: error.code })
       }
-      return {
-        ok: true,
-        value: {
-          solverExecutionResponse: postExecResult.value,
-          intent,
-          intentDeliveryInfo: {
-            srcChainKey,
-            srcTxHash: spokeTxHash,
-            srcAddress: params.srcAddress,
-            dstChainKey: params.dstChainKey,
-            dstTxHash: dstIntentTxHash,
-            dstAddress: params.dstAddress
-          }
-        }
-      };
-    } catch (error) {
-      if (isLeverageYieldSwapError(error)) return { ok: false, error };
-      return {
-        ok: false,
-        error: unknownFailed("leverageYield", error, baseCtx)
-      };
-    }
+    );
   }
   /**
    * Notifies the solver that the vault intent landed on the hub, triggering it to fill.
@@ -38518,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;
@@ -38538,14 +40277,18 @@ var Sodax = class {
   // spoke service enabling spoke chain operations
   constructor(options) {
     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,
       userConfig: options,
       logger,
+      analytics,
       fee
     });
     this.hubProvider = new EvmHubProvider({ config: this.config });
@@ -38553,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,
@@ -38753,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;
@@ -38953,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;
@@ -38983,6 +40727,7 @@ exports.moneyMarketSupportedTokens = moneyMarketSupportedTokens;
 exports.nativeToUSD = nativeToUSD;
 exports.nearSupportedTokens = nearSupportedTokens;
 exports.newbnUSDSpokeChainIds = newbnUSDSpokeChainIds;
+exports.noopAnalytics = noopAnalytics;
 exports.normalize = normalize;
 exports.normalizeBN = normalizeBN;
 exports.normalizePsbtToBase64 = normalizePsbtToBase64;
@@ -39011,6 +40756,7 @@ exports.relayTxAndWaitPacket = relayTxAndWaitPacket;
 exports.requestAddress = requestAddress;
 exports.requestJsonRpc = requestJsonRpc;
 exports.requestSigning = requestSigning;
+exports.resolveAnalytics = resolveAnalytics;
 exports.resolveLogger = resolveLogger;
 exports.retry = retry;
 exports.reverseEncodeAddress = reverseEncodeAddress;