@circle-fin/app-kit 1.17.0 → 1.18.0

package/estimateBridge.cjs

@@ -4543,14 +4543,14 @@ var BorrowChain;
         symbol: 'USDC',
         // Arc uses native USDC with 18 decimals for gas payments (EVM standard).
         // Note: The ERC-20 USDC contract at usdcAddress uses 6 decimals.
-        // See: https://docs.arc.network/arc/references/contract-addresses
+        // See: https://docs.arc.io/arc/references/contract-addresses
         decimals: 18
     },
     chainId: 5042002,
     isTestnet: true,
     explorerUrl: 'https://testnet.arcscan.app/tx/{hash}',
     rpcEndpoints: [
-        'https://rpc.testnet.arc.network/'
+        'https://rpc.testnet.arc.io'
     ],
     eurcAddress: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
     usdcAddress: '0x3600000000000000000000000000000000000000',
@@ -12187,6 +12187,39 @@ function resolveOptions(options) {
         }
     };
 }
+/**
+ * Emit telemetry for a completed operation without affecting its caller.
+ *
+ * No-ops when `config.disabled` is `true`. Like {@link withErrorTelemetry},
+ * failures while constructing or submitting the telemetry payload are reported
+ * as a soft warning and never change a completed operation's result.
+ *
+ * @param eventType - The telemetry event type for the completed operation.
+ * @param config - Per-kit SDK identity and disabled flag.
+ * @param context - Optional chain, token, and transaction context.
+ * @returns Nothing.
+ * @throws Never — telemetry failures are reported as warnings.
+ *
+ * @example
+ * ```typescript
+ * import { emitSuccessTelemetry } from '@core/utils'
+ *
+ * emitSuccessTelemetry(
+ *   'bridge_bridge',
+ *   { sdkName: 'bridge-kit', sdkVersion: '1.0.0', disabled: false },
+ *   { sourceChain: 'Ethereum', destinationChain: 'Base', tokenIn: 'USDC' },
+ * )
+ * ```
+ */ function emitSuccessTelemetry(eventType, config, context) {
+    if (config.disabled) {
+        return;
+    }
+    try {
+        void emitAnalyticsLog(buildPayload(config, eventType, undefined, context));
+    } catch (telemetryError) {
+        warnTelemetryDrop(eventType, telemetryError);
+    }
+}
 /**
  * Wrap an async operation with error telemetry.
  *
@@ -12297,7 +12330,7 @@ function resolveOptions(options) {
 }
 
 var name$3 = "@circle-fin/bridge-kit";
-var version$4 = "1.15.3";
+var version$4 = "1.16.0";
 var pkg$4 = {
 	name: name$3,
 	version: version$4};
@@ -13558,6 +13591,53 @@ const EURC_MAINNET_TOKEN_ID = '0x6ca9e29fa53becc29becaf4a90b9ca7a995ad4d2234880d
     }
 };
 
+/**
+ * Map a CCTPx bytes32 token id back to its known display symbol.
+ *
+ * The inverse of the provider's internal symbol -> id resolution: a bridge
+ * resolves a symbol such as `'cirBTC'` to its canonical bytes32 id and reports
+ * that id on `result.token`, dropping the symbol. This helper recovers the
+ * symbol for display. It is scoped to {@link KNOWN_TOKEN_SYMBOLS} — the same
+ * known set the forward resolution covers — and is keyed by network, because a
+ * symbol names a separate registration on each network, whose ids are
+ * unrelated.
+ *
+ * The lookup is best-effort by design: an arbitrary registry token, a
+ * non-canonical bridge of a known symbol, or any unrecognized id has no known
+ * symbol and yields `undefined`. The id is matched case-insensitively (bytes32
+ * ids have no checksum casing).
+ *
+ * @param id - The bytes32 token id to decode (e.g. a `result.token` value).
+ * @param network - The network the id belongs to (`'testnet'` or `'mainnet'`);
+ *   derive it from the source chain, e.g. `chain.isTestnet ? 'testnet' :
+ *   'mainnet'`.
+ * @returns The matching {@link KnownTokenSymbol}, or `undefined` when `id` is
+ *   not one of the known canonical ids for `network`.
+ * @throws A `KitError` (`INPUT_VALIDATION_FAILED`, FATAL) when `id` is not a
+ *   string or `network` is not a recognized network.
+ *
+ * @example
+ * ```typescript
+ * import { resolveToKnownTokenSymbol } from '@circle-fin/provider-cctpx'
+ *
+ * const result = await provider.bridge(params) // params.token === 'cirBTC'
+ * const network = result.source.chain.isTestnet ? 'testnet' : 'mainnet'
+ *
+ * resolveToKnownTokenSymbol(result.token, network) // 'cirBTC'
+ * resolveToKnownTokenSymbol('0xdeadbeef…', network) // undefined (not known)
+ * ```
+ */ function resolveToKnownTokenSymbol(id, network) {
+    if (typeof id !== 'string') {
+        throw createValidationFailedError$1('id', id, 'must be a string');
+    }
+    if (network !== 'testnet' && network !== 'mainnet') {
+        throw createValidationFailedError$1('network', network, "must be 'testnet' or 'mainnet'");
+    }
+    const row = KNOWN_TOKEN_IDS_BY_NETWORK[network];
+    const target = id.toLowerCase();
+    return KNOWN_TOKEN_SYMBOLS.find((symbol)=>row[symbol].toLowerCase() === target);
+}
+
 /**
  * Default clock implementation.
  *
@@ -20742,6 +20822,24 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
     }
 };
 
+/**
+ * Check whether a forwarded burn to the given destination asks Circle's
+ * Forwarding Service to set up the recipient's token account before minting.
+ *
+ * Must return `true` exactly for the destinations where
+ * {@link getForwarderHookData} emits the `createAta` frame, so the forwarding
+ * fee quote includes the setup rent whenever the burn requests it.
+ *
+ * @internal
+ * @param chainType - The destination blockchain type.
+ * @returns `true` for Solana destinations, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * requiresRecipientSetup('solana') // true
+ * requiresRecipientSetup('evm') // false
+ * ```
+ */ const requiresRecipientSetup = (chainType)=>chainType === 'solana';
 /**
  * Build the forwarding `hookData` for a forwarded (Orbit-relayed) CCTP v2 burn,
  * tailored to the destination chain.
@@ -21092,10 +21190,12 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  * @param sourceDomain - The source domain
  * @param destinationDomain - The destination domain
  * @param isTestnet - Whether the request is for a testnet chain
+ * @param includeRecipientSetup - Whether the quote includes recipient account setup rent
  * @returns The complete API URL with forward=true query parameter
- */ function buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet) {
+ */ function buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet, includeRecipientSetup) {
     const baseUrl = isTestnet ? IRIS_API_SANDBOX_BASE_URL$1 : IRIS_API_BASE_URL$1;
-    return `${baseUrl}/v2/burn/USDC/fees/${sourceDomain.toString()}/${destinationDomain.toString()}?forward=true`;
+    const recipientSetupQuery = includeRecipientSetup ? '&includeRecipientSetup=true' : '';
+    return `${baseUrl}/v2/burn/USDC/fees/${sourceDomain.toString()}/${destinationDomain.toString()}?forward=true${recipientSetupQuery}`;
 }
 /**
  * Fetches the forwarding fee for a USDC transfer operation with retry and timeout handling.
@@ -21112,6 +21212,10 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  *
  * The high fee tier is always used to provide buffer for destination gas fluctuations.
  *
+ * Pass `includeRecipientSetup: true` when the burn asks the Forwarding Service to create
+ * the recipient's token account (Solana destinations). The quote then includes the
+ * account rent, which the quote without this flag leaves out.
+ *
  * Implements timeout and retry logic to handle network issues and temporary API failures.
  * Each HTTP request is given a maximum of 2 seconds before it is aborted.
  * We retry up to 10 times, waiting 200ms between attempts.
@@ -21120,6 +21224,8 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  * @param destinationDomain - The destination domain
  * @param isTestnet - Whether the request is for a testnet chain
  * @param finalityThreshold - The finality threshold to select the fee tier (1000 for FAST, 2000 for SLOW)
+ * @param includeRecipientSetup - Whether to include recipient account setup rent in the
+ *   quote. Defaults to `false`.
  * @returns The high-tier forwarding fee in USDC minor units (6 decimals)
  * @throws Error if the input domains are invalid, the API request fails, returns invalid data, or network errors occur
  *
@@ -21131,8 +21237,11 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  *
  * // SLOW transfer - use 2000ms finality threshold
  * const slowForwardingFee = await fetchForwardingFee(0, 6, false, 2000)
+ *
+ * // Ethereum -> Solana: include the recipient token account rent
+ * const solanaForwardingFee = await fetchForwardingFee(0, 5, false, 1000, true)
  * ```
- */ async function fetchForwardingFee(sourceDomain, destinationDomain, isTestnet, finalityThreshold) {
+ */ async function fetchForwardingFee(sourceDomain, destinationDomain, isTestnet, finalityThreshold, includeRecipientSetup = false) {
     // Validate source domain
     if (!Number.isInteger(sourceDomain) || sourceDomain < 0) {
         throw new KitError({
@@ -21160,7 +21269,7 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
         });
     }
     // Fetch the fee tiers from the API with forward=true
-    const url = buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet);
+    const url = buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet, includeRecipientSetup);
     const response = await pollApiGet(url, isForwardingFeeResponse, DEFAULT_CONFIG$1);
     // Validate that we have at least one fee tier
     if (response.length === 0) {
@@ -23496,7 +23605,7 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$3 = "1.14.2";
+var version$3 = "1.14.3";
 var pkg$3 = {
 	version: version$3};
 
@@ -24415,9 +24524,34 @@ function assertCCTPV2Config(config) {
             tokenAddress: source.chain.usdcAddress,
             operationContext: sourceOperationContext
         });
+        await this.assertAmountCoversRecipientSetupFee(params);
         return bridge(params, this);
     }
     /**
+   * Reject a forwarded transfer to Solana whose amount does not exceed the fee.
+   *
+   * CCTP v2 reverts a burn whose `maxFee` is not less than its amount, and the Solana
+   * forwarding fee includes the recipient token account rent. Checking before the
+   * approval avoids sending a transaction that can never be followed by a burn.
+   * Skipped when the caller provides `config.maxFee`.
+   *
+   * @param params - The validated CCTP v2 bridge parameters.
+   * @returns A promise that resolves when the amount covers the fee.
+   * @throws {KitError} INPUT_INVALID_AMOUNT (FATAL) when the fee is greater than or equal
+   *   to the amount.
+   */ async assertAmountCoversRecipientSetupFee(params) {
+        const { destination, amount, config } = params;
+        if (destination.useForwarder !== true || config.maxFee !== undefined || !requiresRecipientSetup(destination.chain.type)) {
+            return;
+        }
+        const { providerFee, forwarderFee } = await this.getMaxFee(params);
+        const maxFee = providerFee + forwarderFee;
+        if (maxFee >= BigInt(amount)) {
+            // Amounts and fees are in USDC minor units (6 decimals)
+            throw createInvalidAmountError(formatUnits(amount, 6), `Amount must be greater than the ${formatUnits(String(maxFee), 6)} USDC fee for forwarded transfers to ${destination.chain.name}, which includes creating the recipient's token account`);
+        }
+    }
+    /**
    * Retry a failed or incomplete CCTP v2 bridge operation.
    *
    * Analyzes the bridge result to determine where to continue and executes
@@ -25134,6 +25268,9 @@ function assertCCTPV2Config(config) {
    * | FAST           | true         | No              | maxFee = calculatedBurnFee + forwardingFee |
    * | FAST           | true         | Yes             | maxFee = config.maxFee |
    *
+   * For forwarded burns to Solana, the forwarding fee includes the rent for creating the
+   * recipient's token account. A caller-provided `maxFee` must cover it too.
+   *
    * @param params - The bridge parameters object containing:
    *   - `source`: The source wallet context with chain definition and adapter
    *   - `destination`: The destination wallet context with chain definition and adapter
@@ -25172,6 +25309,7 @@ function assertCCTPV2Config(config) {
         }
         // Get the min finality threshold based on the transfer speed
         const minFinalityThreshold = CCTPv2MinFinalityThreshold[transferSpeed];
+        const includeRecipientSetup = requiresRecipientSetup(destination.chain.type);
         // SLOW transfer without forwarder: no fee
         if (transferSpeed === TransferSpeed.SLOW && !useForwarder) {
             return {
@@ -25181,7 +25319,7 @@ function assertCCTPV2Config(config) {
         }
         // SLOW transfer with forwarder: only forwarding fee
         if (transferSpeed === TransferSpeed.SLOW && useForwarder) {
-            const forwarderFee = await fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold);
+            const forwarderFee = await fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold, includeRecipientSetup);
             return {
                 providerFee: 0n,
                 forwarderFee
@@ -25191,7 +25329,7 @@ function assertCCTPV2Config(config) {
         // Fetch fees in parallel when forwarder is enabled
         const [scaledBps, forwarderFee] = await Promise.all([
             fetchUsdcFastBurnFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet),
-            useForwarder ? fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold) : Promise.resolve(0n)
+            useForwarder ? fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold, includeRecipientSetup) : Promise.resolve(0n)
         ]);
         // Calculate fee proportional to the transfer amount
         const amountInMinorUnits = BigInt(amount);
@@ -25741,6 +25879,21 @@ function assertCCTPV2Config(config) {
         'bridge_forward'
     ]
 ];
+/**
+ * Provider step names whose `txHash` is the source-chain transaction that
+ * moves funds into the bridge protocol.
+ *
+ * @remarks
+ * The success event carries this hash so the backend can join it to the
+ * on-chain CCTP / CCTPx event for the same transfer. `burn` is the CCTP v2
+ * step (including batched and source-fee flows); `transfer` is the CCTPx
+ * `CrossChainTokenService` step.
+ *
+ * @internal
+ */ const BRIDGE_SOURCE_TX_STEP_NAMES = [
+    'burn',
+    'transfer'
+];
 
 /**
  * Base URL for Circle's Quote API (hosted in Iris) on mainnet/production.
@@ -26798,6 +26951,85 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
     }
     return undefined;
 }
+/**
+ * Pick the source-chain transaction hash from a bridge result.
+ *
+ * Walk the steps from the end and return the hash of the most recent
+ * successful source step (`burn` for CCTP v2, `transfer` for CCTPx). Walking
+ * backwards selects the attempt that landed when a retry appended a new
+ * source step after a failed one.
+ *
+ * @param steps - All steps from the bridge result.
+ * @returns The source transaction hash, or `undefined` if no source step recorded one.
+ *
+ * @internal
+ */ function pickSourceTxHash(steps) {
+    for(let i = steps.length - 1; i >= 0; i--){
+        const step = steps[i];
+        if (step?.txHash != null && step.state === 'success' && BRIDGE_SOURCE_TX_STEP_NAMES.includes(step.name)) {
+            return step.txHash;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the token value reported in telemetry.
+ *
+ * CCTPx reports `result.token` as a bytes32 token id, while the backend's
+ * canonical tables key tokens by symbol. Map the canonical id of a known CCTPx
+ * token back to its symbol and pass any other value (USDC, or a registry token
+ * without a known symbol) through unchanged. Registry symbols are not used
+ * because they are not unique across CCTPx tokens. Never throws.
+ *
+ * @param token - The token from a bridge result.
+ * @param sourceChain - The result's source chain; selects testnet or mainnet ids.
+ * @returns The known symbol, or `token` unchanged.
+ *
+ * @internal
+ */ function toTelemetryToken(token, sourceChain) {
+    try {
+        const network = sourceChain.isTestnet ? 'testnet' : 'mainnet';
+        return resolveToKnownTokenSymbol(token, network) ?? token;
+    } catch  {
+        return token;
+    }
+}
+/**
+ * Emit the `bridge_bridge` success event for a completed transfer.
+ *
+ * No-ops unless `result.state` is `'success'`. Failed results are already
+ * reported by error telemetry. Never throws: a malformed result (for example
+ * from a custom provider) is reported as a telemetry drop warning and the
+ * caller's result is returned unchanged.
+ *
+ * @param result - The human-readable bridge result returned to the caller.
+ * @param config - Analytics telemetry identity, gated by `disableAnalytics`.
+ *
+ * @internal
+ */ function emitBridgeSuccessTelemetry(result, config) {
+    if (config.disabled || result.state !== 'success') {
+        return;
+    }
+    try {
+        const txHash = pickSourceTxHash(result.steps);
+        // `JSON.stringify` turns a non-finite number into `null`, which the logs
+        // endpoint's strict schema rejects along with the whole event.
+        const amountIn = Number.parseFloat(result.amount);
+        emitSuccessTelemetry(BRIDGE_EVENT_TYPES.BRIDGE, config, {
+            sourceChain: result.source.chain.chain,
+            destinationChain: result.destination.chain.chain,
+            tokenIn: toTelemetryToken(result.token, result.source.chain),
+            ...Number.isFinite(amountIn) && {
+                amountIn
+            },
+            ...txHash != null && {
+                txHash
+            }
+        });
+    } catch (telemetryError) {
+        warnTelemetryDrop(BRIDGE_EVENT_TYPES.BRIDGE, telemetryError);
+    }
+}
 /**
  * BridgeKit caller component for retry and estimate operations.
  */ const BRIDGE_KIT_CALLER = {
@@ -26928,6 +27160,10 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
     /** Whether error telemetry is disabled. */ disableErrorReporting;
     /** Per-kit telemetry identity for shared helpers. */ telemetryConfig;
     /**
+   * Per-kit telemetry identity for success events. Gated by `disableAnalytics`
+   * independently of `disableErrorReporting`.
+   */ analyticsTelemetryConfig;
+    /**
    * Create a new BridgeKit instance.
    *
    * @param config - The configuration containing the CCTPv2 provider
@@ -26954,6 +27190,11 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
             sdkVersion: pkg$4.version,
             disabled: this.disableErrorReporting
         };
+        this.analyticsTelemetryConfig = {
+            sdkName: SDK_NAME,
+            sdkVersion: pkg$4.version,
+            disabled: config.disableAnalytics === true
+        };
         for (const provider of this.providers){
             provider.registerDispatcher(this.actionDispatcher);
         }
@@ -26967,7 +27208,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
         this.actionDispatcher.off(actionOrWildCard, handler);
     }
     async bridge(params) {
-        return withErrorTelemetry(async ()=>{
+        const bridgeResult = await withErrorTelemetry(async ()=>{
             // First validate the parameters
             assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
             // Then resolve chain definitions (includes adapter chain support validation)
@@ -27004,7 +27245,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
                 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,
+                    tokenIn: toTelemetryToken(result.token, result.source.chain),
                     ...txHash != null && {
                         txHash
                     }
@@ -27016,6 +27257,8 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
             destinationChain: resolveChainName(params.to.chain),
             tokenIn: params.token
         });
+        emitBridgeSuccessTelemetry(bridgeResult, this.analyticsTelemetryConfig);
+        return bridgeResult;
     }
     /**
    * Retry a failed or incomplete cross-chain USDC bridge operation.
@@ -27086,7 +27329,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
    * )
    * ```
    */ async retry(result, context, invocationMeta) {
-        return withErrorTelemetry(async ()=>{
+        const retriedResult = await withErrorTelemetry(async ()=>{
             // Cast the providers list to the wide view here. The tuple
             // type on `this.providers` retains concrete provider types
             // (CCTPv2 narrows `TToken` to `'USDC'`); calling `.retry`
@@ -27114,7 +27357,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
                 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,
+                    tokenIn: toTelemetryToken(result.token, result.source.chain),
                     ...txHash != null && {
                         txHash
                     }
@@ -27128,8 +27371,16 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
         }, BRIDGE_EVENT_TYPES.RETRY, this.telemetryConfig, {
             sourceChain: result.source.chain.chain,
             destinationChain: result.destination.chain.chain,
-            tokenIn: result.token
+            tokenIn: toTelemetryToken(result.token, result.source.chain)
         });
+        // A retry that completes the transfer is the transfer's only success
+        // event, so it reports the same `bridge_bridge` type as `bridge()`. An
+        // input that already succeeded was reported by the call that completed it
+        // (CCTP v2 returns such a result unchanged), so it is not reported again.
+        if (result.state !== 'success') {
+            emitBridgeSuccessTelemetry(retriedResult, this.analyticsTelemetryConfig);
+        }
+        return retriedResult;
     }
     async estimate(params) {
         return withErrorTelemetry(async ()=>{
@@ -27725,6 +27976,9 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
         ...context.disableErrorReporting != null && {
             disableErrorReporting: context.disableErrorReporting
         },
+        ...context.disableAnalytics != null && {
+            disableAnalytics: context.disableAnalytics
+        },
         ...context.headers != null && {
             headers: context.headers
         }
@@ -27747,7 +28001,7 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
 };
 
 var name$2 = "@circle-fin/swap-kit";
-var version$2 = "1.8.0";
+var version$2 = "1.8.1";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -30019,7 +30273,7 @@ new Set(Object.values(Blockchain));
 registerKit(`${pkg$2.name}/${pkg$2.version}`);
 
 var name$1 = "@circle-fin/earn-kit";
-var version$1 = "1.9.0";
+var version$1 = "1.10.0";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -31459,7 +31713,7 @@ function hasCrossChainDepositQuoteShape(params) {
 registerKit(`${pkg$1.name}/${pkg$1.version}`);
 
 var name = "@circle-fin/borrow-kit";
-var version = "1.1.0";
+var version = "1.1.1";
 var pkg = {
 	name: name,
 	version: version};

package/estimateBridge.d.cts

@@ -8477,11 +8477,11 @@ interface AppKitContext {
      */
     actions: Record<'bridge' | 'earn' | 'borrow', Record<string, ((payload: unknown) => void)[]>>;
     /**
-     * Disable success analytics for the underlying EarnKit, SwapKit,
+     * Disable success analytics for the underlying BridgeKit, EarnKit, SwapKit,
      * BorrowKit, and UnifiedBalanceKit.
      *
-     * When `true`, completed earn, swap, borrow, and unified balance operations
-     * will not POST analytics events. This does not disable error reporting; use
+     * When `true`, completed bridge, earn, swap, borrow, and unified balance
+     * operations will not POST analytics events. This does not disable error reporting; use
      * {@link AppKitContext.disableErrorReporting} for that. Defaults to `false`.
      *
      * @defaultValue false

package/estimateBridge.d.mts

@@ -8477,11 +8477,11 @@ interface AppKitContext {
      */
     actions: Record<'bridge' | 'earn' | 'borrow', Record<string, ((payload: unknown) => void)[]>>;
     /**
-     * Disable success analytics for the underlying EarnKit, SwapKit,
+     * Disable success analytics for the underlying BridgeKit, EarnKit, SwapKit,
      * BorrowKit, and UnifiedBalanceKit.
      *
-     * When `true`, completed earn, swap, borrow, and unified balance operations
-     * will not POST analytics events. This does not disable error reporting; use
+     * When `true`, completed bridge, earn, swap, borrow, and unified balance
+     * operations will not POST analytics events. This does not disable error reporting; use
      * {@link AppKitContext.disableErrorReporting} for that. Defaults to `false`.
      *
      * @defaultValue false

package/estimateBridge.d.ts

@@ -8477,11 +8477,11 @@ interface AppKitContext {
      */
     actions: Record<'bridge' | 'earn' | 'borrow', Record<string, ((payload: unknown) => void)[]>>;
     /**
-     * Disable success analytics for the underlying EarnKit, SwapKit,
+     * Disable success analytics for the underlying BridgeKit, EarnKit, SwapKit,
      * BorrowKit, and UnifiedBalanceKit.
      *
-     * When `true`, completed earn, swap, borrow, and unified balance operations
-     * will not POST analytics events. This does not disable error reporting; use
+     * When `true`, completed bridge, earn, swap, borrow, and unified balance
+     * operations will not POST analytics events. This does not disable error reporting; use
      * {@link AppKitContext.disableErrorReporting} for that. Defaults to `false`.
      *
      * @defaultValue false