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

package/dist/index.cjs

@@ -2641,6 +2641,8 @@ var RelayChainIdMap = {
 };
 var INTENT_CHAIN_IDS = Object.values(RelayChainIdMap);
 var IntentRelayChainIdToChainKey = Object.fromEntries(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 = {
   [ChainKeys.SONIC_MAINNET]: {
     name: "Sonic",
@@ -2648,6 +2650,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 146,
     mainnet: true,
+    logo: chainLogo(ChainKeys.SONIC_MAINNET),
     explorer: {
       baseUrl: "https://sonicscan.org/",
       txUrl: "https://sonicscan.org/tx/",
@@ -2661,6 +2664,7 @@ var baseChainInfo = {
     type: "SOLANA",
     chainId: "solana",
     mainnet: true,
+    logo: chainLogo(ChainKeys.SOLANA_MAINNET),
     explorer: {
       baseUrl: "https://solscan.io/",
       txUrl: "https://solscan.io/tx/",
@@ -2674,6 +2678,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 43114,
     mainnet: true,
+    logo: chainLogo(ChainKeys.AVALANCHE_MAINNET),
     explorer: {
       baseUrl: "https://snowtrace.io/",
       txUrl: "https://snowtrace.io/tx/",
@@ -2687,6 +2692,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 42161,
     mainnet: true,
+    logo: chainLogo(ChainKeys.ARBITRUM_MAINNET),
     explorer: {
       baseUrl: "https://arbiscan.io/",
       txUrl: "https://arbiscan.io/tx/",
@@ -2700,6 +2706,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 8453,
     mainnet: true,
+    logo: chainLogo(ChainKeys.BASE_MAINNET),
     explorer: {
       baseUrl: "https://basescan.org/",
       txUrl: "https://basescan.org/tx/",
@@ -2713,6 +2720,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 10,
     mainnet: true,
+    logo: chainLogo(ChainKeys.OPTIMISM_MAINNET),
     explorer: {
       baseUrl: "https://optimistic.etherscan.io/",
       txUrl: "https://optimistic.etherscan.io/tx/",
@@ -2726,6 +2734,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 56,
     mainnet: true,
+    logo: chainLogo(ChainKeys.BSC_MAINNET),
     explorer: {
       baseUrl: "https://bscscan.com/",
       txUrl: "https://bscscan.com/tx/",
@@ -2739,6 +2748,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 137,
     mainnet: true,
+    logo: chainLogo(ChainKeys.POLYGON_MAINNET),
     explorer: {
       baseUrl: "https://polygonscan.com/",
       txUrl: "https://polygonscan.com/tx/",
@@ -2752,6 +2762,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 999,
     mainnet: true,
+    logo: chainLogo(ChainKeys.HYPEREVM_MAINNET),
     explorer: {
       baseUrl: "https://hyperevmscan.io/",
       txUrl: "https://hyperevmscan.io/tx/",
@@ -2765,6 +2776,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 1890,
     mainnet: true,
+    logo: chainLogo(ChainKeys.LIGHTLINK_MAINNET),
     explorer: {
       baseUrl: "https://phoenix.lightlink.io/",
       txUrl: "https://phoenix.lightlink.io/tx/",
@@ -2778,6 +2790,7 @@ var baseChainInfo = {
     type: "INJECTIVE",
     chainId: "injective-1",
     mainnet: true,
+    logo: chainLogo(ChainKeys.INJECTIVE_MAINNET),
     explorer: {
       baseUrl: "https://www.mintscan.io/injective/",
       txUrl: "https://www.mintscan.io/injective/tx/",
@@ -2791,6 +2804,7 @@ var baseChainInfo = {
     type: "STELLAR",
     chainId: "stellar",
     mainnet: true,
+    logo: chainLogo(ChainKeys.STELLAR_MAINNET),
     explorer: {
       baseUrl: "https://stellar.expert/explorer/public/",
       txUrl: "https://stellar.expert/explorer/public/tx/",
@@ -2804,6 +2818,7 @@ var baseChainInfo = {
     type: "SUI",
     chainId: "sui",
     mainnet: true,
+    logo: chainLogo(ChainKeys.SUI_MAINNET),
     explorer: {
       baseUrl: "https://suivision.xyz/",
       txUrl: "https://suivision.xyz/txblock/",
@@ -2817,6 +2832,7 @@ var baseChainInfo = {
     type: "ICON",
     chainId: "0x1.icon",
     mainnet: true,
+    logo: chainLogo(ChainKeys.ICON_MAINNET),
     explorer: {
       baseUrl: "https://tracker.icon.community/",
       txUrl: "https://tracker.icon.community/transaction/",
@@ -2830,6 +2846,7 @@ var baseChainInfo = {
     type: "NEAR",
     chainId: "near",
     mainnet: true,
+    logo: chainLogo(ChainKeys.NEAR_MAINNET),
     explorer: {
       baseUrl: "https://nearblocks.io/",
       txUrl: "https://nearblocks.io/txns/",
@@ -2843,6 +2860,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 1,
     mainnet: true,
+    logo: chainLogo(ChainKeys.ETHEREUM_MAINNET),
     explorer: {
       baseUrl: "https://etherscan.io/",
       txUrl: "https://etherscan.io/tx/",
@@ -2856,6 +2874,7 @@ var baseChainInfo = {
     type: "BITCOIN",
     chainId: "bitcoin",
     mainnet: true,
+    logo: chainLogo(ChainKeys.BITCOIN_MAINNET),
     explorer: {
       baseUrl: "https://mempool.space/",
       txUrl: "https://mempool.space/tx/",
@@ -2869,6 +2888,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 151,
     mainnet: true,
+    logo: chainLogo(ChainKeys.REDBELLY_MAINNET),
     explorer: {
       baseUrl: "https://redbelly.routescan.io/",
       txUrl: "https://redbelly.routescan.io/tx/",
@@ -2882,6 +2902,7 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 8217,
     mainnet: true,
+    logo: chainLogo(ChainKeys.KAIA_MAINNET),
     explorer: {
       baseUrl: "https://klaytnfinder.io/",
       txUrl: "https://klaytnfinder.io/tx/",
@@ -2895,6 +2916,7 @@ var baseChainInfo = {
     type: "STACKS",
     chainId: "stacks",
     mainnet: true,
+    logo: chainLogo(ChainKeys.STACKS_MAINNET),
     explorer: {
       baseUrl: "https://explorer.hiro.so/",
       txUrl: "https://explorer.hiro.so/txid/",
@@ -3886,8 +3908,11 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.WAL,
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.NAVX
   ],
-  // Injective is currently staging-only — see stagingSwapSupportedTokens
-  [ChainKeys.INJECTIVE_MAINNET]: [],
+  [ChainKeys.INJECTIVE_MAINNET]: [
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.INJ,
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.bnUSD,
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.USDC
+  ],
   [ChainKeys.NEAR_MAINNET]: [
     spokeChainConfig[ChainKeys.NEAR_MAINNET].supportedTokens.NEAR,
     spokeChainConfig[ChainKeys.NEAR_MAINNET].supportedTokens.bnUSD,
@@ -3976,12 +4001,7 @@ var stagingSwapSupportedTokens = {
   [ChainKeys.ICON_MAINNET]: [],
   [ChainKeys.STELLAR_MAINNET]: [],
   [ChainKeys.SUI_MAINNET]: [spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.USDT],
-  [ChainKeys.INJECTIVE_MAINNET]: [
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.INJ,
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.bnUSD,
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.USDC
-    // spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.SODA, // NOTE: not in solver wiki
-  ],
+  [ChainKeys.INJECTIVE_MAINNET]: [],
   [ChainKeys.NEAR_MAINNET]: [],
   [ChainKeys.BITCOIN_MAINNET]: [],
   [ChainKeys.ETHEREUM_MAINNET]: [
@@ -4087,6 +4107,31 @@ function usesBip322MessageSigning(addressType) {
 var BTC_WALLET_ADDRESS_TYPES = ["taproot", "segwit"];
 var BTC_ADDRESS_TYPES = ["P2PKH", "P2SH", "P2WPKH", "P2TR"];
 
+// ../types/dist/hooks/hooks.js
+var HookKind = {
+  /** Deposits delivered USDC into the recipient's HyperCore perps account (HyperEVM). */
+  HYPERCORE_DEPOSIT: "hyperCoreDeposit"
+};
+var spokeHooks = {
+  [ChainKeys.HYPEREVM_MAINNET]: [
+    {
+      kind: HookKind.HYPERCORE_DEPOSIT,
+      address: "0xc79224a4DEE653C9a26572B941149d95a88432c4",
+      supportedTokens: [spokeChainConfig[ChainKeys.HYPEREVM_MAINNET].supportedTokens.USDC.address]
+      // USDC on HyperEVM
+    }
+  ]
+};
+var getSpokeHook = (chainKey, kind) => spokeHooks[chainKey]?.find((h) => h.kind === kind);
+var getSpokeHooks = (chainKey) => spokeHooks[chainKey] ?? [];
+var isHookSupportedToken = (chainKey, kind, token) => {
+  const hook = getSpokeHook(chainKey, kind);
+  if (!hook) {
+    return false;
+  }
+  return !hook.supportedTokens || hook.supportedTokens.some((t) => t.toLowerCase() === token.toLowerCase());
+};
+
 // ../types/dist/utils/utils.js
 function isHubChainKey(chainId) {
   return chainId === HUB_CHAIN_KEY;
@@ -4201,7 +4246,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 214;
+var CONFIG_VERSION = 216;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -10604,6 +10649,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"
   }
 ];
 
@@ -13511,6 +13694,68 @@ 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;
@@ -13521,6 +13766,12 @@ var ConfigService = class {
    * {@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
@@ -13538,11 +13789,12 @@ var ConfigService = class {
   stakedATokenAddressesSet;
   chainToSupportedTokenAddressMap;
   hubAssetToXTokenMap;
-  constructor({ api, config, userConfig, logger, fee }) {
+  constructor({ api, config, userConfig, logger, analytics, fee }) {
     this.api = api;
     this.sodax = config;
     this.userConfig = userConfig;
     this.logger = logger ?? resolveLogger(void 0);
+    this.analytics = analytics ?? noopAnalytics;
     this.fee = fee;
     this.loadSodaxConfigDataStructures(config);
   }
@@ -13593,6 +13845,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());
   }
@@ -21852,9 +22114,147 @@ var NearSpokeService = class {
 
 // src/shared/types/intent-types.ts
 var IntentDataType = /* @__PURE__ */ ((IntentDataType2) => {
+  IntentDataType2[IntentDataType2["ARRAY"] = 0] = "ARRAY";
   IntentDataType2[IntentDataType2["FEE"] = 1] = "FEE";
+  IntentDataType2[IntentDataType2["HOOK"] = 2] = "HOOK";
+  IntentDataType2[IntentDataType2["DELIVERY"] = 3] = "DELIVERY";
   return IntentDataType2;
 })(IntentDataType || {});
+var HOOK_DELIVERY_ABI = {
+  // HyperCoreDepositHook expects `abi.encode(address)` — the HyperCore account to credit.
+  [HookKind.HYPERCORE_DEPOSIT]: [{ name: "recipient", type: "address" }]
+};
+var HookService = class _HookService {
+  constructor() {
+  }
+  /**
+   * Encodes a hook's `deliveryData` payload. One common entry point for all hooks — the encoding is
+   * selected by {@link HookRequest.kind} and uses that hook's schema from {@link HOOK_DELIVERY_ABI}.
+   *
+   * @param request - The hook selection (and any hook-specific params).
+   * @param recipient - The end recipient the hook should credit (the intent's `dstAddress`).
+   */
+  static encodeDeliveryData(request, recipient) {
+    switch (request.kind) {
+      case HookKind.HYPERCORE_DEPOSIT:
+        return viem.encodeAbiParameters(HOOK_DELIVERY_ABI[HookKind.HYPERCORE_DEPOSIT], [recipient]);
+    }
+    throw new Error(
+      `[HookService.encodeDeliveryData] Unsupported delivery hook kind: ${request.kind}`
+    );
+  }
+  /**
+   * Resolves a high-level {@link HookRequest} to the on-chain delivery pair: the deployed hook address
+   * (becomes the intent's `dstAddress`) and the encoded payload the hook expects (`deliveryData`).
+   * Bundling lookup + codec here guarantees the address and its payload schema can never drift.
+   *
+   * @param chainKey - Destination spoke chain (must have the requested hook deployed).
+   * @param request - The hook selection (and any hook-specific params).
+   * @param recipient - The end recipient the hook should credit (the intent's `dstAddress`).
+   */
+  static resolveDeliveryHook(chainKey, request, recipient) {
+    const hook = getSpokeHook(chainKey, request.kind);
+    invariant(hook, `No '${request.kind}' delivery hook is deployed on chain ${chainKey}`);
+    return { dstAddress: hook.address, deliveryData: _HookService.encodeDeliveryData(request, recipient) };
+  }
+  /**
+   * Resolves the effective delivery target for an intent. When {@link CreateIntentParams.hook} is set,
+   * routes the output through that registered hook (overriding `dstAddress` and deriving `deliveryData`);
+   * otherwise returns the caller's `dstAddress` and low-level `deliveryData` unchanged. Centralised so
+   * both the hub and Sonic intent constructors apply hooks identically.
+   *
+   * @returns `{ dstAddress, deliveryData }` — the address to deliver to and the payload to forward.
+   */
+  static resolveDelivery(params) {
+    if (!params.hook) {
+      return { dstAddress: params.dstAddress, deliveryData: params.deliveryData };
+    }
+    return _HookService.resolveDeliveryHook(params.dstChainKey, params.hook, params.dstAddress);
+  }
+};
+var ARRAY_DATA_ABI = [
+  {
+    type: "tuple",
+    components: [
+      {
+        name: "data",
+        type: "tuple[]",
+        components: [
+          { name: "dataType", type: "uint8" },
+          { name: "data", type: "bytes" }
+        ]
+      }
+    ]
+  }
+];
+var IntentDataService = class _IntentDataService {
+  constructor() {
+  }
+  /**
+   * Folds a partner-fee envelope and an optional delivery payload into the final `Intent.data`:
+   * - Neither → `'0x'`.
+   * - Exactly one → that single packed `[uint8 type, bytes payload]` envelope (byte-identical to a
+   *   bare fee envelope, so a fee-only intent's `data` is unchanged and stays decode-stable).
+   * - Both → a `TYPE_ARRAY` envelope wrapping `[FEE, DELIVERY]` entries.
+   *
+   * @param feeEnvelope - The packed fee envelope from `EvmSolverService.createIntentFeeData` (`'0x'` if no fee).
+   * @param deliveryData - Opaque delivery payload (e.g. from `HookService.encodeDeliveryData`), or `undefined`.
+   */
+  static composeIntentData(feeEnvelope, deliveryData) {
+    const entries = [];
+    if (feeEnvelope !== "0x") {
+      entries.push({ type: 1 /* FEE */, data: `0x${feeEnvelope.slice(4)}` });
+    }
+    if (deliveryData && deliveryData !== "0x") {
+      entries.push({ type: 3 /* DELIVERY */, data: deliveryData });
+    }
+    return _IntentDataService.encodeIntentData(entries);
+  }
+  /**
+   * Encodes a list of typed `IntentData` entries into the `Intent.data` bytes the contract decodes.
+   * Empty → `'0x'`; single → a packed `[uint8 type, bytes payload]` envelope; multiple → a `TYPE_ARRAY`
+   * envelope wrapping the entries as `ArrayData { DataEntry[] }`.
+   */
+  static encodeIntentData(entries) {
+    if (entries.length === 0) {
+      return "0x";
+    }
+    const [first] = entries;
+    if (first && entries.length === 1) {
+      return viem.encodePacked(["uint8", "bytes"], [first.type, first.data]);
+    }
+    const encodedArray = viem.encodeAbiParameters(ARRAY_DATA_ABI, [
+      { data: entries.map((e) => ({ dataType: e.type, data: e.data })) }
+    ]);
+    return viem.encodePacked(["uint8", "bytes"], [0 /* ARRAY */, encodedArray]);
+  }
+  /**
+   * Extracts the raw `FeeData` payload (`abi.encode(uint256 fee, address receiver)`) from an intent's
+   * `data`, unwrapping whichever envelope shape it uses. Returns `undefined` when there is no fee:
+   * empty `data`, a delivery-only envelope, or an unknown type byte (logged). Used by
+   * `EvmSolverService.decodeIntentFeeAmount` to recover fees regardless of delivery data.
+   */
+  static extractFeePayload(data) {
+    if (data === "0x" || data.length <= 2) {
+      return void 0;
+    }
+    const typeByte = Number.parseInt(data.slice(2, 4), 16);
+    if (typeByte === 1 /* FEE */) {
+      return `0x${data.slice(4)}`;
+    }
+    if (typeByte === 0 /* ARRAY */) {
+      const [arrayData] = viem.decodeAbiParameters(ARRAY_DATA_ABI, `0x${data.slice(4)}`);
+      return arrayData.data.find((e) => e.dataType === 1 /* FEE */)?.data;
+    }
+    if (typeByte === 3 /* DELIVERY */) {
+      return void 0;
+    }
+    console.error(
+      `[IntentDataService.extractFeePayload] Unknown IntentData type byte: ${typeByte}. Gracefully returning no fee.`
+    );
+    return void 0;
+  }
+};
 var IntentCreatedEventAbi = viem.getAbiItem({ abi: IntentsAbi, name: "IntentCreated" });
 var IntentFilledEventAbi = viem.getAbiItem({ abi: IntentsAbi, name: "IntentFilled" });
 var MintPositionEventAbi = viem.getAbiItem({ abi: infinitySdk.CLPositionManagerAbi, name: "MintPosition" });
@@ -21893,7 +22293,9 @@ var EvmSolverService = class _EvmSolverService {
       outputToken,
       `hub asset not found for spoke chain token (intent.outputToken): ${createIntentParams.outputToken}`
     );
-    const [feeData, feeAmount] = _EvmSolverService.createIntentFeeData(fee, createIntentParams.inputAmount);
+    const { dstAddress, deliveryData } = HookService.resolveDelivery(createIntentParams);
+    const [feeEnvelope, feeAmount] = _EvmSolverService.createIntentFeeData(fee, createIntentParams.inputAmount);
+    const intentData = IntentDataService.composeIntentData(feeEnvelope, deliveryData);
     const calls = [];
     const intentsContract = config.solver.intentsContract;
     const intent = {
@@ -21908,10 +22310,10 @@ var EvmSolverService = class _EvmSolverService {
       srcChain: getIntentRelayChainId(createIntentParams.srcChainKey),
       dstChain: getIntentRelayChainId(createIntentParams.dstChainKey),
       srcAddress: encodeAddress(createIntentParams.srcChainKey, createIntentParams.srcAddress),
-      dstAddress: encodeAddress(createIntentParams.dstChainKey, createIntentParams.dstAddress),
+      dstAddress: encodeAddress(createIntentParams.dstChainKey, dstAddress),
       solver: createIntentParams.solver ?? "0x0000000000000000000000000000000000000000",
-      data: feeData
-      // fee amount will be deducted from the input amount
+      data: intentData
+      // fee amount will be deducted from the input amount; may also carry delivery data
     };
     calls.push(Erc20Service.encodeApprove(intent.inputToken, intentsContract, createIntentParams.inputAmount));
     calls.push(_EvmSolverService.encodeCreateIntent(intent, intentsContract));
@@ -21972,29 +22374,25 @@ var EvmSolverService = class _EvmSolverService {
   /**
    * Recovers the partner fee amount embedded in an intent's `data` field.
    *
-   * Exact inverse of {@link createIntentFeeData}: `'0x'` means no fee (`0n`); otherwise the first
-   * byte is the {@link IntentDataType} tag (from the `encodePacked(['uint8','bytes'], …)` envelope)
-   * and the remainder is the ABI-encoded `(uint256 fee, address receiver)` struct.
+   * Inverse of {@link createIntentFeeData}: returns the encoded fee, regardless of whether the `data`
+   * is a bare fee envelope or a multi-entry envelope that also carries delivery data. The envelope
+   * parsing lives in {@link IntentDataService.extractFeePayload}; this method just decodes the fee struct.
    *
    * @param data - The intent's `data` field (`'0x'` when no fee was configured).
-   * @returns The fee amount in the input token's smallest unit (`0n` when no fee data is present, or
-   *   when the leading type byte is not {@link IntentDataType.FEE} — in which case it logs and degrades to `0n`).
+   * @returns The fee amount in the input token's smallest unit (`0n` when no fee is present).
    */
   static decodeIntentFeeAmount(data) {
-    if (data === "0x" || data.length <= 2) {
-      return 0n;
-    }
-    const typeByte = Number.parseInt(data.slice(2, 4), 16);
-    if (typeByte !== 1 /* FEE */) {
-      console.error(`[decodeIntentFeeAmount] Unknown IntentData type byte: ${typeByte}. Gracefully returning 0n.`);
-      return 0n;
-    }
+    const feePayload = IntentDataService.extractFeePayload(data);
+    return feePayload ? _EvmSolverService.decodeFeePayload(feePayload) : 0n;
+  }
+  /** Decodes a raw `FeeData` payload (`abi.encode(uint256 fee, address receiver)`) to its fee amount. */
+  static decodeFeePayload(payload) {
     const [feeAmount] = viem.decodeAbiParameters(
       [
         { name: "fee", type: "uint256" },
         { name: "receiver", type: "address" }
       ],
-      `0x${data.slice(4)}`
+      payload
     );
     return feeAmount;
   }
@@ -22360,7 +22758,9 @@ var SonicSpokeService = class {
       outputToken,
       `hub asset not found for spoke chain token (intent.outputToken): ${createIntentParams.outputToken}`
     );
-    const [feeData, feeAmount] = EvmSolverService.createIntentFeeData(fee, createIntentParams.inputAmount);
+    const { dstAddress, deliveryData } = HookService.resolveDelivery(createIntentParams);
+    const [feeEnvelope, feeAmount] = EvmSolverService.createIntentFeeData(fee, createIntentParams.inputAmount);
+    const intentData = IntentDataService.composeIntentData(feeEnvelope, deliveryData);
     const intentsContract = solverConfig2.intentsContract;
     const intent = {
       intentId: randomUint256(),
@@ -22374,10 +22774,10 @@ var SonicSpokeService = class {
       srcChain: getIntentRelayChainId(createIntentParams.srcChainKey),
       dstChain: getIntentRelayChainId(createIntentParams.dstChainKey),
       srcAddress: encodeAddress(createIntentParams.srcChainKey, createIntentParams.srcAddress),
-      dstAddress: encodeAddress(createIntentParams.dstChainKey, createIntentParams.dstAddress),
+      dstAddress: encodeAddress(createIntentParams.dstChainKey, dstAddress),
       solver: createIntentParams.solver ?? "0x0000000000000000000000000000000000000000",
-      data: feeData
-      // fee amount will be deducted from the input amount
+      data: intentData
+      // fee amount will be deducted from the input amount; may also carry delivery data
     };
     const txData = EvmSolverService.encodeCreateIntent(intent, intentsContract);
     const rawTx = {
@@ -26242,64 +26642,88 @@ 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 };
-      }
-      const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
-      const verifyTxHashResult = await this.spoke.verifyTxHash({
-        txHash: spokeTxHash,
-        chainKey: srcChainKey
-      });
-      if (!verifyTxHashResult.ok) {
-        return { ok: false, error: verifyFailed("swap", verifyTxHashResult.error, { ...baseCtx, action: "swap" }) };
-      }
-      let dstIntentTxHash;
-      if (isHubChainKeyType(srcChainKey)) {
-        dstIntentTxHash = spokeTxHash;
-      } else {
-        const packet = await relayTxAndWaitPacket({
-          srcTxHash: spokeTxHash,
-          data: relayData,
-          chainKey: srcChainKey,
-          relayerApiEndpoint: this.relayerApiEndpoint,
-          timeout
-        });
-        if (!packet.ok) {
-          return { ok: false, error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx }) };
-        }
-        dstIntentTxHash = packet.value.dst_tx_hash;
-      }
-      const postExecResult = await this.postExecution({
-        intent_tx_hash: dstIntentTxHash
-      });
-      if (!postExecResult.ok) {
-        return { ok: false, error: postExecResult.error };
-      }
-      return {
-        ok: true,
-        value: {
-          solverExecutionResponse: postExecResult.value,
-          intent,
-          intentDeliveryInfo: {
-            srcChainKey,
-            srcTxHash: spokeTxHash,
-            srcAddress: params.srcAddress,
-            dstChainKey: params.dstChainKey,
-            dstTxHash: dstIntentTxHash,
-            dstAddress: params.dstAddress
+    return this.config.analytics.trackResult(
+      "swap",
+      "swap",
+      async () => {
+        try {
+          const timeout = _params.timeout;
+          const createIntentResult = await this.createIntent(_params);
+          if (!createIntentResult.ok) {
+            return { ok: false, error: createIntentResult.error };
+          }
+          const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
+          const verifyTxHashResult = await this.spoke.verifyTxHash({
+            txHash: spokeTxHash,
+            chainKey: srcChainKey
+          });
+          if (!verifyTxHashResult.ok) {
+            return { ok: false, error: verifyFailed("swap", verifyTxHashResult.error, { ...baseCtx, action: "swap" }) };
+          }
+          let dstIntentTxHash;
+          if (isHubChainKeyType(srcChainKey)) {
+            dstIntentTxHash = spokeTxHash;
+          } else {
+            const packet = await relayTxAndWaitPacket({
+              srcTxHash: spokeTxHash,
+              data: relayData,
+              chainKey: srcChainKey,
+              relayerApiEndpoint: this.relayerApiEndpoint,
+              timeout
+            });
+            if (!packet.ok) {
+              return {
+                ok: false,
+                error: mapRelayFailure(packet.error, { feature: "swap", action: "swap", ...baseCtx })
+              };
+            }
+            dstIntentTxHash = packet.value.dst_tx_hash;
           }
+          const postExecResult = await this.postExecution({
+            intent_tx_hash: dstIntentTxHash
+          });
+          if (!postExecResult.ok) {
+            return { ok: false, error: postExecResult.error };
+          }
+          return {
+            ok: true,
+            value: {
+              solverExecutionResponse: postExecResult.value,
+              intent,
+              intentDeliveryInfo: {
+                srcChainKey,
+                srcTxHash: spokeTxHash,
+                srcAddress: params.srcAddress,
+                dstChainKey: params.dstChainKey,
+                dstTxHash: dstIntentTxHash,
+                dstAddress: params.dstAddress
+              }
+            }
+          };
+        } catch (error) {
+          if (isSwapError(error)) return { ok: false, error };
+          return {
+            ok: false,
+            error: unknownFailed("swap", error, { ...baseCtx, action: "swap" })
+          };
         }
-      };
-    } 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 })
+      }
+    );
   }
   /**
    * Checks whether the relevant spender contract is already approved to spend the input token amount.
@@ -28345,72 +28769,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.
@@ -28425,37 +28871,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
@@ -28473,37 +28939,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.
@@ -28520,37 +29005,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.
@@ -29604,49 +30110,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,
@@ -29675,8 +30203,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"
@@ -29744,6 +30272,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.
    *
@@ -30626,52 +31168,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.
@@ -30776,42 +31337,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.
@@ -30907,42 +31486,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.
@@ -31050,42 +31648,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.
@@ -31199,42 +31816,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.
@@ -32608,34 +33243,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.
@@ -32650,33 +33307,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.
@@ -32691,33 +33371,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.
@@ -32869,34 +33570,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.
@@ -35819,50 +36540,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
@@ -35979,58 +36718,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
@@ -36128,59 +36885,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
@@ -36276,50 +37051,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
@@ -37020,50 +37813,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.
@@ -37175,6 +37985,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.
@@ -37198,6 +38013,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,
@@ -37245,47 +38079,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) };
     }
   }
 };
@@ -37420,42 +38425,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 })
+      }
+    );
   }
 };
 
@@ -37915,70 +38940,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.
@@ -38355,6 +39403,7 @@ 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;
     this.instanceConfig = options ? mergeSodaxConfig(sodaxConfig, options) : sodaxConfig;
     this.backendApi = new BackendApiService(this.instanceConfig.api, logger);
@@ -38363,6 +39412,7 @@ var Sodax = class {
       config: this.instanceConfig,
       userConfig: options,
       logger,
+      analytics,
       fee
     });
     this.hubProvider = new EvmHubProvider({ config: this.config });
@@ -38458,6 +39508,7 @@ exports.BitcoinSpokeService = BitcoinSpokeService;
 exports.BnUSDMigrationService = BnUSDMigrationService;
 exports.BridgeService = BridgeService;
 exports.CHAIN_KEYS = CHAIN_KEYS;
+exports.CHAIN_LOGO_BASE_URL = CHAIN_LOGO_BASE_URL;
 exports.CONFIG_VERSION = CONFIG_VERSION;
 exports.CREATE_INTENT_CODES = CREATE_INTENT_CODES;
 exports.ChainKeys = ChainKeys;
@@ -38492,6 +39543,8 @@ exports.GAS_ESTIMATION_CODES = GAS_ESTIMATION_CODES;
 exports.HALF_RAY = HALF_RAY;
 exports.HALF_WAD = HALF_WAD;
 exports.HUB_CHAIN_KEY = HUB_CHAIN_KEY;
+exports.HookKind = HookKind;
+exports.HookService = HookService;
 exports.HttpRelayError = HttpRelayError;
 exports.HubVaultSymbols = HubVaultSymbols;
 exports.ICON_CHAIN_KEYS = ICON_CHAIN_KEYS;
@@ -38505,6 +39558,7 @@ exports.IcxMigrationService = IcxMigrationService;
 exports.Injective20Token = Injective20Token;
 exports.InjectiveSpokeService = InjectiveSpokeService;
 exports.IntentCreatedEventAbi = IntentCreatedEventAbi;
+exports.IntentDataService = IntentDataService;
 exports.IntentDataType = IntentDataType;
 exports.IntentFilledEventAbi = IntentFilledEventAbi;
 exports.IntentRelayChainIdToChainKey = IntentRelayChainIdToChainKey;
@@ -38659,6 +39713,8 @@ exports.getReserveNormalizedIncome = getReserveNormalizedIncome;
 exports.getReservesEModes = getReservesEModes;
 exports.getSolanaAddressBytes = getSolanaAddressBytes;
 exports.getSolverConfig = getSolverConfig;
+exports.getSpokeHook = getSpokeHook;
+exports.getSpokeHooks = getSpokeHooks;
 exports.getStagingSolverTokens = getStagingSolverTokens;
 exports.getSupportedSolverTokens = getSupportedSolverTokens;
 exports.getTransactionPackets = getTransactionPackets;
@@ -38690,6 +39746,7 @@ exports.isEvmSpokeOnlyChainKey = isEvmSpokeOnlyChainKey;
 exports.isEvmSpokeOnlyChainKeyType = isEvmSpokeOnlyChainKeyType;
 exports.isEvmWalletProviderType = isEvmWalletProviderType;
 exports.isFeatureError = isFeatureError;
+exports.isHookSupportedToken = isHookSupportedToken;
 exports.isHubChainKey = isHubChainKey;
 exports.isHubChainKeyType = isHubChainKeyType;
 exports.isIconAddress = isIconAddress;
@@ -38793,6 +39850,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;
@@ -38821,6 +39879,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;
@@ -38836,6 +39895,7 @@ exports.sonicWalletFactoryAbi = sonicWalletFactoryAbi;
 exports.spokeAssetManagerAbi = spokeAssetManagerAbi;
 exports.spokeChainConfig = spokeChainConfig;
 exports.spokeChainKeysSet = spokeChainKeysSet;
+exports.spokeHooks = spokeHooks;
 exports.stacksSupportedTokens = stacksSupportedTokens;
 exports.stagingSwapSupportedTokens = stagingSwapSupportedTokens;
 exports.stakedSodaAbi = stakedSodaAbi;