@circle-fin/app-kit 1.16.0 → 1.18.0

package/swap.cjs

@@ -2010,22 +2010,73 @@ class KitError extends Error {
     '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);
@@ -3151,6 +3202,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 = {}));
@@ -3842,14 +3895,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',
@@ -4494,7 +4547,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -5363,7 +5417,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -7253,6 +7308,56 @@ var Chains = {
     Blockchain.World_Chain_Sepolia
 ]);
 
+/**
+ * Check if a chain supports a specific type of custom smart contract logic.
+ *
+ * This function examines a chain definition to determine if it has a specific
+ * contract type configured. When a chain has custom contract support, it can
+ * use enhanced features and custom business logic in addition to the standard
+ * CCTP approve/burn/mint flow.
+ *
+ * @param chain - The chain definition to examine for custom contract support.
+ * @param contractType - The type of contract to check for (e.g., 'bridge').
+ * @returns True if the chain supports the specified contract type with a valid address configured.
+ *
+ * @example
+ * ```typescript
+ * import { hasCustomContractSupport, Ethereum } from '@core/chains'
+ *
+ * // Check if a chain supports bridge contracts
+ * if (hasCustomContractSupport(Ethereum, 'bridge')) {
+ *   // Runtime validation confirmed kitContracts.bridge exists
+ *   console.log('Bridge contract:', Ethereum.kitContracts?.bridge)
+ *   return executeCustomFlow(Ethereum.kitContracts?.bridge!, params)
+ * } else {
+ *   console.log('Using standard CCTP flow')
+ *   return executeStandardFlow(params)
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in flow determination
+ * function determineBridgingFlow(chain: ChainDefinition, params: BridgeParams) {
+ *   if (hasCustomContractSupport(chain, 'bridge')) {
+ *     return 'custom'
+ *   } else if (isCCTPV2Supported(chain)) {
+ *     return 'standard'
+ *   } else {
+ *     throw new Error(`Chain ${chain.name} is not supported for bridging`)
+ *   }
+ * }
+ *
+ * // Future usage with other contract types (when added to KitContractType)
+ * // if (hasCustomContractSupport(someChain, 'customType')) {
+ * //   console.log('Custom contract:', someChain.kitContracts?.customType)
+ * // }
+ * ```
+ */ function hasCustomContractSupport(chain, contractType) {
+    const contractAddress = chain.kitContracts?.[contractType];
+    return typeof contractAddress === 'string' && contractAddress.trim().length > 0;
+}
+
 /**
  * Temporary allowlist of chains permitted to initiate Gateway fast deposits.
  * Only chains keyed here are eligible; all others are rejected. Using the
@@ -7506,8 +7611,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([
@@ -8062,7 +8167,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).
@@ -8083,14 +8188,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;
@@ -8101,7 +8206,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.
@@ -9421,11 +9526,13 @@ const swapTokenEnumSchema = zod.z.enum([
         [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',
@@ -9484,6 +9591,7 @@ const swapTokenEnumSchema = zod.z.enum([
         [Blockchain.Arbitrum]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
         [Blockchain.Avalanche]: '0xd586E7F844cEa2F87f50152665BCbc2C279D8d70',
         [Blockchain.Base]: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+        [Blockchain.Cronos]: '0xF2001B145b43032AAF5Ee2884e456CCd805F677D',
         [Blockchain.Ethereum]: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
         [Blockchain.Linea]: '0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5',
         [Blockchain.Optimism]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
@@ -9546,7 +9654,9 @@ const swapTokenEnumSchema = zod.z.enum([
         [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'
@@ -9565,6 +9675,7 @@ const swapTokenEnumSchema = zod.z.enum([
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -10737,7 +10848,7 @@ const swapTokenEnumSchema = zod.z.enum([
 }
 
 var name$3 = "@circle-fin/bridge-kit";
-var version$3 = "1.15.2";
+var version$3 = "1.16.0";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -12392,7 +12503,7 @@ const validateQuoteItemSchema = zod.z.object({
 registerKit(`${pkg$3.name}/${pkg$3.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};
@@ -12852,6 +12963,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.
  *
@@ -12937,10 +13106,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
 });
@@ -13156,19 +13322,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({
@@ -13306,6 +13459,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
 });
 
@@ -13333,6 +13488,25 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
  * }
  * ```
  */ const isGetQuoteResponse = (obj)=>getQuoteResponseSchema.safeParse(obj).success;
+/**
+ * Parse and transform a GetQuoteResponse object.
+ *
+ * Applies the schema's lenient route and fee parsing: entries the SDK does
+ * not recognise are dropped and undeclared fields are stripped, rather than
+ * passed through to callers as the type guard alone would.
+ *
+ * @param obj - The raw API response object to parse.
+ * @returns The validated and transformed GetQuoteResponse.
+ * @throws If validation fails.
+ *
+ * @example
+ * ```typescript
+ * import { parseGetQuoteResponse } from '@core/service-client'
+ *
+ * const quote = parseGetQuoteResponse(await response.json())
+ * console.log(quote.quote.route.steps.length)
+ * ```
+ */ const parseGetQuoteResponse = (obj)=>getQuoteResponseSchema.parse(obj);
 /**
  * Type guard to validate CreateSwapResponse objects.
  *
@@ -13692,7 +13866,9 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
             }
         }
     };
-    return pollApiGet(url, isGetQuoteResponse, effectiveConfig);
+    // Use type guard for validation in polling, then parse for transformation
+    const rawResponse = await pollApiGet(url, isGetQuoteResponse, effectiveConfig);
+    return parseGetQuoteResponse(rawResponse);
 };
 
 /**
@@ -17089,6 +17265,16 @@ function resolveFeePayoutChain(tokenIn, tokenOut, sourceChain, destinationChain)
         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',
@@ -18657,6 +18843,12 @@ const TOKEN_REGISTRY$1 = createTokenRegistry();
  * i.e. 1 + 0.2 + 0.1 = 1.3. Use the greater of (local estimate × this multiplier)
  * or the proxy's gasLimit.
  */ const GAS_SAFETY_MULTIPLIER = 1.3;
+/**
+ * Gas units used to estimate the displayed gas fee when the service returns an
+ * EVM route without a gasLimit, as direct Circle CCTP plans do. Sized from
+ * observed Adapter executions of those plans. Display-only: it never becomes an
+ * execution gas limit.
+ */ const DEFAULT_EVM_SWAP_GAS_LIMIT = 500_000n;
 const TOKEN_REGISTRY = createTokenRegistry();
 /**
  * Enhances a KitError with transaction details (txHash and explorerUrl).
@@ -19173,9 +19365,9 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
         // Calculate estimated gas/transaction fee based on chain type
         let estimatedGasFee = '0';
         const evmGasLimit = 'gasLimit' in serviceResponse.transaction ? serviceResponse.transaction.gasLimit : undefined;
-        if (chain.type === 'evm' && evmGasLimit !== undefined) {
+        if (chain.type === 'evm') {
             // EVM: gasLimit (units) × gasPrice (wei/unit) = estimated gas fee (wei)
-            const gasLimitUnits = BigInt(evmGasLimit);
+            const gasLimitUnits = evmGasLimit === undefined ? DEFAULT_EVM_SWAP_GAS_LIMIT : BigInt(evmGasLimit);
             // Use calculateTransactionFee which fetches current gas price and applies buffer
             const gasEstimate = await params.from.adapter.calculateTransactionFee(gasLimitUnits, undefined, chain);
             // Format the fee from wei to human-readable native currency amount
@@ -19219,7 +19411,10 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
         const estimateResult = {
             stopLimit: formattedStopLimit,
             estimatedOutput: formattedEstimatedOutput,
-            fees
+            fees,
+            ...serviceResponse.route !== undefined && {
+                route: serviceResponse.route
+            }
         };
         return estimateResult;
     }
@@ -19604,7 +19799,7 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
    * }
    * ```
    */ async swap(params) {
-        // Extract wallet context & validate
+        validateServiceSwapParams(params);
         const { from, tokenIn, tokenOut, config } = params;
         const { adapter, chain } = from;
         const destinationChain = params.toChain ?? chain;
@@ -19741,6 +19936,9 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
             ...swapResultFees !== undefined && {
                 fees: swapResultFees
             },
+            ...serviceResponse.route !== undefined && {
+                route: serviceResponse.route
+            },
             progress: statusSnapshot.progress,
             ...statusSnapshot.amountOut !== undefined && {
                 amountOut: statusSnapshot.amountOut
@@ -19941,7 +20139,13 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
             return {
                 token: formatted.token,
                 amount: formatted.amount,
-                type
+                type,
+                ...fee.type !== undefined && {
+                    component: fee.type
+                },
+                ...fee.chain !== undefined && {
+                    chain: fee.chain
+                }
             };
         }));
     }
@@ -19962,7 +20166,13 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
                 token: formatted.token,
                 amount: formatted.amount,
                 type: 'developer',
-                recipientAddress
+                recipientAddress,
+                ...fee.type !== undefined && {
+                    component: fee.type
+                },
+                ...fee.chain !== undefined && {
+                    chain: fee.chain
+                }
             };
         }));
     }
@@ -20019,6 +20229,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(),
@@ -20029,7 +20240,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,
@@ -21004,6 +21218,9 @@ const transformAmount = (value, direction, decimals)=>formatUnits(value, decimal
         ...formattedFees && {
             fees: formattedFees
         },
+        ...result.route !== undefined && {
+            route: result.route
+        },
         ...formattedConfig && {
             config: formattedConfig
         },
@@ -21265,6 +21482,9 @@ const transformAmount = (value, direction, decimals)=>formatUnits(value, decimal
         estimatedOutput: providerEstimate.estimatedOutput,
         ...providerEstimate.fees !== undefined && {
             fees: providerEstimate.fees
+        },
+        ...providerEstimate.route !== undefined && {
+            route: providerEstimate.route
         }
     };
 }
@@ -22956,7 +23176,7 @@ 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};
@@ -24396,7 +24616,7 @@ function hasCrossChainDepositQuoteShape(params) {
 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};