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

package/dist/index.cjs

@@ -4246,7 +4246,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 215;
+var CONFIG_VERSION = 216;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -10649,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"
   }
 ];
 
@@ -13556,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;
@@ -13566,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
@@ -13583,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);
   }
@@ -13638,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());
   }
@@ -26425,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.
@@ -28528,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.
@@ -28608,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
@@ -28656,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.
@@ -28703,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.
@@ -29787,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,
@@ -29858,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"
@@ -29927,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.
    *
@@ -30809,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.
@@ -30959,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.
@@ -31090,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.
@@ -31233,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.
@@ -31382,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.
@@ -32791,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.
@@ -32833,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.
@@ -32874,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.
@@ -33052,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.
@@ -36002,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
@@ -36162,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
@@ -36311,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
@@ -36459,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
@@ -37203,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.
@@ -37358,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.
@@ -37381,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,
@@ -37428,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) };
     }
   }
 };
@@ -37603,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 })
+      }
+    );
   }
 };
 
@@ -38098,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.
@@ -38538,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);
@@ -38546,6 +39412,7 @@ var Sodax = class {
       config: this.instanceConfig,
       userConfig: options,
       logger,
+      analytics,
       fee
     });
     this.hubProvider = new EvmHubProvider({ config: this.config });
@@ -38983,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;
@@ -39011,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;