@circle-fin/app-kit 1.4.2 → 1.5.1

package/index.cjs

@@ -3405,6 +3405,8 @@ exports.Blockchain = void 0;
     Blockchain["Hedera_Testnet"] = "Hedera_Testnet";
     Blockchain["HyperEVM"] = "HyperEVM";
     Blockchain["HyperEVM_Testnet"] = "HyperEVM_Testnet";
+    Blockchain["Injective"] = "Injective";
+    Blockchain["Injective_Testnet"] = "Injective_Testnet";
     Blockchain["Ink"] = "Ink";
     Blockchain["Ink_Testnet"] = "Ink_Testnet";
     Blockchain["Linea"] = "Linea";
@@ -3624,6 +3626,7 @@ exports.BridgeChain = void 0;
     BridgeChain["Edge"] = "Edge";
     BridgeChain["Ethereum"] = "Ethereum";
     BridgeChain["HyperEVM"] = "HyperEVM";
+    BridgeChain["Injective"] = "Injective";
     BridgeChain["Ink"] = "Ink";
     BridgeChain["Linea"] = "Linea";
     BridgeChain["Monad"] = "Monad";
@@ -3647,6 +3650,7 @@ exports.BridgeChain = void 0;
     BridgeChain["Edge_Testnet"] = "Edge_Testnet";
     BridgeChain["Ethereum_Sepolia"] = "Ethereum_Sepolia";
     BridgeChain["HyperEVM_Testnet"] = "HyperEVM_Testnet";
+    BridgeChain["Injective_Testnet"] = "Injective_Testnet";
     BridgeChain["Ink_Testnet"] = "Ink_Testnet";
     BridgeChain["Linea_Sepolia"] = "Linea_Sepolia";
     BridgeChain["Monad_Testnet"] = "Monad_Testnet";
@@ -5091,6 +5095,98 @@ const HyperEVMTestnet = defineChain({
     },
 });
 
+/**
+ * Injective Mainnet chain definition
+ * @remarks
+ * This represents the official production network for the Injective blockchain.
+ * Injective is a high-performance, interoperable Layer-1 blockchain built for
+ * finance, with an EVM execution layer on top of a Cosmos SDK base and
+ * sub-second block finality.
+ */
+const Injective = defineChain({
+    type: 'evm',
+    chain: exports.Blockchain.Injective,
+    name: 'Injective',
+    title: 'Injective Mainnet',
+    nativeCurrency: {
+        name: 'Injective',
+        symbol: 'INJ',
+        decimals: 18,
+    },
+    chainId: 1776,
+    isTestnet: false,
+    explorerUrl: 'https://injscan.com/transaction/{hash}',
+    rpcEndpoints: ['https://sentry.evm-rpc.injective.network'],
+    eurcAddress: null,
+    usdcAddress: '0xa00C59fF5a080D2b954d0c75e46E22a0c371235a',
+    usdtAddress: null,
+    cctp: {
+        domain: 29,
+        contracts: {
+            v2: {
+                type: 'split',
+                tokenMessenger: '0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d',
+                messageTransmitter: '0x81D40F21F12A8F0E3252Bccb954D722d4c464B64',
+                confirmations: 1,
+                fastConfirmations: 1,
+            },
+        },
+        forwarderSupported: {
+            source: false,
+            destination: false,
+        },
+    },
+    kitContracts: {
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+    },
+});
+
+/**
+ * Injective Testnet chain definition
+ * @remarks
+ * This represents the official test network for the Injective blockchain.
+ * Injective is a high-performance, interoperable Layer-1 blockchain built for
+ * finance, with an EVM execution layer on top of a Cosmos SDK base and
+ * sub-second block finality.
+ */
+const InjectiveTestnet = defineChain({
+    type: 'evm',
+    chain: exports.Blockchain.Injective_Testnet,
+    name: 'Injective Testnet',
+    title: 'Injective Testnet',
+    nativeCurrency: {
+        name: 'Injective',
+        symbol: 'INJ',
+        decimals: 18,
+    },
+    chainId: 1439,
+    isTestnet: true,
+    explorerUrl: 'https://testnet.explorer.injective.network/transaction/{hash}',
+    rpcEndpoints: ['https://k8s.testnet.json-rpc.injective.network'],
+    eurcAddress: null,
+    usdcAddress: '0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d',
+    usdtAddress: null,
+    cctp: {
+        domain: 29,
+        contracts: {
+            v2: {
+                type: 'split',
+                tokenMessenger: '0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA',
+                messageTransmitter: '0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275',
+                confirmations: 1,
+                fastConfirmations: 1,
+            },
+        },
+        forwarderSupported: {
+            source: false,
+            destination: false,
+        },
+    },
+    kitContracts: {
+        bridge: BRIDGE_CONTRACT_EVM_TESTNET,
+    },
+});
+
 /**
  * Ink Mainnet chain definition
  * @remarks
@@ -6933,6 +7029,8 @@ var Chains = {
     HederaTestnet: HederaTestnet,
     HyperEVM: HyperEVM,
     HyperEVMTestnet: HyperEVMTestnet,
+    Injective: Injective,
+    InjectiveTestnet: InjectiveTestnet,
     Ink: Ink,
     InkTestnet: InkTestnet,
     Linea: Linea,
@@ -7554,6 +7652,44 @@ function resolveChainIdentifier(chainIdentifier) {
     throw new Error(`Invalid chain identifier type: ${typeof chainIdentifier}. Expected ChainDefinition object, Blockchain enum, or string literal.`);
 }
 
+/**
+ * Resolve a chain identifier to a plain chain-name string.
+ *
+ * Accept a string literal (`'Ethereum'`), a `ChainDefinition`-like
+ * object (`{ chain: 'Ethereum' }`), or `null`/`undefined` and return
+ * the chain name as a string. Return `undefined` when the value
+ * cannot be resolved.
+ *
+ * @remarks
+ * Unlike `resolveChainIdentifier` (which returns a full `ChainDefinition`
+ * and throws on invalid input), this helper is intentionally lenient and
+ * never throws — it is safe to call in error-handling and telemetry paths.
+ *
+ * @param value - A string, chain-definition object, or nullish value.
+ * @returns The chain name string, or `undefined`.
+ *
+ * @example
+ * ```typescript
+ * import { resolveChainName } from '@core/chains'
+ *
+ * resolveChainName('Ethereum')              // 'Ethereum'
+ * resolveChainName({ chain: 'Ethereum' })   // 'Ethereum'
+ * resolveChainName(undefined)               // undefined
+ * ```
+ */
+function resolveChainName(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' &&
+        'chain' in value &&
+        typeof value.chain === 'string') {
+        return value.chain;
+    }
+    return undefined;
+}
+
 /**
  * @packageDocumentation
  * @module SwapTokenUtils
@@ -9210,6 +9346,7 @@ const USDC = {
         [exports.Blockchain.Ethereum]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
         [exports.Blockchain.Hedera]: '0.0.456858',
         [exports.Blockchain.HyperEVM]: '0xb88339CB7199b77E23DB6E890353E22632Ba630f',
+        [exports.Blockchain.Injective]: '0xa00C59fF5a080D2b954d0c75e46E22a0c371235a',
         [exports.Blockchain.Ink]: '0x2D270e6886d130D724215A266106e6832161EAEd',
         [exports.Blockchain.Linea]: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff',
         [exports.Blockchain.Monad]: '0x754704Bc059F8C67012fEd69BC8A327a5aafb603',
@@ -9242,6 +9379,7 @@ const USDC = {
         [exports.Blockchain.Ethereum_Sepolia]: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
         [exports.Blockchain.Hedera_Testnet]: '0.0.429274',
         [exports.Blockchain.HyperEVM_Testnet]: '0x2B3370eE501B4a559b57D449569354196457D8Ab',
+        [exports.Blockchain.Injective_Testnet]: '0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d',
         [exports.Blockchain.Ink_Testnet]: '0xFabab97dCE620294D2B0b0e46C68964e326300Ac',
         [exports.Blockchain.Linea_Sepolia]: '0xfece4462d57bd51a6a552365a011b95f0e16d9b7',
         [exports.Blockchain.Monad_Testnet]: '0x534b2f3A21130d7a60830c2Df862319e593943A3',
@@ -10343,8 +10481,325 @@ async function retryAsync(fn, options) {
     throw new Error('retryAsync: unreachable');
 }
 
+/**
+ * Default telemetry endpoint.
+ *
+ * Override via the `STABLECOIN_KITS_TELEMETRY_URL` environment variable
+ * (e.g. for staging or local development).
+ *
+ * @internal
+ */
+const DEFAULT_LOGS_URL = 'https://api.circle.com/v1/stablecoinKits/logs';
+/**
+ * Resolve the telemetry endpoint URL.
+ *
+ * @internal
+ */
+function getLogsUrl() {
+    if (isNodeEnvironment() &&
+        typeof process.env['STABLECOIN_KITS_TELEMETRY_URL'] === 'string' &&
+        process.env['STABLECOIN_KITS_TELEMETRY_URL'].length > 0) {
+        return process.env['STABLECOIN_KITS_TELEMETRY_URL'];
+    }
+    return DEFAULT_LOGS_URL;
+}
+/**
+ * Send a telemetry event to the proxy service.
+ *
+ * @remarks
+ * Fire-and-forget: the returned promise is intentionally not awaited
+ * by the caller. A fetch failure (network error, non-2xx, timeout)
+ * is silently swallowed so telemetry never blocks or fails user
+ * operations.
+ *
+ * @param payload - The structured log payload matching the server schema.
+ *
+ * @example
+ * ```typescript
+ * import { emitAnalyticsLog } from '@core/utils'
+ *
+ * // Fire-and-forget — do not await
+ * void emitAnalyticsLog(payload)
+ * ```
+ */
+async function emitAnalyticsLog(payload) {
+    try {
+        const isNode = isNodeEnvironment();
+        const userAgent = getUserAgent();
+        await fetch(getLogsUrl(), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                // Browser restricts setting User-Agent; use X-User-Agent instead.
+                ...(isNode
+                    ? { 'User-Agent': userAgent }
+                    : { 'X-User-Agent': userAgent }),
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(5_000),
+        });
+    }
+    catch {
+        // Silently swallow — telemetry must never break user operations.
+    }
+}
+
+/**
+ * Build the `clientContext` object for telemetry payloads.
+ *
+ * @remarks
+ * Use the exported `getRuntime()` and `isNodeEnvironment()` from
+ * `@core/utils` to detect the runtime environment. The returned
+ * string is parsed into the structured `ClientContext` fields
+ * expected by the server schema.
+ *
+ * @returns A {@link ClientContext} with platform, OS, and runtime name
+ *   populated from the current environment.
+ *
+ * @example
+ * ```typescript
+ * import { buildClientContext } from '@core/utils'
+ *
+ * const ctx = buildClientContext()
+ * // Node: { platform: 'node', os: 'darwin', runtimeName: null }
+ * // Browser: { platform: 'browser', os: null, runtimeName: 'chrome' }
+ * ```
+ */
+function buildClientContext() {
+    const runtime = getRuntime();
+    if (runtime.startsWith('browser/')) {
+        return {
+            platform: 'browser',
+            os: null,
+            runtimeName: runtime.slice('browser/'.length).toLowerCase(),
+        };
+    }
+    if (runtime.startsWith('node/')) {
+        return {
+            platform: 'node',
+            os: isNodeEnvironment() ? process.platform : null,
+            runtimeName: null,
+        };
+    }
+    return {
+        platform: 'node',
+        os: null,
+        runtimeName: null,
+    };
+}
+
+/**
+ * Extract structured error details from an unknown error value.
+ *
+ * @remarks
+ * Handle three cases:
+ * - `KitError` — extract `code` and `name`.
+ * - `Error` — extract `name`.
+ * - Anything else — return empty details.
+ *
+ * Only structured, bounded fields (`errorCode`, `errorType`) are
+ * included. Free-text fields (`message`, `stack`) are intentionally
+ * omitted to avoid leaking secrets or PII through vendor telemetry.
+ *
+ * @param error - The thrown value to extract details from.
+ * @returns A {@link ErrorDetails} object suitable for telemetry payloads.
+ *
+ * @example
+ * ```typescript
+ * import { extractErrorDetails } from '@core/utils'
+ *
+ * try {
+ *   await riskyOperation()
+ * } catch (error) {
+ *   const details = extractErrorDetails(error)
+ *   // { errorCode: '1001', errorType: 'INPUT_NETWORK_MISMATCH' }
+ * }
+ * ```
+ */
+function extractErrorDetails(error) {
+    if (error instanceof KitError) {
+        return {
+            errorCode: String(error.code),
+            errorType: error.name,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            errorType: error.name,
+        };
+    }
+    return {};
+}
+
+/**
+ * Register event handlers on an action dispatcher that emit analytics
+ * telemetry for the configured events.
+ *
+ * @remarks
+ * Subscribe to each action name in `actionEventMap`, call `mapEventToPayload`
+ * for each event, and fire-and-forget `emitAnalyticsLog` if a non-null
+ * payload is returned. All errors are silently swallowed so telemetry
+ * never blocks or fails user operations.
+ *
+ * @param dispatcher - The `Actionable` instance from the kit.
+ * @param sdkName - SDK package name (e.g. `'unified-balance-kit'`).
+ * @param sdkVersion - SDK version string (e.g. `'1.0.0'`).
+ * @param actionEventMap - Map of action names to subscribe to.
+ * @param mapEventToPayload - Function that maps an action name and payload
+ *   to a {@link ClientLogPayload}, or `null` to skip logging.
+ *
+ * @example
+ * ```typescript
+ * import { registerTelemetryHandler } from '@core/utils'
+ *
+ * registerTelemetryHandler(
+ *   dispatcher,
+ *   'unified-balance-kit',
+ *   '1.0.0',
+ *   VERB_EVENT_MAP,
+ *   mapSucceededEventToLog,
+ * )
+ * ```
+ */
+function registerTelemetryHandler$1(dispatcher, sdkName, sdkVersion, actionEventMap, mapEventToPayload) {
+    for (const actionName of Object.keys(actionEventMap)) {
+        dispatcher.on(actionName, (payload) => {
+            try {
+                const log = mapEventToPayload(actionName, payload, sdkName, sdkVersion);
+                if (log) {
+                    // Fire-and-forget — intentionally not awaited.
+                    void emitAnalyticsLog(log);
+                }
+            }
+            catch {
+                // Silently swallow — telemetry must never break user operations.
+            }
+        });
+    }
+}
+
+/**
+ * Strip the `@circle-fin/` scope from a kit package name to produce the
+ * short SDK name used in telemetry payloads.
+ *
+ * @param pkgName - The full npm package name (e.g. `@circle-fin/bridge-kit`).
+ * @returns The unscoped kit name (e.g. `bridge-kit`).
+ *
+ * @example
+ * ```typescript
+ * import pkg from '../../package.json'
+ * import { resolveKitSdkName } from '@core/utils'
+ *
+ * const SDK_NAME = resolveKitSdkName(pkg.name) // 'bridge-kit'
+ * ```
+ */
+function resolveKitSdkName(pkgName) {
+    return pkgName.replace('@circle-fin/', '');
+}
+
+/**
+ * Build a telemetry payload from common fields.
+ *
+ * @internal
+ */
+function buildPayload$1(config, eventType, errorDetails, context) {
+    return {
+        sdkName: config.sdkName,
+        sdkVersion: config.sdkVersion,
+        eventType,
+        timestamp: new Date().toISOString(),
+        errorDetails,
+        clientContext: buildClientContext(),
+        ...(context?.sourceChain != null && {
+            sourceChain: context.sourceChain,
+        }),
+        ...(context?.destinationChain != null && {
+            destinationChain: context.destinationChain,
+        }),
+        ...(context?.tokenIn != null && { tokenIn: context.tokenIn }),
+        ...(context?.tokenOut != null && { tokenOut: context.tokenOut }),
+    };
+}
+/**
+ * Wrap an async operation with error telemetry.
+ *
+ * Execute `fn` and, if it throws, emit an error telemetry payload
+ * before re-throwing. No-ops when `config.disabled` is `true`.
+ *
+ * @param fn - The async operation to execute.
+ * @param eventType - The telemetry event type for this operation.
+ * @param config - Per-kit SDK identity and disabled flag.
+ * @param context - Optional chain/token context.
+ * @returns The result of the operation.
+ * @throws Re-throws any error after emitting telemetry.
+ *
+ * @example
+ * ```typescript
+ * import { withErrorTelemetry } from '@core/utils'
+ *
+ * const result = await withErrorTelemetry(
+ *   () => provider.bridge(params),
+ *   'bridge_bridge',
+ *   { sdkName: 'bridge-kit', sdkVersion: '1.0.0', disabled: false },
+ *   { sourceChain: 'Ethereum', destinationChain: 'Base', tokenIn: 'USDC' },
+ * )
+ * ```
+ */
+async function withErrorTelemetry(fn, eventType, config, context) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (!config.disabled) {
+            void emitAnalyticsLog(buildPayload$1(config, eventType, extractErrorDetails(error), context));
+        }
+        throw error;
+    }
+}
+/**
+ * Emit error telemetry for a result-reported step error.
+ *
+ * Handle the case where a provider reports a step failure inside a
+ * result object (e.g. `BridgeResult.state === 'error'`) rather than
+ * throwing. The caller extracts the failed step as a simple
+ * {@link FailedStepInfo} — this function handles sanitization,
+ * step-to-event mapping, and emission.
+ *
+ * No-ops when `config.disabled` is `true`.
+ *
+ * @param failedStep - The failed step info, or undefined if none found.
+ * @param stepEventMap - Ordered mapping from step names to event types.
+ * @param fallbackEventType - Event type when step is not in the map.
+ * @param config - Per-kit SDK identity and disabled flag.
+ * @param context - Optional chain/token context.
+ *
+ * @example
+ * ```typescript
+ * import { emitResultStepErrorTelemetry } from '@core/utils'
+ *
+ * const failedStep = result.steps.find((s) => s.state === 'error')
+ * emitResultStepErrorTelemetry(
+ *   failedStep,
+ *   BRIDGE_STEP_EVENT_MAP,
+ *   'bridge_bridge',
+ *   { sdkName: 'bridge-kit', sdkVersion: '1.0.0', disabled: false },
+ *   { sourceChain: 'Ethereum', tokenIn: 'USDC' },
+ * )
+ * ```
+ */
+function emitResultStepErrorTelemetry(failedStep, stepEventMap, fallbackEventType, config, context) {
+    if (config.disabled) {
+        return;
+    }
+    const stepEntry = stepEventMap.find(([name]) => name === failedStep?.name);
+    const errorDetails = {
+        ...(failedStep?.name != null && { errorType: failedStep.name }),
+    };
+    void emitAnalyticsLog(buildPayload$1(config, stepEntry?.[1] ?? fallbackEventType, errorDetails, context));
+}
+
 var name$2 = "@circle-fin/bridge-kit";
-var version$3 = "1.9.0";
+var version$3 = "1.10.0";
 var pkg$3 = {
 	name: name$2,
 	version: version$3};
@@ -13309,18 +13764,16 @@ const buildIrisUrl = (sourceDomainId, transactionHash, isTestnet) => {
 };
 /**
  * Fetches attestation data from the IRIS API with retry and timeout handling.
- * Since fetching starts after a confirmed burn transaction, we attempt up to 10 retries.
- * Implements a conservative delay between requests to respect the API rate
- * limit of 35 requests per second. To avoid rate limiting when multiple processes are
- * running concurrently, we enforce a 200ms delay between retries.
  *
- * Each HTTP request is given a maximum of 2 seconds before it is aborted.
- * We retry up to 10 times, waiting 200ms between attempts.
+ * Polls the IRIS API until a complete attestation is available. The default
+ * window is sized for slow source chains where finality may take many
+ * confirmations.
  *
- * The total maximum time this function might take (worst case) is:
- * - Per‐attempt timeout: 2 000 ms
- * - Retry delays: 9 × 200 ms = 1 800 ms
- * - Total max time: 2 000 ms + 1 800 ms = 3 800 ms
+ * Defaults (see `DEFAULT_CONFIG`):
+ * - Per-attempt timeout: 2 000 ms (each HTTP request aborts after 2 s)
+ * - Retry delay: 2 000 ms between attempts
+ * - Max retries: 600 (30 × 20)
+ * - Total worst-case polling window: 600 × (2 000 ms + 2 000 ms) ≈ 40 minutes
  *
  * @param sourceDomainId - The CCTP domain ID.
  * @param transactionHash - The transaction hash to fetch attestation for.
@@ -15297,7 +15750,7 @@ async function buildBatchedStep(name, receipt, batchId, adapter, chain, statusCo
     return step;
 }
 
-var version$2 = "1.7.0";
+var version$2 = "1.8.1";
 var pkg$2 = {
 	version: version$2};
 
@@ -16963,6 +17416,35 @@ const formatBridgeResult = (result, formatDirection) => {
     };
 };
 
+/**
+ * Telemetry event type identifiers for bridge-kit operations.
+ *
+ * @internal
+ */
+const BRIDGE_EVENT_TYPES = {
+    BRIDGE: 'bridge_bridge',
+    RETRY: 'bridge_retry',
+    ESTIMATE: 'bridge_estimate',
+};
+/**
+ * Ordered mapping from provider step event names to telemetry event types.
+ *
+ * @remarks
+ * The order matches the CCTP v2 bridge execution sequence. During
+ * `bridge()`, completed step events are counted so the failing step
+ * can be identified by its index.
+ *
+ * @internal
+ */
+const BRIDGE_STEP_EVENT_MAP = [
+    ['approve', 'bridge_approve'],
+    ['burn', 'bridge_burn'],
+    ['fetchAttestation', 'bridge_fetch_attestation'],
+    ['mint', 'bridge_mint'],
+];
+
+/** SDK name used in telemetry payloads. */
+const SDK_NAME$2 = resolveKitSdkName(pkg$3.name);
 /**
  * BridgeKit caller component for retry and estimate operations.
  */
@@ -17046,6 +17528,10 @@ class BridgeKit {
      * A custom fee policy for the kit.
      */
     customFeePolicy;
+    /** Whether error telemetry is disabled. */
+    disableErrorReporting;
+    /** Per-kit telemetry identity for shared helpers. */
+    telemetryConfig;
     /**
      * Create a new BridgeKit instance.
      *
@@ -17063,6 +17549,12 @@ class BridgeKit {
         const defaultProviders = getDefaultProviders$2();
         this.providers = [...defaultProviders, ...(config.providers ?? [])];
         this.actionDispatcher = new Actionable();
+        this.disableErrorReporting = config.disableErrorReporting === true;
+        this.telemetryConfig = {
+            sdkName: SDK_NAME$2,
+            sdkVersion: pkg$3.version,
+            disabled: this.disableErrorReporting,
+        };
         for (const provider of this.providers) {
             provider.registerDispatcher(this.actionDispatcher);
         }
@@ -17136,19 +17628,36 @@ class BridgeKit {
      * ```
      */
     async bridge(params) {
-        // First validate the parameters
-        assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
-        // Then resolve chain definitions (includes adapter chain support validation)
-        const resolvedParams = await resolveBridgeParams(params);
-        // Validate network compatibility
-        this.validateNetworkCompatibility(resolvedParams);
-        // Merge the custom fee config into the resolved params
-        const finalResolvedParams = await this.mergeCustomFeeConfig(resolvedParams);
-        // Find a provider that supports this route
-        const provider = this.findProviderForRoute(finalResolvedParams);
-        // Execute the transfer using the provider
-        // Format the bridge result into human-readable string values for the user
-        return formatBridgeResult(await provider.bridge(finalResolvedParams), 'to-human-readable');
+        return withErrorTelemetry(async () => {
+            // First validate the parameters
+            assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
+            // Then resolve chain definitions (includes adapter chain support validation)
+            const resolvedParams = await resolveBridgeParams(params);
+            // Validate network compatibility
+            this.validateNetworkCompatibility(resolvedParams);
+            // Merge the custom fee config into the resolved params
+            const finalResolvedParams = await this.mergeCustomFeeConfig(resolvedParams);
+            // Find a provider that supports this route
+            const provider = this.findProviderForRoute(finalResolvedParams);
+            // Execute the transfer using the provider
+            // Format the bridge result into human-readable string values for the user
+            const result = formatBridgeResult(await provider.bridge(finalResolvedParams), 'to-human-readable');
+            // Emit error telemetry when the provider returns an error state
+            // (provider records step failures in the result instead of throwing).
+            if (result.state === 'error') {
+                const failedStep = result.steps.find((s) => s.state === 'error');
+                emitResultStepErrorTelemetry(failedStep, BRIDGE_STEP_EVENT_MAP, BRIDGE_EVENT_TYPES.BRIDGE, this.telemetryConfig, {
+                    sourceChain: resolveChainName(params.from.chain),
+                    destinationChain: resolveChainName(params.to.chain),
+                    tokenIn: params.token,
+                });
+            }
+            return result;
+        }, BRIDGE_EVENT_TYPES.BRIDGE, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from.chain),
+            destinationChain: resolveChainName(params.to.chain),
+            tokenIn: params.token,
+        });
     }
     /**
      * Retry a failed or incomplete cross-chain USDC bridge operation.
@@ -17220,17 +17729,33 @@ class BridgeKit {
      * ```
      */
     async retry(result, context, invocationMeta) {
-        const provider = this.providers.find((p) => p.name === result.provider);
-        if (!provider) {
-            throw new Error(`Provider ${result.provider} not found`);
-        }
-        // Merge BridgeKit caller into invocation metadata for retry operation
-        const mergedMeta = mergeRetryInvocationMeta(invocationMeta);
-        // Format the bridge result into bigint string values for internal use
-        const formattedBridgeResultInternal = formatBridgeResult(result, 'to-internal');
-        // Execute the retry using the provider
-        // Format the bridge result into human-readable string values for the user
-        return formatBridgeResult(await provider.retry(formattedBridgeResultInternal, context, mergedMeta), 'to-human-readable');
+        return withErrorTelemetry(async () => {
+            const provider = this.providers.find((p) => p.name === result.provider);
+            if (!provider) {
+                throw new Error(`Provider ${result.provider} not found`);
+            }
+            // Merge BridgeKit caller into invocation metadata for retry operation
+            const mergedMeta = mergeRetryInvocationMeta(invocationMeta);
+            // Format the bridge result into bigint string values for internal use
+            const formattedBridgeResultInternal = formatBridgeResult(result, 'to-internal');
+            // Execute the retry using the provider
+            // Format the bridge result into human-readable string values for the user
+            const retryResult = formatBridgeResult(await provider.retry(formattedBridgeResultInternal, context, mergedMeta), 'to-human-readable');
+            // Emit error telemetry when the provider returns an error state.
+            if (retryResult.state === 'error') {
+                const failedStep = retryResult.steps.find((s) => s.state === 'error');
+                emitResultStepErrorTelemetry(failedStep, BRIDGE_STEP_EVENT_MAP, BRIDGE_EVENT_TYPES.RETRY, this.telemetryConfig, {
+                    sourceChain: result.source.chain.chain,
+                    destinationChain: result.destination.chain.chain,
+                    tokenIn: result.token,
+                });
+            }
+            return retryResult;
+        }, BRIDGE_EVENT_TYPES.RETRY, this.telemetryConfig, {
+            sourceChain: result.source.chain.chain,
+            destinationChain: result.destination.chain.chain,
+            tokenIn: result.token,
+        });
     }
     /**
      * Estimate the cost and fees for a cross-chain USDC bridge operation.
@@ -17269,18 +17794,24 @@ class BridgeKit {
      * ```
      */
     async estimate(params) {
-        // First validate the parameters
-        assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
-        // Then resolve chain definitions (includes adapter chain support validation)
-        const resolvedParams = await resolveBridgeParams(params);
-        // Validate network compatibility
-        this.validateNetworkCompatibility(resolvedParams);
-        // Merge the custom fee config into the resolved params
-        const finalResolvedParams = await this.mergeCustomFeeConfig(resolvedParams);
-        // Find a provider that supports this route
-        const provider = this.findProviderForRoute(finalResolvedParams);
-        // Estimate the transfer using the provider and format amounts to human-readable strings
-        return formatBridgeResult(await provider.estimate(finalResolvedParams), 'to-human-readable');
+        return withErrorTelemetry(async () => {
+            // First validate the parameters
+            assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
+            // Then resolve chain definitions (includes adapter chain support validation)
+            const resolvedParams = await resolveBridgeParams(params);
+            // Validate network compatibility
+            this.validateNetworkCompatibility(resolvedParams);
+            // Merge the custom fee config into the resolved params
+            const finalResolvedParams = await this.mergeCustomFeeConfig(resolvedParams);
+            // Find a provider that supports this route
+            const provider = this.findProviderForRoute(finalResolvedParams);
+            // Estimate the transfer using the provider and format amounts to human-readable strings
+            return formatBridgeResult(await provider.estimate(finalResolvedParams), 'to-human-readable');
+        }, BRIDGE_EVENT_TYPES.ESTIMATE, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from.chain),
+            destinationChain: resolveChainName(params.to.chain),
+            tokenIn: params.token,
+        });
     }
     /**
      * Get all chains supported by any provider in the kit, with optional filtering.
@@ -17597,7 +18128,11 @@ const createBridgeKit = (context) => {
     const getFee = context.getFee?.bind(context);
     const getFeeRecipient = context.getFeeRecipient?.bind(context);
     const hasBoth = typeof getFee === 'function' && typeof getFeeRecipient === 'function';
-    const kit = new BridgeKit();
+    const kit = new BridgeKit({
+        ...(context.disableErrorReporting != null && {
+            disableErrorReporting: context.disableErrorReporting,
+        }),
+    });
     if (hasBoth) {
         kit.setCustomFeePolicy({
             calculateFee: async (params) => {
@@ -17614,7 +18149,7 @@ const createBridgeKit = (context) => {
 };
 
 var name$1 = "@circle-fin/swap-kit";
-var version$1 = "1.1.1";
+var version$1 = "1.2.1";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -21494,6 +22029,119 @@ function evmSigningData(burnIntent) {
     };
 }
 
+/**
+ * EIP-7702 delegation indicator. A 7702-delegated EOA's bytecode is
+ * `0xef0100` followed by the 20-byte delegate address (23 bytes total).
+ * The underlying secp256k1 key still produces `ecrecover`-verifiable
+ * signatures, so for Gateway's purposes a 7702-delegated address is
+ * an EOA, not an SCA.
+ *
+ * Spec: https://eips.ethereum.org/EIPS/eip-7702
+ */
+const EIP_7702_DELEGATION_PREFIX = '0xef0100';
+/**
+ * Assert that `address` on `chain` can sign Gateway burn intents.
+ *
+ * Gateway verifies burn-intent signatures with plain `ecrecover` (see
+ * `evm-gateway-contracts/src/lib/EIP712Domain.sol`). Smart-contract
+ * accounts (SCAs) produce signatures over wrapped hashes (ERC-1271 /
+ * ERC-6492 / ERC-6900 replay-safe hashes) that Gateway cannot verify.
+ * Additionally, the Circle Wallets backend rejects SCA typed-data signing
+ * against Gateway's chainId-less domain with an opaque
+ * `invalid integer value <nil>/<nil> for type uint256` error.
+ *
+ * EIP-7702-delegated EOAs are exempt: they expose non-empty bytecode
+ * (`0xef0100<delegate>`) but the underlying secp256k1 key still produces
+ * `ecrecover`-verifiable signatures, so Gateway accepts them.
+ *
+ * When the signer is a true SCA, raises an `INPUT_UNSUPPORTED_ACTION`
+ * error directing the caller to register an EOA delegate against the
+ * SCA and then submit the spend with the delegate EOA as the signer
+ * and the SCA as the source account. See the unified-balance / Gateway
+ * docs for the exact API.
+ *
+ * If bytecode cannot be read (RPC failure, etc.) the pre-check is
+ * skipped and downstream signing surfaces its own error — a warning is
+ * logged so the skip is diagnosable.
+ *
+ * @param adapter - Anything exposing {@link EvmAdapterLike.readBytecode}.
+ * @param address - Signer address to validate.
+ * @param chain - EVM chain where the signer lives.
+ * @throws {KitError} INPUT_UNSUPPORTED_ACTION when `address` is an SCA.
+ *
+ * @example
+ * ```typescript
+ * import { assertSignerIsEoa } from '@core/adapter-evm'
+ * import { Ethereum } from '@core/chains'
+ *
+ * await assertSignerIsEoa(adapter, '0xabc...', Ethereum)
+ * ```
+ */
+async function assertSignerIsEoa(adapter, address, chain) {
+    let code;
+    try {
+        code = await adapter.readBytecode(address, chain);
+    }
+    catch (err) {
+        console.warn(`[gateway] assertSignerIsEoa skipped (readBytecode failed for ` +
+            `${address} on ${chain.name}): ` +
+            (err instanceof Error ? err.message : String(err)));
+        return;
+    }
+    if (code === undefined ||
+        code === '0x' ||
+        code.toLowerCase().startsWith(EIP_7702_DELEGATION_PREFIX)) {
+        return;
+    }
+    throw new KitError({
+        ...InputError.UNSUPPORTED_ACTION,
+        recoverability: 'FATAL',
+        message: `Gateway burn-intent signing requires an EOA signer (Gateway ` +
+            `verifies signatures with ecrecover and does not support ERC-1271). ` +
+            `The signer ${address} on ${chain.name} has on-chain bytecode, ` +
+            `indicating it is a smart-contract account (SCA). Register an EOA ` +
+            `delegate against the SCA, then submit the spend with the delegate ` +
+            `EOA as the signer and the SCA as the source account. See DEVX-2774.`,
+        cause: {
+            trace: {
+                operation: 'signEvmIntentGroup.assertSignerIsEoa',
+                address,
+                chain: chain.name,
+                bytecodeBytes: (code.length - 2) / 2,
+                bytecodePrefix: code.slice(0, 12),
+            },
+        },
+    });
+}
+
+/**
+ * Duck-type test for an EVM adapter that exposes `readBytecode`.
+ *
+ * Used as a structural guard at package boundaries (e.g. the Circle Wallets
+ * hybrid adapter calling into a chain adapter, or the Gateway sign path
+ * receiving an arbitrary adapter implementation) where `instanceof EvmAdapter`
+ * is unreliable because each consumer bundles its own copy of the base class.
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is an object exposing a callable
+ *   `readBytecode` method, narrowed to {@link EvmAdapterLike}.
+ *
+ * @example
+ * ```typescript
+ * import { isEvmAdapterLike } from '@core/adapter-evm'
+ *
+ * if (isEvmAdapterLike(adapter)) {
+ *   const code = await adapter.readBytecode('0xabc...', chain)
+ * }
+ * ```
+ */
+function isEvmAdapterLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'readBytecode' in value &&
+        typeof value.readBytecode === 'function');
+}
+
 /**
  * Sign an EVM adapter group: batches all intents and produces a single
  * EIP-712 ECDSA signature.
@@ -21501,6 +22149,12 @@ function evmSigningData(burnIntent) {
  * For a single-intent group, `primaryType` is `'BurnIntent'`.
  * For multi-intent groups, `primaryType` is `'BurnIntentSet'`.
  *
+ * Before signing, asserts that the signer address is an EOA. Gateway
+ * verifies burn-intent signatures with plain `ecrecover` (no ERC-1271
+ * fallback), so signatures produced by smart-contract accounts (SCAs)
+ * cannot be verified. When an SCA is detected, a clear error is raised
+ * directing the caller to the delegate workflow (DEVX-2774).
+ *
  * @param group - The adapter group containing the adapter, chain, and
  *   burn intents to sign.
  * @returns A signed set with the intents and the ECDSA signature.
@@ -21521,6 +22175,22 @@ function evmSigningData(burnIntent) {
 async function signEvmIntentGroup(group) {
     const { adapter, intents: groupIntents, chain, address } = group;
     const operationContext = address === undefined ? { chain } : { chain, address };
+    // Gateway verifies burn-intent signatures with plain ecrecover. An SCA
+    // signer silently produces a signature over a wrapped hash that Gateway
+    // cannot verify, and Circle Wallets' KMS rejects the typed data up front
+    // with an opaque `<nil>/<nil>` error. Short-circuit with a clear message
+    // when we can detect bytecode at the signer address. See DEVX-2774.
+    //
+    // Duck-typed on readBytecode rather than `instanceof EvmAdapter` because
+    // each consumer package bundles its own copy of the base class and the
+    // `instanceof` identity check fails across package boundaries.
+    //
+    // Empty string is defended against because assertSignerIsEoa would
+    // otherwise call eth_getCode('') on the RPC.
+    const hasResolvedSigner = typeof address === 'string' && address.length > 0;
+    if (hasResolvedSigner && chain.type === 'evm' && isEvmAdapterLike(adapter)) {
+        await assertSignerIsEoa(adapter, address, chain);
+    }
     const firstIntent = groupIntents[0];
     const typedData = groupIntents.length === 1 && firstIntent
         ? evmSigningData(firstIntent)
@@ -21790,9 +22460,10 @@ function getSolanaFeeRecipient() {
     return CIRCLE_FEE_RECIPIENT_SOLANA;
 }
 
-Buffer.from('gateway_minter');
-Buffer.from('gateway_minter_custody');
-Buffer.from('used_transfer_spec_hash');
+const enc = new TextEncoder();
+enc.encode('gateway_minter');
+enc.encode('gateway_minter_custody');
+enc.encode('used_transfer_spec_hash');
 
 async function executeAndWait$1(adapter, request, chain) {
     if (request.type === 'noop') {
@@ -28075,6 +28746,18 @@ function createSwapKitContext(config = {}) {
     return context;
 }
 
+/**
+ * Telemetry event type identifiers for swap-kit operations.
+ *
+ * @internal
+ */
+const SWAP_EVENT_TYPES = {
+    SWAP: 'swap_swap',
+    ESTIMATE: 'swap_estimate',
+};
+
+/** SDK name used in telemetry payloads. */
+const SDK_NAME$1 = resolveKitSdkName(pkg$1.name);
 /**
  * A high-level class-based interface for single-chain token swap operations.
  *
@@ -28146,6 +28829,10 @@ function createSwapKitContext(config = {}) {
  */
 class SwapKit {
     context;
+    /** Whether error telemetry is disabled. */
+    disableErrorReporting;
+    /** Per-kit telemetry identity for shared helpers. */
+    telemetryConfig;
     /**
      * Create a new SwapKit instance.
      *
@@ -28194,6 +28881,12 @@ class SwapKit {
      */
     constructor(config = {}) {
         this.context = createSwapKitContext(config);
+        this.disableErrorReporting = config.disableErrorReporting === true;
+        this.telemetryConfig = {
+            sdkName: SDK_NAME$1,
+            sdkVersion: pkg$1.version,
+            disabled: this.disableErrorReporting,
+        };
     }
     /**
      * Estimate the output amount and fees for a swap operation.
@@ -28235,7 +28928,11 @@ class SwapKit {
      * ```
      */
     async estimate(params) {
-        return estimate(this.context, params);
+        return withErrorTelemetry(async () => estimate(this.context, params), SWAP_EVENT_TYPES.ESTIMATE, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from.chain),
+            tokenIn: params.tokenIn,
+            tokenOut: params.tokenOut,
+        });
     }
     /**
      * Execute a token swap operation on a single chain.
@@ -28291,7 +28988,11 @@ class SwapKit {
      * ```
      */
     async swap(params) {
-        return swap$1(this.context, params);
+        return withErrorTelemetry(async () => swap$1(this.context, params), SWAP_EVENT_TYPES.SWAP, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from.chain),
+            tokenIn: params.tokenIn,
+            tokenOut: params.tokenOut,
+        });
     }
     /**
      * Get all chains supported by the configured swap providers.
@@ -28484,7 +29185,11 @@ const createSwapKit = (context) => {
     const getFee = context.getFee?.bind(context);
     const getFeeRecipient = context.getFeeRecipient?.bind(context);
     const hasBoth = typeof getFee === 'function' && typeof getFeeRecipient === 'function';
-    const kit = new SwapKit();
+    const kit = new SwapKit({
+        ...(context.disableErrorReporting != null && {
+            disableErrorReporting: context.disableErrorReporting,
+        }),
+    });
     if (hasBoth) {
         kit.setCustomFeePolicy({
             computeFee: async (params) => {
@@ -29433,121 +30138,11 @@ const getSupportedChains$2 = (context, operationType, unifiedBalance) => {
 };
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.0.2";
+var version = "1.1.1";
 var pkg = {
 	name: name,
 	version: version};
 
-/**
- * Default telemetry endpoint.
- *
- * Override via the `STABLECOIN_KITS_TELEMETRY_URL` environment variable
- * (e.g. for staging or local development).
- *
- * @internal
- */
-const DEFAULT_LOGS_URL = 'https://api.circle.com/v1/stablecoinKits/logs';
-/**
- * Resolve the telemetry endpoint URL.
- *
- * @internal
- */
-function getLogsUrl() {
-    if (isNodeEnvironment() &&
-        typeof process.env['STABLECOIN_KITS_TELEMETRY_URL'] === 'string' &&
-        process.env['STABLECOIN_KITS_TELEMETRY_URL'].length > 0) {
-        return process.env['STABLECOIN_KITS_TELEMETRY_URL'];
-    }
-    return DEFAULT_LOGS_URL;
-}
-/**
- * Send a telemetry event to the proxy service.
- *
- * @remarks
- * Fire-and-forget: the returned promise is intentionally not awaited
- * by the caller. A fetch failure (network error, non-2xx, timeout)
- * is silently swallowed so telemetry never blocks or fails user
- * operations.
- *
- * @param payload - The structured log payload matching the server schema.
- *
- * @example
- * ```typescript
- * import { emitAnalyticsLog } from './emitLog'
- *
- * // Fire-and-forget — do not await
- * emitAnalyticsLog(payload).catch(() => {})
- * ```
- *
- * @internal
- */
-async function emitAnalyticsLog(payload) {
-    try {
-        const isNode = isNodeEnvironment();
-        const userAgent = getUserAgent();
-        await fetch(getLogsUrl(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                // Browser restricts setting User-Agent; use X-User-Agent instead.
-                ...(isNode
-                    ? { 'User-Agent': userAgent }
-                    : { 'X-User-Agent': userAgent }),
-            },
-            body: JSON.stringify(payload),
-            signal: AbortSignal.timeout(5_000),
-        });
-    }
-    catch {
-        // Silently swallow — telemetry must never break user operations.
-    }
-}
-
-/**
- * Build the `clientContext` object for telemetry payloads.
- *
- * @remarks
- * Uses the exported `getRuntime()` and `isNodeEnvironment()` from
- * `@core/utils` to detect the runtime environment (per Dominik's
- * feedback to reuse existing infrastructure). The returned string
- * is parsed into the structured `ClientContext` fields expected by
- * the server schema.
- *
- * @returns A {@link ClientContext} with platform, OS, and runtime name
- *   populated from the current environment.
- *
- * @example
- * ```typescript
- * import { buildClientContext } from './clientContext'
- *
- * const ctx = buildClientContext()
- * // Node: { platform: 'node', os: 'darwin', runtimeName: null }
- * // Browser: { platform: 'browser', os: null, runtimeName: 'chrome' }
- * ```
- */
-function buildClientContext() {
-    const runtime = getRuntime();
-    if (runtime.startsWith('browser/')) {
-        return {
-            platform: 'browser',
-            os: null,
-            runtimeName: runtime.slice('browser/'.length).toLowerCase(),
-        };
-    }
-    if (runtime.startsWith('node/')) {
-        return {
-            platform: 'node',
-            os: isNodeEnvironment() ? process.platform : null,
-            runtimeName: null,
-        };
-    }
-    return {
-        platform: 'node',
-        os: null,
-        runtimeName: null,
-    };
-}
-
 /**
  * Event type identifiers accepted by the server-side logs endpoint.
  *
@@ -29560,6 +30155,11 @@ const EVENT_TYPES = {
     DEPOSIT_FOR: 'unified_balance_deposit_for',
     SPEND: 'unified_balance_spend',
     SPEND_FORWARDER: 'unified_balance_spend_forwarder',
+    ESTIMATE_SPEND: 'unified_balance_estimate_spend',
+    GET_BALANCES: 'unified_balance_get_balances',
+    ADD_DELEGATE: 'unified_balance_add_delegate',
+    REMOVE_DELEGATE: 'unified_balance_remove_delegate',
+    GET_DELEGATE_STATUS: 'unified_balance_get_delegate_status',
     INITIATE_REMOVE_FUND: 'unified_balance_initiate_remove_fund',
     REMOVE_FUND: 'unified_balance_remove_fund',
 };
@@ -29597,33 +30197,29 @@ function extractSingleChainResult(data) {
         txHash: data.txHash,
     };
 }
-/**
- * Resolve a chain identifier that may be a string or a
- * `ChainDefinition` object to a plain string.
- *
- * @internal
- */
-function resolveChainString(chain) {
-    if (typeof chain === 'string')
-        return chain;
-    return chain.chain;
-}
 /**
  * Extract log-relevant fields from a spend result.
  *
+ * @remarks
+ * Collects all source chains from allocations and joins them with
+ * commas so multi-chain spends are fully represented.
+ *
  * @internal
  */
 function extractSpend(data) {
-    const rawChain = data.allocations?.[0]?.chain;
-    let firstSourceChain;
-    if (rawChain != null) {
-        firstSourceChain = resolveChainString(rawChain);
+    const allocs = data.allocations ?? [];
+    const chains = [];
+    for (const alloc of allocs) {
+        const name = resolveChainName(alloc.chain);
+        if (name != null) {
+            chains.push(name);
+        }
     }
-    const hasAllocations = data.allocations?.[0] != null;
+    const sourceChain = chains.length > 0 ? chains.join(',') : undefined;
     return {
-        ...(firstSourceChain != null && { sourceChain: firstSourceChain }),
+        ...(sourceChain != null && { sourceChain }),
         destinationChain: data.destinationChain,
-        ...(hasAllocations && { tokenIn: 'USDC' }),
+        ...(allocs.length > 0 && { tokenIn: 'USDC' }),
         txHash: data.txHash,
     };
 }
@@ -29722,10 +30318,9 @@ function mapSucceededEventToLog(actionName, payload, sdkName, sdkVersion) {
  * telemetry for successful verb operations.
  *
  * @remarks
- * Follows Dominik's feedback to reuse the existing event bus as the
- * SDK-side hook for telemetry. Registers a handler for each verb's
- * `.succeeded` event. Non-verb and non-succeeded events are not
- * subscribed to.
+ * Registers a handler for each verb's `.succeeded` event using the
+ * shared `registerTelemetryHandler` from `@core/utils`. Non-verb and
+ * non-succeeded events are not subscribed to.
  *
  * The HTTP POST is fire-and-forget — telemetry never blocks or fails
  * user operations.
@@ -29745,20 +30340,7 @@ function mapSucceededEventToLog(actionName, payload, sdkName, sdkVersion) {
  * @internal
  */
 function registerTelemetryHandler(dispatcher, sdkName, sdkVersion) {
-    for (const actionName of Object.keys(VERB_EVENT_MAP)) {
-        dispatcher.on(actionName, (payload) => {
-            try {
-                const log = mapSucceededEventToLog(actionName, payload, sdkName, sdkVersion);
-                if (log) {
-                    // Fire-and-forget — intentionally not awaited.
-                    void emitAnalyticsLog(log);
-                }
-            }
-            catch {
-                // Silently swallow — telemetry must never break user operations.
-            }
-        });
-    }
+    registerTelemetryHandler$1(dispatcher, sdkName, sdkVersion, VERB_EVENT_MAP, mapSucceededEventToLog);
 }
 
 /**
@@ -32861,13 +33443,20 @@ async function resolveAllocationsAndIntents(params, destChain, recipientAddress,
         const sourcesArray = rawSources.filter((s) => s != null);
         const networkType = destChain.isTestnet ? 'testnet' : 'mainnet';
         const balanceResults = await Promise.all(sourcesArray.map(async (source) => {
-            const querySource = {
-                adapter: source.adapter,
-            };
-            if (source.sourceAccount)
-                querySource['account'] = source.sourceAccount;
-            if ('address' in source && source.address) {
-                querySource['address'] = source.address;
+            // When sourceAccount is set (delegate flow), scope the balance
+            // query to the Gateway depositor — not the signer. Using the
+            // address-only path bypasses adapter address resolution, which
+            // would otherwise return the signer's balance (developer-
+            // controlled) or reject an explicit address (user-controlled).
+            let querySource;
+            if (source.sourceAccount) {
+                querySource = { address: source.sourceAccount };
+            }
+            else {
+                querySource = { adapter: source.adapter };
+                if ('address' in source && source.address) {
+                    querySource['address'] = source.address;
+                }
             }
             return getBalances$1({
                 token: params.token,
@@ -35788,6 +36377,8 @@ function getSupportedChains(context, token, options) {
     return Object.values(Object.fromEntries(filtered.map((chain) => [chain.chain, chain])));
 }
 
+/** SDK name used in telemetry payloads. */
+const SDK_NAME = resolveKitSdkName(pkg.name);
 /**
  * A high-level class-based interface for cross-chain USDC deposits,
  * spending, balance queries, delegation management, and withdrawals.
@@ -35835,6 +36426,10 @@ class UnifiedBalanceKit {
      * The action dispatcher for the kit.
      */
     actionDispatcher;
+    /** Whether error telemetry is disabled. */
+    disableErrorReporting;
+    /** Per-kit telemetry identity for shared helpers. */
+    telemetryConfig;
     /**
      * Create a new UnifiedBalanceKit instance.
      *
@@ -35847,14 +36442,49 @@ class UnifiedBalanceKit {
     constructor(config = {}) {
         this.context = createUnifiedBalanceKitContext(config);
         this.actionDispatcher = new Actionable();
+        this.disableErrorReporting = config.disableErrorReporting === true;
+        this.telemetryConfig = {
+            sdkName: SDK_NAME,
+            sdkVersion: pkg.version,
+            disabled: this.disableErrorReporting,
+        };
         for (const provider of this.context.providers) {
             provider.registerDispatcher(this.actionDispatcher);
         }
         if (!config.disableAnalytics) {
-            const sdkName = pkg.name.replace('@circle-fin/', '');
-            registerTelemetryHandler(this.actionDispatcher, sdkName, pkg.version);
+            registerTelemetryHandler(this.actionDispatcher, SDK_NAME, pkg.version);
         }
     }
+    /**
+     * Extract comma-separated source chain names from spend params.
+     *
+     * @internal
+     */
+    static extractSpendSourceChains(params) {
+        if (params == null || typeof params !== 'object' || !('from' in params)) {
+            return undefined;
+        }
+        const fromVal = params.from;
+        const sources = Array.isArray(fromVal) ? fromVal : [fromVal];
+        const chains = [];
+        for (const src of sources) {
+            const allocs = src?.allocations;
+            let allocArr;
+            if (allocs == null) {
+                allocArr = [];
+            }
+            else {
+                allocArr = Array.isArray(allocs) ? allocs : [allocs];
+            }
+            for (const alloc of allocArr) {
+                const name = resolveChainName(alloc.chain);
+                if (name != null) {
+                    chains.push(name);
+                }
+            }
+        }
+        return chains.length > 0 ? chains.join(',') : undefined;
+    }
     // implementation just forwards to the bus
     on(actionOrWildcard, handler) {
         this.actionDispatcher.on(actionOrWildcard, handler);
@@ -35877,7 +36507,10 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.depositFor to deposit into another account.
      */
     async deposit(params) {
-        return deposit(this.context, params);
+        return withErrorTelemetry(async () => deposit(this.context, params), EVENT_TYPES.DEPOSIT, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from?.chain),
+            tokenIn: params.token ?? 'USDC',
+        });
     }
     /**
      * Deposit USDC into another account (not the caller's).
@@ -35889,7 +36522,10 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.deposit to deposit into your own account.
      */
     async depositFor(params) {
-        return depositFor(this.context, params);
+        return withErrorTelemetry(async () => depositFor(this.context, params), EVENT_TYPES.DEPOSIT_FOR, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from?.chain),
+            tokenIn: params.token ?? 'USDC',
+        });
     }
     /**
      * Spend (mint) USDC on a destination chain by pulling funds from one
@@ -35902,7 +36538,17 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.estimateSpend to preview fees before spending.
      */
     async spend(params) {
-        return spend(this.context, params);
+        const destChain = 'to' in params
+            ? resolveChainName(params.to.chain)
+            : undefined;
+        const tokenIn = 'token' in params
+            ? (params.token ?? 'USDC')
+            : 'USDC';
+        return withErrorTelemetry(async () => spend(this.context, params), EVENT_TYPES.SPEND, this.telemetryConfig, {
+            sourceChain: UnifiedBalanceKit.extractSpendSourceChains(params),
+            ...(destChain != null && { destinationChain: destChain }),
+            tokenIn,
+        });
     }
     /**
      * Estimate the fees for a spend operation without executing it.
@@ -35912,7 +36558,17 @@ class UnifiedBalanceKit {
      * @returns Promise resolving to the fee estimate.
      */
     async estimateSpend(params) {
-        return estimateSpend(this.context, params);
+        const destChain = 'to' in params
+            ? resolveChainName(params.to.chain)
+            : undefined;
+        const sourceChain = UnifiedBalanceKit.extractSpendSourceChains(params);
+        return withErrorTelemetry(async () => estimateSpend(this.context, params), EVENT_TYPES.ESTIMATE_SPEND, this.telemetryConfig, {
+            ...(sourceChain != null && { sourceChain }),
+            ...(destChain != null && { destinationChain: destChain }),
+            tokenIn: 'token' in params
+                ? (params.token ?? 'USDC')
+                : 'USDC',
+        });
     }
     /**
      * Fetch aggregated and per-chain balances for one or more accounts.
@@ -35921,7 +36577,7 @@ class UnifiedBalanceKit {
      * @returns Promise resolving to the aggregated balance result.
      */
     async getBalances(params) {
-        return getBalances(this.context, params);
+        return withErrorTelemetry(async () => getBalances(this.context, params), EVENT_TYPES.GET_BALANCES, this.telemetryConfig);
     }
     /**
      * Grant spending rights to another address on the owner's account.
@@ -35936,7 +36592,7 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.getDelegateStatus to check delegate status.
      */
     async addDelegate(params) {
-        return addDelegate(this.context, params);
+        return withErrorTelemetry(async () => addDelegate(this.context, params), EVENT_TYPES.ADD_DELEGATE, this.telemetryConfig, { sourceChain: resolveChainName(params.from?.chain) });
     }
     /**
      * Revoke spending rights from a delegate on the owner's account.
@@ -35951,7 +36607,7 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.getDelegateStatus to check delegate status.
      */
     async removeDelegate(params) {
-        return removeDelegate(this.context, params);
+        return withErrorTelemetry(async () => removeDelegate(this.context, params), EVENT_TYPES.REMOVE_DELEGATE, this.telemetryConfig, { sourceChain: resolveChainName(params.from?.chain) });
     }
     /**
      * Kick off a delayed fund removal from an account.
@@ -35963,7 +36619,10 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.removeFund to complete the fund removal.
      */
     async initiateRemoveFund(params) {
-        return initiateRemoveFund(this.context, params);
+        return withErrorTelemetry(async () => initiateRemoveFund(this.context, params), EVENT_TYPES.INITIATE_REMOVE_FUND, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from?.chain),
+            tokenIn: params.token ?? 'USDC',
+        });
     }
     /**
      * Complete a fund removal once the activation period has passed.
@@ -35975,7 +36634,10 @@ class UnifiedBalanceKit {
      * @see UnifiedBalanceKit.initiateRemoveFund to start the process.
      */
     async removeFund(params) {
-        return removeFund(this.context, params);
+        return withErrorTelemetry(async () => removeFund(this.context, params), EVENT_TYPES.REMOVE_FUND, this.telemetryConfig, {
+            sourceChain: resolveChainName(params.from?.chain),
+            tokenIn: params.token ?? 'USDC',
+        });
     }
     /**
      * Check the finality-aware delegate status of an address.
@@ -36003,7 +36665,7 @@ class UnifiedBalanceKit {
      * ```
      */
     async getDelegateStatus(params) {
-        return getDelegateStatus(this.context, params);
+        return withErrorTelemetry(async () => getDelegateStatus(this.context, params), EVENT_TYPES.GET_DELEGATE_STATUS, this.telemetryConfig, { sourceChain: resolveChainName(params.from?.chain) });
     }
     /**
      * Get all chains supported by the kit.
@@ -36493,8 +37155,18 @@ class AppKit {
      * ```
      */
     constructor(config = {}) {
-        this.context = createContext(config);
-        this.unifiedBalance = new AppKitUnifiedBalance(config.unifiedBalance);
+        this.context = createContext({
+            ...config,
+            ...(config.disableErrorReporting != null && {
+                disableErrorReporting: config.disableErrorReporting,
+            }),
+        });
+        this.unifiedBalance = new AppKitUnifiedBalance({
+            ...config.unifiedBalance,
+            ...(config.disableErrorReporting != null && {
+                disableErrorReporting: config.disableErrorReporting,
+            }),
+        });
     }
     /**
      * Execute a cross-chain USDC bridge transfer.