@circle-fin/app-kit 1.16.0 → 1.18.0

package/bridge.cjs

@@ -2522,22 +2522,73 @@ let activeRedactor = defaultMessageRedactor;
     '0x9147d463': 'Final balance is less than the initial balance',
     '0xf4b3b1bc': 'Native token transfer to the beneficiary failed'
 };
+/**
+ * Matches revert data: a 4-byte selector followed by whole ABI-encoded bytes.
+ */ const REVERT_DATA_PATTERN = /^0x[0-9a-f]{8}(?:[0-9a-f]{2})*$/i;
+/**
+ * Returns the revert data held by one error in a `cause` chain.
+ *
+ * Browser wallets (EIP-1193) wrap the node's error, so the revert data sits
+ * one level down as `data.data`. viem's `getContractError` reads it the same
+ * way, then keeps it on `ContractFunctionRevertedError.raw` and drops the
+ * node's error from the chain.
+ *
+ * @param link - One error in the `cause` chain
+ * @returns The `raw` or `data` string, or undefined if there is none
+ */ function getRevertData(link) {
+    if ('raw' in link && typeof link.raw === 'string' && REVERT_DATA_PATTERN.test(link.raw)) {
+        return link.raw;
+    }
+    if (!('data' in link)) {
+        return undefined;
+    }
+    const { data } = link;
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (data !== null && typeof data === 'object' && 'data' in data && typeof data.data === 'string') {
+        return data.data;
+    }
+    return undefined;
+}
+/**
+ * Finds the first revert data on the error or in its `cause` chain that
+ * `accept` takes.
+ *
+ * viem keeps the node's revert data on an inner `RpcRequestError`, not on
+ * the error it throws. The `seen` set stops a self-referencing `cause` chain.
+ *
+ * @param error - The error object
+ * @param accept - Returns true for the data shape the caller wants
+ * @returns The data as written on the error, or undefined if not found
+ */ function findRevertData(error, accept) {
+    const seen = new Set();
+    let current = error;
+    while(current !== null && typeof current === 'object' && !seen.has(current)){
+        seen.add(current);
+        const data = getRevertData(current);
+        if (data !== undefined && accept(data)) {
+            return data;
+        }
+        current = 'cause' in current ? current.cause : undefined;
+    }
+    return undefined;
+}
 /**
  * Attempts to extract an error selector from an error object or message.
  *
  * Checks multiple sources in priority order:
- * 1. `error.data` field
+ * 1. `raw` or `data` field (or nested `data.data`) on the error or anywhere
+ *    in its `cause` chain
  * 2. Message pattern: "custom error 0x8baa579f"
  *
  * @param msg - The error message
  * @param error - The error object (optional)
  * @returns The 4 bytes selector , or undefined if not found
  */ function extractErrorSelector(msg, error) {
-    // Check error.data field
-    if (error !== null && typeof error === 'object' && 'data' in error) {
-        if (typeof error.data === 'string' && /^0x[0-9a-f]{8}$/i.test(error.data)) {
-            return error.data.toLowerCase();
-        }
+    const data = findRevertData(error, (value)=>/^0x[0-9a-f]{8}$/i.test(value));
+    if (data !== undefined) {
+        return data.toLowerCase();
     }
     // Check for "custom error 0x8baa579f" in the message
     const match = /custom error (0x[0-9a-f]{8})\b/i.exec(msg);
@@ -3810,6 +3861,8 @@ var SwapChain;
     SwapChain["HyperEVM"] = "HyperEVM";
     SwapChain["Monad"] = "Monad";
     SwapChain["Arc"] = "Arc";
+    SwapChain["Cronos"] = "Cronos";
+    SwapChain["Morph"] = "Morph";
     // Testnet chains with swap support
     SwapChain["Arc_Testnet"] = "Arc_Testnet";
 })(SwapChain || (SwapChain = {}));
@@ -4490,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',
@@ -5142,7 +5195,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -6011,7 +6065,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -8309,8 +8364,8 @@ var Chains = {
  * Zod schema for validating swap-specific chain identifiers.
  *
  * Validates chains based on:
- * - CCTPv2 support (adapter contract deployed)
- * - Mainnet only (no testnets)
+ * - Membership in the SwapChain enum
+ * - Mainnet or explicitly allowlisted testnet
  * - At least one supported token available
  *
  */ const swapChainIdentifierSchema = zod.z.union([
@@ -8789,7 +8844,7 @@ const swapTokenEnumSchema = zod.z.enum([
  *
  * A chain supports swaps if ALL conditions are met:
  * 1. Is a member of the {@link SwapChain} enum
- * 2. Has CCTPv2 support (adapter contract deployed)
+ * 2. Has an Adapter contract configured directly or through CCTP v2
  *
  * Testnets are allowed only when explicitly listed in the
  * {@link SwapChain} enum (e.g., Arc_Testnet).
@@ -8810,14 +8865,14 @@ const swapTokenEnumSchema = zod.z.enum([
  * @remarks
  * Chains automatically become swap-enabled when:
  * - Added to the {@link SwapChain} enum
- * - Adapter contract is deployed (CCTPv2)
+ * - An Adapter contract is deployed and configured
  *
  * No code changes needed when new chains are added!
  */ function isSwapSupportedChain(chain) {
     if (!(chain.chain in SwapChain)) {
         return false;
     }
-    if (!isCCTPV2Supported(chain)) {
+    if (!isCCTPV2Supported(chain) && !hasCustomContractSupport(chain, 'adapter')) {
         return false;
     }
     return true;
@@ -8828,7 +8883,7 @@ const swapTokenEnumSchema = zod.z.enum([
  *
  * Dynamically filter chain definitions to include only those that:
  * - Are members of the {@link SwapChain} enum
- * - Have CCTPv2 support
+ * - Have an Adapter contract configured directly or through CCTP v2
  *
  * This function is pure and accepts chains as parameter to avoid
  * circular dependencies.
@@ -10262,11 +10317,13 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
         [Blockchain.Avalanche]: '0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
         [Blockchain.Celo]: '0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e',
+        [Blockchain.Cronos]: '0x66e428c3f67a68878562e79A0234c1F83c208770',
         [Blockchain.Ethereum]: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
         [Blockchain.HyperEVM]: '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb',
         [Blockchain.Ink]: '0x0200C29006150606B650577BBE7B6248F58470c1',
         [Blockchain.Linea]: '0xA219439258ca9da29E9Cc4cE5596924745e12B93',
         [Blockchain.Monad]: '0xe7cd86e13AC4309349F30B3435a9d337750fC82D',
+        [Blockchain.Morph]: '0xe7cd86e13AC4309349F30B3435a9d337750fC82D',
         [Blockchain.NEAR]: 'usdt.tether-token.near',
         [Blockchain.Optimism]: '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58',
         [Blockchain.Polkadot_Asset_Hub]: '1984',
@@ -10325,6 +10382,7 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
         [Blockchain.Avalanche]: '0xd586E7F844cEa2F87f50152665BCbc2C279D8d70',
         [Blockchain.Base]: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+        [Blockchain.Cronos]: '0xF2001B145b43032AAF5Ee2884e456CCd805F677D',
         [Blockchain.Ethereum]: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
         [Blockchain.Linea]: '0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5',
         [Blockchain.Optimism]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
@@ -10387,7 +10445,9 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
         [Blockchain.Avalanche]: '0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB',
         [Blockchain.Base]: '0x4200000000000000000000000000000000000006',
+        [Blockchain.Cronos]: '0xe44Fd7fCb2b1581822D0c862B68222998a0c299a',
         [Blockchain.Ethereum]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+        [Blockchain.Morph]: '0x5300000000000000000000000000000000000011',
         [Blockchain.Optimism]: '0x4200000000000000000000000000000000000006',
         [Blockchain.Polygon]: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
         [Blockchain.Solana]: '7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs'
@@ -10406,6 +10466,7 @@ function parseOrThrow(value, schema, context) {
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -12126,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.
  *
@@ -12236,7 +12330,7 @@ function resolveOptions(options) {
 }
 
 var name$3 = "@circle-fin/bridge-kit";
-var version$4 = "1.15.2";
+var version$4 = "1.16.0";
 var pkg$4 = {
 	name: name$3,
 	version: version$4};
@@ -13497,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.
  *
@@ -14801,7 +14942,11 @@ function createNoopLogger() {
     tokenId: bytes32Hex,
     domainId: nonNegativeInteger,
     tokenAddress: zod.z.string(),
-    tokenManagerAddress: zod.z.string()
+    tokenManagerAddress: zod.z.string(),
+    // Operator-controlled per-chain kill switch (CCTPE-3979). Optional for
+    // back-compat with older IRIS versions that do not surface it. Downstream
+    // consumers in `findCCTPXDeployment` treat a missing value as `true`.
+    enabled: zod.z.boolean().optional()
 });
 /**
  * Schema for one token entry in the token registry response.
@@ -15285,17 +15430,23 @@ function createNoopLogger() {
 /**
  * Find a token's deployment on the given CCTP domain.
  *
+ * A deployment row with `enabled === false` is treated as missing: an IRIS
+ * operator has flipped the per-chain kill switch (CCTPE-3979), so the SDK must
+ * not route through it even though the row still exists in the registry. A
+ * missing or `true` `enabled` value remains routable — the field is optional on
+ * older IRIS versions and absence is read as "allowed".
+ *
  * @param token - The registry token whose deployments are searched.
  * @param domain - The CCTP domain id to match.
  * @returns The matching {@link CCTPXTokenDeployment}, or `undefined` when the
- *   token has no deployment on that domain.
+ *   token has no deployment on that domain or the deployment is disabled.
  *
  * @example
  * ```typescript
  * const deployment = findCCTPXDeployment(token, 0)
  * ```
  */ function findCCTPXDeployment(token, domain) {
-    return token.deployments.find((deployment)=>deployment.domainId === domain);
+    return token.deployments.find((deployment)=>deployment.domainId === domain && deployment.enabled !== false);
 }
 
 /**
@@ -15397,6 +15548,24 @@ function createNoopLogger() {
                     }
                 }
             })
+    ],
+    // The token is not deployed on one of the route chains, or an operator has
+    // flipped the per-chain `enabled` kill switch on the IRIS deployment row.
+    // Either way the route is permanently unavailable until the operator intervenes;
+    // a retry at the same source/destination will keep returning this error.
+    [
+        'TOKEN_NOT_SUPPORTED_ON_ROUTE',
+        ({ sourceDomain, destinationDomain })=>new KitError({
+                ...InputError.UNSUPPORTED_ROUTE,
+                recoverability: 'FATAL',
+                message: 'CCTPx fee quote rejected the route: the token is not supported on ' + 'the source or destination chain (missing deployment or operator-disabled).',
+                cause: {
+                    trace: {
+                        sourceDomain,
+                        destinationDomain
+                    }
+                }
+            })
     ]
 ]);
 /**
@@ -20653,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.
@@ -21003,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.
@@ -21023,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.
@@ -21031,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
  *
@@ -21042,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({
@@ -21071,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) {
@@ -23407,7 +23605,7 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$3 = "1.14.1";
+var version$3 = "1.14.3";
 var pkg$3 = {
 	version: version$3};
 
@@ -24326,9 +24524,34 @@ function assertCCTPV2Config(config) {
             tokenAddress: source.chain.usdcAddress,
             operationContext: sourceOperationContext
         });
+        await this.assertAmountCoversRecipientSetupFee(params);
         return bridge$1(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
@@ -25045,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
@@ -25083,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 {
@@ -25092,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
@@ -25102,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);
@@ -25652,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.
@@ -26709,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 = {
@@ -26839,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
@@ -26865,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);
         }
@@ -26878,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)
@@ -26915,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
                     }
@@ -26927,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.
@@ -26997,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`
@@ -27025,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
                     }
@@ -27039,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 ()=>{
@@ -27636,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
         }
@@ -27658,7 +28001,7 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
 };
 
 var name$2 = "@circle-fin/swap-kit";
-var version$2 = "1.7.1";
+var version$2 = "1.8.1";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -28000,6 +28343,64 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
 }, {
     message: 'fee amount must be non-negative (>= 0)'
 });
+/**
+ * Parses a display-only field leniently: a value `schema` rejects is replaced
+ * with `fallback` instead of failing the response that carries it.
+ * Implemented with `preprocess` rather than Zod's `.catch()` because static
+ * analysis misreads `.catch` on the schema chain as an unhandled Promise
+ * (S7785).
+ */ const withFallback = (schema, fallback)=>zod.z.preprocess((value)=>schema.safeParse(value).success ? value : fallback, schema);
+const swapRouteTokenSchema = zod.z.object({
+    symbol: zod.z.string(),
+    address: zod.z.string(),
+    decimals: zod.z.number()
+});
+const swapRouteMetadataSchema = zod.z.record(zod.z.unknown()).optional();
+const swapRouteStepSchema = zod.z.object({
+    type: zod.z.string(),
+    tool: zod.z.string(),
+    toolName: zod.z.string(),
+    fromToken: swapRouteTokenSchema,
+    toToken: swapRouteTokenSchema,
+    estimate: zod.z.object({
+        fromAmount: zod.z.string(),
+        toAmount: zod.z.string(),
+        gasCostUSD: zod.z.string().optional()
+    }),
+    metadata: swapRouteMetadataSchema
+});
+/**
+ * Strict schema for a `SwapRoute`. Module-private: service responses
+ * parse routes leniently through {@link responseSwapRouteSchema}.
+ */ const swapRouteSchema = zod.z.object({
+    provider: zod.z.string().min(1, 'provider must be a non-empty string'),
+    steps: zod.z.array(swapRouteStepSchema),
+    metadata: swapRouteMetadataSchema
+});
+/**
+ * Route details are display-only, so service responses parse them leniently:
+ * steps or metadata in a shape the SDK does not know are dropped rather than
+ * failing the quote or swap they describe. Steps are all-or-nothing: if any
+ * step is malformed, `steps` is empty, so a route never silently loses a hop.
+ */ const responseSwapRouteSchema = swapRouteSchema.extend({
+    steps: withFallback(swapRouteSchema.shape.steps, []),
+    metadata: withFallback(swapRouteMetadataSchema, undefined)
+});
+const createSwapFeeItemSchema = zod.z.object({
+    token: zod.z.string({
+        required_error: 'fee token is required',
+        invalid_type_error: 'fee token must be a string'
+    }).min(1, 'fee token must be a non-empty string'),
+    amount: feeAmountSchema,
+    decimals: zod.z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
+    symbol: zod.z.string({
+        invalid_type_error: 'fee token symbol must be a string'
+    }).min(1, 'fee token symbol must be a non-empty string').optional(),
+    // Descriptive metadata: a value the SDK cannot use is dropped rather than
+    // failing the response that carries the fee.
+    type: withFallback(zod.z.string().min(1).optional(), undefined),
+    chain: withFallback(zod.z.string().min(1).optional(), undefined)
+});
 /**
  * Zod schema for validating API keys.
  *
@@ -28085,10 +28486,7 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
     /** Quote information with estimated amounts and route */ quote: zod.z.object({
         /** Estimated output amount (base units) */ estimatedAmount: zod.z.string().min(1, 'estimatedAmount must be a non-empty string').regex(/^\d+$/, 'estimatedAmount must be a numeric string'),
         /** Guaranteed minimum output amount (base units) */ minAmount: zod.z.string().min(1, 'minAmount must be a non-empty string').regex(/^\d+$/, 'minAmount must be a numeric string'),
-        /** Route information from DEX aggregator */ route: zod.z.object({
-            provider: zod.z.string().min(1, 'provider must be a non-empty string'),
-            steps: zod.z.array(zod.z.unknown())
-        })
+        /** Route information from DEX aggregator */ route: responseSwapRouteSchema
     }),
     /** Fee context indicating where fees should be collected */ feeContext: quoteFeeContextSchema
 });
@@ -28304,19 +28702,6 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     }).min(1, 'toChain must be a non-empty string if provided').optional(),
     apiKey: apiKeySchema.optional()
 });
-/**
- * Zod schema for validating CreateSwapResponse payloads.
- */ const createSwapFeeItemSchema = zod.z.object({
-    token: zod.z.string({
-        required_error: 'fee token is required',
-        invalid_type_error: 'fee token must be a string'
-    }).min(1, 'fee token must be a non-empty string'),
-    amount: feeAmountSchema,
-    decimals: zod.z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
-    symbol: zod.z.string({
-        invalid_type_error: 'fee token symbol must be a string'
-    }).min(1, 'fee token symbol must be a non-empty string').optional()
-});
 /**
  * Developer fee item schema with basis field.
  */ const createSwapDeveloperFeeItemSchema = createSwapFeeItemSchema.extend({
@@ -28454,6 +28839,8 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     correlationId: zod.z.preprocess((value)=>zod.z.string().uuid().safeParse(value).success ? value : undefined, zod.z.string().optional()),
     config: createSwapRequestBaseSchema.shape.config.optional(),
     fees: createSwapFeesSchema.optional(),
+    // A route the SDK cannot parse is dropped instead of failing the swap.
+    route: withFallback(responseSwapRouteSchema.optional(), undefined),
     transaction: createSwapTransactionSchema
 });
 
@@ -29581,6 +29968,16 @@ createTokenRegistry();
         name: 'USDC',
         version: '2'
     },
+    Cronos: {
+        chainId: Cronos.chainId,
+        name: 'USDC',
+        version: '2'
+    },
+    Morph: {
+        chainId: Morph.chainId,
+        name: 'USDC',
+        version: '2'
+    },
     Arc_Testnet: {
         chainId: ArcTestnet.chainId,
         name: 'USDC',
@@ -29669,6 +30066,7 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
  * - customFee: Optional fee configuration
  * - apiKey: Optional credential string
  * - kitKey: Optional credential string (deprecated alias for apiKey)
+ * - batchTransactions: Optional boolean to opt out of atomic batching
  */ const swapConfigSchema = zod.z.object({
     allowanceStrategy: allowanceStrategySchema.optional(),
     slippageBps: zod.z.number().int().min(0).optional(),
@@ -29679,7 +30077,10 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
     })(zod.z.string())).optional(),
     customFee: swapCustomFeeSchema.optional(),
     apiKey: zod.z.string().optional(),
-    kitKey: zod.z.string().optional()
+    kitKey: zod.z.string().optional(),
+    batchTransactions: zod.z.boolean({
+        invalid_type_error: 'batchTransactions must be a boolean'
+    }).optional()
 });
 const swapDestinationSchema = zod.z.object({
     chain: optionalSwapChainIdentifierField,
@@ -29872,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.8.1";
+var version$1 = "1.10.0";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -31376,7 +31777,7 @@ registerKit(`${pkg$1.name}/${pkg$1.version}`);
 };
 
 var name = "@circle-fin/borrow-kit";
-var version = "1.0.0";
+var version = "1.1.1";
 var pkg = {
 	name: name,
 	version: version};