@circle-fin/app-kit 1.16.0 → 1.17.0

package/index.mjs

@@ -2804,22 +2804,96 @@ 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;
+}
+/**
+ * Finds the raw revert data on an error or anywhere in its `cause` chain.
+ *
+ * Reads `data`, the nested `data.data` from browser wallets, and viem's
+ * `raw`. Only hex of at least 4 bytes counts, so decoded `data` objects and
+ * empty `0x` data are skipped.
+ *
+ * Revert data is public: it is what the contract returned. Keep it when the
+ * rest of a raw error is redacted, so callers can still decode the revert.
+ *
+ * @param error - The raw error from the blockchain library
+ * @returns The revert data in lowercase, or undefined if there is none
+ *
+ * @example
+ * ```typescript
+ * import { extractRevertData } from '@core/errors'
+ *
+ * extractRevertData({ cause: { data: { data: '0xF64059DB' } } })
+ * // Returns: '0xf64059db'
+ * ```
+ */ function extractRevertData(error) {
+    return findRevertData(error, (data)=>REVERT_DATA_PATTERN.test(data))?.toLowerCase();
+}
 /**
  * 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);
@@ -4356,7 +4430,7 @@ let activeRedactor = defaultMessageRedactor;
  * between input errors (fix your request) and service errors (retry later).
  *
  * Error code ranges:
- * - 1100-1106: INPUT errors — invalid, unsupported, or stale request state
+ * - 1100-1107: INPUT errors — invalid, unsupported, or stale request state
  * - 8100-8105: SERVICE errors — retryable backend/provider failures
  *
  * @example
@@ -4417,6 +4491,15 @@ let activeRedactor = defaultMessageRedactor;
         name: 'EARN_BRIDGE_QUOTE_EXPIRED',
         type: 'INPUT'
     },
+    /**
+   * The wallet's vault shares are inside the vault's share lock period, which
+   * starts at deposit. Surfaced as FATAL rather than RETRYABLE because the
+   * lock can last hours, so an immediate retry fails the same way.
+   */ SHARES_LOCKED: {
+        code: 1107,
+        name: 'EARN_SHARES_LOCKED',
+        type: 'INPUT'
+    },
     /** The proxy signing call failed — retryable. */ SIGNING_FAILED: {
         code: 8100,
         name: 'EARN_SIGNING_FAILED',
@@ -5563,6 +5646,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 = {}));
@@ -6916,7 +7001,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -7785,7 +7871,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -10156,8 +10243,8 @@ var Chains = /*#__PURE__*/Object.freeze({
  * 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 = z.union([
@@ -10799,7 +10886,7 @@ const swapTokenEnumSchema = 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).
@@ -10820,14 +10907,14 @@ const swapTokenEnumSchema = 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;
@@ -10838,7 +10925,7 @@ const swapTokenEnumSchema = 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.
@@ -12363,11 +12450,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',
@@ -12426,6 +12515,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',
@@ -12488,7 +12578,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'
@@ -12507,6 +12599,7 @@ function parseOrThrow(value, schema, context) {
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -14581,7 +14674,7 @@ function resolveOptions(options) {
 }
 
 var name$5 = "@circle-fin/bridge-kit";
-var version$6 = "1.15.2";
+var version$6 = "1.15.3";
 var pkg$6 = {
 	name: name$5,
 	version: version$6};
@@ -17646,7 +17739,11 @@ function createNoopLogger() {
     tokenId: bytes32Hex,
     domainId: nonNegativeInteger,
     tokenAddress: z.string(),
-    tokenManagerAddress: z.string()
+    tokenManagerAddress: 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: z.boolean().optional()
 });
 /**
  * Schema for one token entry in the token registry response.
@@ -18130,17 +18227,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);
 }
 
 /**
@@ -18242,6 +18345,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
+                    }
+                }
+            })
     ]
 ]);
 /**
@@ -26252,7 +26373,7 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$5 = "1.14.1";
+var version$5 = "1.14.2";
 var pkg$5 = {
 	version: version$5};
 
@@ -30472,7 +30593,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
 registerKit(`${pkg$6.name}/${pkg$6.version}`);
 
 var name$4 = "@circle-fin/swap-kit";
-var version$4 = "1.7.1";
+var version$4 = "1.8.0";
 var pkg$4 = {
 	name: name$4,
 	version: version$4};
@@ -30932,6 +31053,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)=>z.preprocess((value)=>schema.safeParse(value).success ? value : fallback, schema);
+const swapRouteTokenSchema = z.object({
+    symbol: z.string(),
+    address: z.string(),
+    decimals: z.number()
+});
+const swapRouteMetadataSchema = z.record(z.unknown()).optional();
+const swapRouteStepSchema = z.object({
+    type: z.string(),
+    tool: z.string(),
+    toolName: z.string(),
+    fromToken: swapRouteTokenSchema,
+    toToken: swapRouteTokenSchema,
+    estimate: z.object({
+        fromAmount: z.string(),
+        toAmount: z.string(),
+        gasCostUSD: z.string().optional()
+    }),
+    metadata: swapRouteMetadataSchema
+});
+/**
+ * Strict schema for a `SwapRoute`. Module-private: service responses
+ * parse routes leniently through {@link responseSwapRouteSchema}.
+ */ const swapRouteSchema = z.object({
+    provider: z.string().min(1, 'provider must be a non-empty string'),
+    steps: 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 = z.object({
+    token: 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: z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
+    symbol: 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(z.string().min(1).optional(), undefined),
+    chain: withFallback(z.string().min(1).optional(), undefined)
+});
 /**
  * Zod schema for validating API keys.
  *
@@ -31017,10 +31196,7 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
     /** Quote information with estimated amounts and route */ quote: z.object({
         /** Estimated output amount (base units) */ estimatedAmount: 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: 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: z.object({
-            provider: z.string().min(1, 'provider must be a non-empty string'),
-            steps: z.array(z.unknown())
-        })
+        /** Route information from DEX aggregator */ route: responseSwapRouteSchema
     }),
     /** Fee context indicating where fees should be collected */ feeContext: quoteFeeContextSchema
 });
@@ -31236,19 +31412,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 = z.object({
-    token: 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: z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
-    symbol: 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({
@@ -31386,6 +31549,8 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     correlationId: z.preprocess((value)=>z.string().uuid().safeParse(value).success ? value : undefined, 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
 });
 
@@ -31413,6 +31578,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.
  *
@@ -31818,7 +32002,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);
 };
 
 /**
@@ -40742,6 +40928,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',
@@ -42310,6 +42506,12 @@ const TOKEN_REGISTRY$2 = 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$1 = createTokenRegistry();
 /**
  * Enhances a KitError with transaction details (txHash and explorerUrl).
@@ -42826,9 +43028,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
@@ -42872,7 +43074,10 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
         const estimateResult = {
             stopLimit: formattedStopLimit,
             estimatedOutput: formattedEstimatedOutput,
-            fees
+            fees,
+            ...serviceResponse.route !== undefined && {
+                route: serviceResponse.route
+            }
         };
         return estimateResult;
     }
@@ -43257,7 +43462,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;
@@ -43394,6 +43599,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
@@ -43594,7 +43802,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
+                }
             };
         }));
     }
@@ -43615,7 +43829,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
+                }
             };
         }));
     }
@@ -43672,6 +43892,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 = z.object({
     allowanceStrategy: allowanceStrategySchema$1.optional(),
     slippageBps: z.number().int().min(0).optional(),
@@ -43682,7 +43903,10 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
     })(z.string())).optional(),
     customFee: swapCustomFeeSchema.optional(),
     apiKey: z.string().optional(),
-    kitKey: z.string().optional()
+    kitKey: z.string().optional(),
+    batchTransactions: z.boolean({
+        invalid_type_error: 'batchTransactions must be a boolean'
+    }).optional()
 });
 const swapDestinationSchema = z.object({
     chain: optionalSwapChainIdentifierField,
@@ -44657,6 +44881,9 @@ const transformAmount = (value, direction, decimals)=>formatUnits(value, decimal
         ...formattedFees && {
             fees: formattedFees
         },
+        ...result.route !== undefined && {
+            route: result.route
+        },
         ...formattedConfig && {
             config: formattedConfig
         },
@@ -44918,6 +45145,9 @@ const transformAmount = (value, direction, decimals)=>formatUnits(value, decimal
         estimatedOutput: providerEstimate.estimatedOutput,
         ...providerEstimate.fees !== undefined && {
             fees: providerEstimate.fees
+        },
+        ...providerEstimate.route !== undefined && {
+            route: providerEstimate.route
         }
     };
 }
@@ -46717,7 +46947,7 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
 };
 
 var name$3 = "@circle-fin/earn-kit";
-var version$3 = "1.8.1";
+var version$3 = "1.9.0";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -48505,6 +48735,187 @@ function isCrossChainDepositStatusStep(step) {
     return step.name === 'status';
 }
 
+/**
+ * Selector of `TellerWithMultiAssetSupport__SharesAreLocked()`.
+ */ const SHARES_LOCKED_SELECTOR = '0xf64059db';
+/**
+ * Readable reasons for Veda BoringVault Teller and Accountant reverts.
+ */ const VEDA_REVERT_REASONS = {
+    '0xe0f9e71d': 'The vault is paused',
+    '0x3b3132f6': 'The vault exchange rate is paused',
+    '0xc8bfa33e': 'The vault does not support this asset for this operation',
+    '0x4b37cd2a': 'The asset amount must be greater than zero',
+    '0x3a8c54c4': 'The share amount must be greater than zero',
+    '0x4bd956a8': 'The deposit would mint fewer vault shares than the signed minimum',
+    '0x9883d840': 'The withdrawal would pay out fewer assets than the signed minimum',
+    '0xed32f3bb': 'The deposit would exceed the vault deposit cap',
+    '0x1b8851f0': 'The permit failed and the token allowance is too low',
+    '0x2821264f': 'The vault denied the share transfer'
+};
+/**
+ * Matches a 4-byte selector in a message. The lookarounds stop a longer hex
+ * value, such as an address or a hash, from matching.
+ */ const SELECTOR_IN_TEXT = /(?<![0-9a-fx])0x[0-9a-f]{8}(?![0-9a-f])/gi;
+function toRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function isVedaSelector(selector) {
+    return selector === SHARES_LOCKED_SELECTOR || selector in VEDA_REVERT_REASONS;
+}
+/**
+ * Reads the selector from the revert data on a trace. The `/next` adapters
+ * keep it on `revertData`. The default adapters keep the whole raw error on
+ * `rawError`.
+ */ function selectorFromData(trace) {
+    const data = typeof trace['revertData'] === 'string' ? trace['revertData'] : extractRevertData(trace['rawError']);
+    const selector = data?.slice(0, 10).toLowerCase();
+    return selector !== undefined && isVedaSelector(selector) ? selector : undefined;
+}
+/**
+ * Reads the selector from error text, for wallets that return no revert
+ * data and put the selector or the decoded error name in the message.
+ */ function selectorFromText(texts) {
+    for (const text of texts){
+        if (typeof text !== 'string') {
+            continue;
+        }
+        if (/SharesAreLocked/i.test(text)) {
+            return SHARES_LOCKED_SELECTOR;
+        }
+        const selector = text.match(SELECTOR_IN_TEXT)?.map((match)=>match.toLowerCase()).find(isVedaSelector);
+        if (selector !== undefined) {
+            return selector;
+        }
+    }
+    return undefined;
+}
+/**
+ * Reads a Veda revert from one error, without looking at nested errors.
+ */ function readVedaRevert(error) {
+    const trace = toRecord(error.cause?.trace);
+    const selector = selectorFromData(trace) ?? selectorFromText([
+        error.message,
+        trace['reason']
+    ]);
+    if (selector === undefined) {
+        return undefined;
+    }
+    const chain = trace['chain'];
+    return {
+        selector,
+        chain: typeof chain === 'string' ? chain : undefined
+    };
+}
+/**
+ * Returns the errors that a failed batch nests under `trace.cause` or
+ * `trace.error`.
+ */ function nestedErrors(error) {
+    const trace = toRecord(error.cause?.trace);
+    return [
+        trace['cause'],
+        trace['error']
+    ].filter(isKitError);
+}
+/**
+ * Finds a Veda revert on the error or on an error nested in its trace.
+ */ function findVedaRevert(error) {
+    const seen = new Set();
+    const pending = [
+        error
+    ];
+    let current = pending.pop();
+    while(current !== undefined){
+        if (!seen.has(current)) {
+            seen.add(current);
+            const revert = readVedaRevert(current);
+            if (revert !== undefined) {
+                return {
+                    ...revert,
+                    nested: current !== error
+                };
+            }
+            pending.push(...nestedErrors(current));
+        }
+        current = pending.pop();
+    }
+    return undefined;
+}
+/**
+ * Map a Veda vault revert to an Earn error.
+ *
+ * A Teller `SharesAreLocked()` revert becomes `EARN_SHARES_LOCKED`. Other
+ * known Veda reverts keep their simulation failed or transaction reverted
+ * code and get a readable reason. A failed batch that wraps a Veda revert
+ * keeps its code, and the reason is added to its message. A timed out batch
+ * is returned unchanged, because its outcome is unknown. Any other error is
+ * returned unchanged.
+ *
+ * @param error - The error caught from an earn operation.
+ * @returns The mapped error, or `error` when it is not a Veda revert.
+ *
+ * @example
+ * ```typescript
+ * import { mapVedaRevert } from './vedaRevert'
+ *
+ * const mapped = mapVedaRevert(error)
+ * console.log(mapped.name) // 'EARN_SHARES_LOCKED' for a share lock revert
+ * ```
+ *
+ * @internal
+ */ function mapVedaRevert(error) {
+    if (error.name === NetworkError.TIMEOUT.name) {
+        return error;
+    }
+    const revert = findVedaRevert(error);
+    if (revert === undefined) {
+        return error;
+    }
+    const trace = toRecord(error.cause?.trace);
+    const chain = typeof trace['chain'] === 'string' ? trace['chain'] : revert.chain ?? 'EVM';
+    if (revert.selector === SHARES_LOCKED_SELECTOR) {
+        return new KitError({
+            ...EarnError.SHARES_LOCKED,
+            // The lock can last hours, so an immediate retry fails the same way.
+            recoverability: 'FATAL',
+            message: `Vault shares on ${chain} are still locked after a recent deposit. Wait for the vault's share lock period to end, then try again.`,
+            cause: {
+                trace: {
+                    ...trace,
+                    selector: revert.selector,
+                    chain
+                }
+            }
+        });
+    }
+    const readable = VEDA_REVERT_REASONS[revert.selector];
+    if (readable === undefined) {
+        return error;
+    }
+    const reason = `${readable} (${revert.selector})`;
+    if (error.name === OnchainError.SIMULATION_FAILED.name) {
+        return createSimulationFailedError(chain, reason, trace);
+    }
+    if (error.name === OnchainError.TRANSACTION_REVERTED.name) {
+        return createTransactionRevertedError(chain, reason, trace);
+    }
+    if (!revert.nested) {
+        return error;
+    }
+    return new KitError({
+        code: error.code,
+        name: error.name,
+        type: error.type,
+        recoverability: error.recoverability,
+        message: `${error.message} Reason: ${reason}.`,
+        cause: {
+            trace: {
+                ...trace,
+                reason
+            }
+        }
+    });
+}
+
 const EARN_OPERATIONS = new Set([
     'deposit',
     'withdraw',
@@ -48550,6 +48961,10 @@ const EARN_OPERATIONS = new Set([
  * `RESUMABLE` so callers know `retry()` can resume from the failed phase. A
  * fatal underlying error stays fatal — it cannot be resumed.
  *
+ * A Veda vault revert is mapped first (see {@link mapVedaRevert}): a share
+ * lock becomes `EARN_SHARES_LOCKED`, and other known Veda reverts get a
+ * readable reason.
+ *
  * Non-{@link KitError} inputs (which should not occur on provider code paths)
  * are normalized to a retryable {@link ServiceError.INTERNAL_ERROR}.
  *
@@ -48571,7 +48986,7 @@ const EARN_OPERATIONS = new Set([
  * }
  * ```
  */ function augmentEarnError(error, context) {
-    const base = isKitError(error) ? error : new KitError({
+    const base = isKitError(error) ? mapVedaRevert(error) : new KitError({
         ...ServiceError.INTERNAL_ERROR,
         recoverability: 'RETRYABLE',
         message: getErrorMessage(error)
@@ -49514,7 +49929,7 @@ const bridgeDepositPrepareReviewSchema = z.object({
 }
 
 var name$2 = "@circle-fin/provider-earn-service";
-var version$2 = "1.7.1";
+var version$2 = "1.7.2";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -50775,7 +51190,7 @@ function reportTransactionFailure(reportContext, action, error) {
 }
 function transactionReportErrorCode(error) {
     if (isKitError(error)) {
-        return error.name;
+        return mapVedaRevert(error).name;
     }
     const message = getErrorMessage(error);
     if (/user (rejected|denied)|rejected by user/i.test(message)) {
@@ -54144,7 +54559,7 @@ registerKit(`${pkg$3.name}/${pkg$3.version}`);
 };
 
 var name$1 = "@circle-fin/borrow-kit";
-var version$1 = "1.0.0";
+var version$1 = "1.1.0";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -64868,7 +65283,7 @@ function normaliseLoadTimeout(value) {
     currency: z.string().min(1).optional(),
     email: z.string().email().optional(),
     assets: onrampAssetSelectionSchema.optional(),
-    metadata: z.record(z.string(), z.unknown()).optional()
+    metadata: z.record(z.string(), z.string()).optional()
 });
 
 /**
@@ -67053,7 +67468,7 @@ async function deposit$2(context, params) {
 }
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.8.0";
+var version = "1.8.1";
 var pkg = {
 	name: name,
 	version: version};