@circle-fin/app-kit 1.16.0 → 1.18.0

package/earn.cjs

@@ -749,6 +749,11 @@ class KitError extends Error {
         code: 5001,
         name: 'ONCHAIN_TRANSACTION_REVERTED',
         type: 'ONCHAIN'
+    },
+    /** Pre-flight transaction simulation failed */ SIMULATION_FAILED: {
+        code: 5002,
+        name: 'ONCHAIN_SIMULATION_FAILED',
+        type: 'ONCHAIN'
     }};
 /**
  * Standardized error definitions for LIQUIDITY type errors.
@@ -1171,6 +1176,49 @@ class KitError extends Error {
     return new KitError(errorDetails);
 }
 
+/**
+ * Creates error for transaction simulation failures.
+ *
+ * This error is thrown when a pre-flight transaction simulation fails,
+ * typically due to contract logic that would revert. The error is FATAL
+ * as it indicates the transaction would fail if submitted.
+ *
+ * @param chain - The blockchain network where the simulation failed
+ * @param reason - The reason for simulation failure (e.g., revert message)
+ * @param trace - Optional trace context to include in error (can include rawError and additional debugging data)
+ * @returns KitError with simulation failure details
+ *
+ * @example
+ * ```typescript
+ * import { createSimulationFailedError } from '@core/errors'
+ *
+ * throw createSimulationFailedError('Ethereum', 'ERC20: insufficient allowance')
+ * // Message: "Simulation failed on Ethereum: ERC20: insufficient allowance"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With trace context for debugging
+ * throw createSimulationFailedError('Ethereum', 'ERC20: insufficient allowance', {
+ *   rawError: error,
+ *   txHash: '0x1234...',
+ *   gasLimit: '21000',
+ * })
+ * ```
+ */ function createSimulationFailedError(chain, reason, trace) {
+    return new KitError({
+        ...OnchainError.SIMULATION_FAILED,
+        recoverability: 'FATAL',
+        message: `Simulation failed on ${chain}: ${reason}`,
+        cause: {
+            trace: {
+                ...trace,
+                chain,
+                reason
+            }
+        }
+    });
+}
 /**
  * Creates error for transaction reverts.
  *
@@ -1225,6 +1273,82 @@ class KitError extends Error {
     });
 }
 
+/**
+ * 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();
+}
+
 /**
  * Type guard to check if an error is a KitError instance.
  *
@@ -2010,7 +2134,7 @@ class KitError extends Error {
  * 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
@@ -2071,6 +2195,15 @@ class KitError extends Error {
         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',
@@ -2312,6 +2445,15 @@ class KitError extends Error {
             recoverability: 'RETRYABLE'
         }
     ],
+    // DEPOSIT_INTENT_INVALID: the Veda deposit intent is missing, expired, or
+    // not signed by the depositing wallet.
+    [
+        380418,
+        {
+            errorDef: EarnError.SIGNATURE_REJECTED,
+            recoverability: 'FATAL'
+        }
+    ],
     // Bridge (380_5XX)
     [
         380500,
@@ -2543,6 +2685,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 = {}));
@@ -3223,14 +3367,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',
@@ -3875,7 +4019,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -4744,7 +4889,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -6634,6 +6780,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
@@ -6887,8 +7083,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([
@@ -7293,7 +7489,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).
@@ -7314,14 +7510,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;
@@ -7332,7 +7528,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.
@@ -8205,11 +8401,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',
@@ -8268,6 +8466,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',
@@ -8330,7 +8529,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'
@@ -8349,6 +8550,7 @@ const swapTokenEnumSchema = zod.z.enum([
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -9367,7 +9569,7 @@ const swapTokenEnumSchema = zod.z.enum([
 }
 
 var name$4 = "@circle-fin/bridge-kit";
-var version$4 = "1.15.2";
+var version$4 = "1.16.0";
 var pkg$4 = {
 	name: name$4,
 	version: version$4};
@@ -11163,7 +11365,7 @@ const validateQuoteItemSchema = zod.z.object({
 registerKit(`${pkg$4.name}/${pkg$4.version}`);
 
 var name$3 = "@circle-fin/swap-kit";
-var version$3 = "1.7.1";
+var version$3 = "1.8.1";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -11505,6 +11707,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.
  *
@@ -11590,10 +11850,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
 });
@@ -11809,19 +12066,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({
@@ -11959,6 +12203,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
 });
 
@@ -14380,6 +14626,47 @@ const abiParameterSchema = zod.z.object({
  */ function hasSignTypedData(adapter) {
     return typeof adapter === 'object' && adapter !== null && 'signTypedData' in adapter && typeof adapter.signTypedData === 'function';
 }
+/**
+ * Type guard to check if an adapter can actually produce an EIP-712
+ * typed-data signature.
+ *
+ * @remarks
+ * Strengthens {@link hasSignTypedData}: having a `signTypedData` method
+ * does not guarantee it can succeed. Adapters whose signer is delegated
+ * (e.g. through a signing strategy backed by a smart contract account)
+ * expose the method but reject typed-data payloads at runtime. Such
+ * adapters report their real capability through an optional
+ * `supportsSignTypedData()` method, which this guard consults when
+ * present. Adapters without the capability method are assumed able to
+ * sign, preserving the previous duck-typing behavior.
+ *
+ * @param adapter - The adapter to check
+ * @returns True if calling `signTypedData` can be expected to succeed
+ *
+ * @example
+ * ```typescript
+ * import { canSignTypedData } from '@core/adapter-evm'
+ *
+ * if (canSignTypedData(adapter)) {
+ *   const signature = await adapter.signTypedData(typedData, context)
+ * } else {
+ *   // take an on-chain approval path instead of a permit signature
+ * }
+ * ```
+ */ function canSignTypedData(adapter) {
+    if (!hasSignTypedData(adapter)) {
+        return false;
+    }
+    if (typeof adapter.supportsSignTypedData === 'function') {
+        // The value is `boolean` per the interface, but a plain-JS adapter may
+        // return anything; treat it as untrusted and coerce to a strict
+        // boolean. Comparing an `unknown` (not a `boolean`) also keeps the
+        // lint autofix from stripping this as a redundant `=== true`.
+        const supported = adapter.supportsSignTypedData();
+        return supported === true;
+    }
+    return true;
+}
 
 /** Inputs for {@link checkErc3009ValidityWindow}. */ /**
  * Check an ERC-3009 authorization validity window.
@@ -14921,6 +15208,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',
@@ -15009,6 +15306,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(),
@@ -15019,7 +15317,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,
@@ -15212,7 +15513,7 @@ new Set(Object.values(Blockchain));
 registerKit(`${pkg$3.name}/${pkg$3.version}`);
 
 var name$2 = "@circle-fin/earn-kit";
-var version$2 = "1.8.1";
+var version$2 = "1.10.0";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -15319,6 +15620,61 @@ const EARN_BRIDGE_USDC_ERC3009_DOMAINS = {
  *
  * @internal
  */ const EARN_BRIDGE_MAX_VALIDITY_SECONDS = 86_400n;
+/**
+ * Static fields of the EIP-712 domain for the `DepositIntent` typed-data
+ * intent. `chainId` is excluded here — it must come from the deposit's
+ * actual chain (see {@link buildDepositIntentTypedData}), since a mismatched
+ * `chainId` in the domain separator would make every intent signature
+ * invalid.
+ *
+ * `verifyingContract` is intentionally omitted — the intent is verified
+ * off-chain by the Earn Service, not by a deployed contract.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_DOMAIN = {
+    name: 'Circle EarnKit',
+    version: '1'
+};
+/**
+ * EIP-712 type definition for the `DepositIntent` struct.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_TYPES = {
+    DepositIntent: [
+        {
+            name: 'wallet',
+            type: 'address'
+        },
+        {
+            name: 'vault',
+            type: 'address'
+        },
+        {
+            name: 'amount',
+            type: 'uint256'
+        },
+        {
+            name: 'deadline',
+            type: 'uint256'
+        }
+    ]
+};
+/**
+ * Lifetime of a `DepositIntent` signature, in seconds.
+ *
+ * The Earn Service rejects a deadline more than 300 seconds ahead of its own
+ * clock. 240 seconds leaves room for clock skew between the client and the
+ * service while still covering the deposit request that follows the
+ * signature.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_TTL_SECONDS = 240;
+/**
+ * Protocol value the Earn Service reports for Veda vaults. A deposit into a
+ * Veda vault needs a signed `DepositIntent`.
+ *
+ * @internal
+ */ const VEDA_PROTOCOL = 'veda';
 /**
  * Display symbol for vault share tokens.
  *
@@ -16962,6 +17318,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',
@@ -17007,6 +17544,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}.
  *
@@ -17028,7 +17569,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)
@@ -17971,7 +18512,7 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
 }
 
 var name$1 = "@circle-fin/provider-earn-service";
-var version$1 = "1.7.1";
+var version$1 = "1.8.0";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -18323,8 +18864,9 @@ function toPositionInfo(data) {
  * Build signed deposit instructions via the Earn Service API.
  *
  * Call `POST /v1/earnKit/deposit` with the vault address, amount,
- * wallet address, and chain. Return EIP-712 signed execution
- * parameters for on-chain submission.
+ * wallet address, and chain, plus the signed `DepositIntent` when one is
+ * given. Return EIP-712 signed execution parameters for on-chain
+ * submission.
  *
  * @param params - Deposit parameters
  * @returns Signed execution parameters for the deposit
@@ -18338,7 +18880,8 @@ function toPositionInfo(data) {
         vaultAddress: params.vaultAddress,
         amount: params.amount,
         address: params.address,
-        chain: params.chain
+        chain: params.chain,
+        ...params.intent
     };
     try {
         const response = await pollApiPost(url.toString(), requestBody, isDepositResponse, pollingConfig);
@@ -18350,6 +18893,232 @@ function toPositionInfo(data) {
     }
 }
 
+/**
+ * Build the version-1 EarnKit `DepositIntent` EIP-712 typed data.
+ *
+ * The signed struct binds the depositing `wallet`, the target `vault`, the
+ * deposit `amount` in the asset's smallest unit, and a signature `deadline`.
+ * The Earn Service rebuilds the same struct from the deposit request and
+ * rejects the deposit unless `wallet` signed it. The domain intentionally
+ * omits `verifyingContract` because the service verifies the signature
+ * off-chain.
+ *
+ * `domain.chainId` comes from the deposit's chain rather than a constant: the
+ * domain separator must match what the service rebuilds, and a wrong
+ * `chainId` would make every intent signature invalid.
+ *
+ * This function returns the fully-typed {@link DepositIntentTypedData} with
+ * no assertion. {@link resolveDepositIntent} casts it to the adapter's
+ * generic `EIP712Domain` shape only where it calls `adapter.signTypedData`,
+ * since that shared interface always requires `verifyingContract`. The
+ * adapter's runtime `eip712DomainSchema` treats `verifyingContract` as
+ * optional, so the cast is safe at runtime. BorrowKit's
+ * `buildWebhookRegistrationTypedData` works around the same gap.
+ *
+ * @param params - Wallet, vault, base-unit amount, deadline, and chain id.
+ * @returns EIP-712 typed data ready to be cast for `adapter.signTypedData`.
+ *
+ * @example
+ * ```typescript
+ * const typedData = buildDepositIntentTypedData({
+ *   wallet: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   vault: '0x00000000000000000000000000000000000000a1',
+ *   amount: 100_000_000n,
+ *   deadline: 1_700_000_000n,
+ *   chainId: 5_042_002,
+ * })
+ * ```
+ *
+ * @internal
+ */ function buildDepositIntentTypedData(params) {
+    return {
+        domain: {
+            ...DEPOSIT_INTENT_DOMAIN,
+            chainId: params.chainId
+        },
+        types: DEPOSIT_INTENT_TYPES,
+        primaryType: 'DepositIntent',
+        message: {
+            wallet: params.wallet,
+            vault: params.vault,
+            amount: params.amount,
+            deadline: params.deadline
+        }
+    };
+}
+/**
+ * Earn Service error code for a missing, expired, or wrongly signed
+ * `DepositIntent` (`DEPOSIT_INTENT_INVALID`).
+ */ const DEPOSIT_INTENT_INVALID_CODE = 380418;
+/**
+ * Sign a `DepositIntent` when the target vault needs one.
+ *
+ * A Veda vault mints shares straight to the depositing wallet, so the Earn
+ * Service only builds a Veda deposit for a wallet that signed a
+ * `DepositIntent` for the same vault and amount. The vault lookup exists only
+ * to find out whether the vault is a Veda vault (and its asset decimals, to
+ * sign the amount). Other vaults ignore the intent, so this returns no intent
+ * for them and the wallet sees no extra signature prompt. A vault the service
+ * does not return is also treated as not needing an intent; the deposit call
+ * then reports why.
+ *
+ * A failed vault lookup does not stop the deposit: this returns the lookup
+ * error with no intent, so a non-Veda deposit works as before. A Veda deposit
+ * then gets `DEPOSIT_INTENT_INVALID` from the service, and
+ * {@link resolveDepositError} reports the lookup error instead. The lookup
+ * fails either by throwing or by returning the vault in its `errors` list (for
+ * example `VAULT_REFRESH_BUSY`); both are kept the same way.
+ *
+ * @param params - Adapter, resolved chain, wallet, vault, human-readable
+ *   amount, and service config.
+ * @returns The signed intent when the vault needs one, and the lookup error
+ *   when the vault lookup failed.
+ * @throws {@link KitError} `InputError.VALIDATION_FAILED` when the vault needs
+ *   an intent but the chain is not EVM, the adapter cannot sign typed data, or
+ *   the amount has more decimal places than the vault asset.
+ *
+ * @example
+ * ```typescript
+ * const { intent } = await resolveDepositIntent({
+ *   adapter,
+ *   chain: ArcTestnet,
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   vaultAddress: '0x00000000000000000000000000000000000000a1',
+ *   amount: '100',
+ *   config,
+ * })
+ * // intent -> { intentSignature: '0x…', intentDeadline: 1700000240 }
+ * ```
+ *
+ * @internal
+ */ async function resolveDepositIntent(params) {
+    let lookup;
+    try {
+        lookup = await fetchVaults({
+            // `resolveAdapterContext` already rejected chains the Earn Service does
+            // not support, so the chain is an Earn chain here.
+            vaults: [
+                {
+                    chain: params.chain,
+                    vaultAddress: params.vaultAddress
+                }
+            ],
+            config: params.config
+        });
+    } catch (lookupError) {
+        return {
+            lookupError
+        };
+    }
+    const vaultError = lookup.errors.find((candidate)=>isSameAddress(candidate.vaultAddress, params.vaultAddress));
+    if (vaultError !== undefined) {
+        // Same handling as a thrown lookup error, mapped with the Earn Service
+        // error table so it keeps its recoverability (VAULT_REFRESH_BUSY retries).
+        return {
+            lookupError: parseEarnApiError({
+                responseBody: {
+                    code: vaultError.code,
+                    message: vaultError.message
+                }
+            }, {
+                operation: 'getVaults'
+            })
+        };
+    }
+    const vault = lookup.vaults.find((candidate)=>isSameAddress(candidate.address, params.vaultAddress));
+    if (vault?.protocol.toLowerCase() !== VEDA_PROTOCOL) {
+        return {};
+    }
+    if (params.chain.type !== 'evm') {
+        throw createValidationFailedError('from.chain', params.chain.chain, 'Veda vault deposits need an EVM chain to sign the deposit intent');
+    }
+    if (!canSignTypedData(params.adapter)) {
+        throw createValidationFailedError('from.adapter', params.adapter, 'adapter must support signTypedData for Veda vault deposits');
+    }
+    const wallet = assertHexAddress('from.address', params.address, 'Depositor address must be a 0x-prefixed 20-byte hex address.');
+    const assetDecimals = vault.liquidityProfile.totalDeposits.decimals;
+    // Amount.parse truncates extra digits, but the service rejects them. Fail
+    // before the wallet prompt instead of asking to sign a deposit that cannot
+    // go through.
+    assertDecimalPlaces('amount', params.amount, assetDecimals, `amount must have at most ${String(assetDecimals)} decimal places for the vault asset`);
+    const deadline = Math.floor(Date.now() / 1000) + DEPOSIT_INTENT_TTL_SECONDS;
+    const typedData = buildDepositIntentTypedData({
+        wallet,
+        vault: params.vaultAddress,
+        amount: Amount.parse(params.amount, {
+            decimals: assetDecimals
+        }).raw,
+        deadline: BigInt(deadline),
+        chainId: params.chain.chainId
+    });
+    // `typedData.domain` intentionally omits `verifyingContract` (the Earn
+    // Service verifies off-chain), but the shared `signTypedData` signature
+    // requires the standard `EIP712Domain` shape. The adapter's runtime
+    // `eip712DomainSchema` treats `verifyingContract` as optional, so this cast
+    // is safe at runtime.
+    const intentSignature = await params.adapter.signTypedData(typedData, {
+        chain: params.chain,
+        address: wallet
+    });
+    return {
+        intent: {
+            intentSignature,
+            intentDeadline: deadline
+        }
+    };
+}
+/**
+ * Pick the error to report for a failed deposit request.
+ *
+ * When the vault lookup failed, the SDK sent the deposit without an intent.
+ * If the service then answers `DEPOSIT_INTENT_INVALID`, the vault is a Veda
+ * vault and the real cause is the failed lookup, not a bad signature. Report
+ * the lookup error, which keeps its own recoverability (often retryable),
+ * instead of a fatal signature rejection.
+ *
+ * When the SDK did send an intent and the service still answers
+ * `DEPOSIT_INTENT_INVALID`, the error stays a fatal signature rejection, but
+ * its message adds that the intent may have expired: the deadline starts
+ * before the wallet prompt, so a slow signer can submit an expired intent.
+ * Calling `deposit()` again signs a new one. Every other error is reported as
+ * is.
+ *
+ * @param resolution - The result of {@link resolveDepositIntent}.
+ * @param error - The error from the deposit request.
+ * @returns The error to throw.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   return await fetchDeposit({ ...params, intent: resolution.intent })
+ * } catch (error) {
+ *   throw resolveDepositError(resolution, error)
+ * }
+ * ```
+ *
+ * @internal
+ */ function resolveDepositError(resolution, error) {
+    if (resolution.lookupError !== undefined && isKitError(error) && isEarnServiceCode(error.cause?.trace, DEPOSIT_INTENT_INVALID_CODE)) {
+        return resolution.lookupError;
+    }
+    if (resolution.intent !== undefined && isKitError(error) && isEarnServiceCode(error.cause?.trace, DEPOSIT_INTENT_INVALID_CODE)) {
+        return new KitError({
+            code: error.code,
+            name: error.name,
+            type: error.type,
+            recoverability: error.recoverability,
+            message: `${error.message} The deposit intent may have expired before the deposit was submitted (it is valid for ${String(DEPOSIT_INTENT_TTL_SECONDS)} seconds from when the SDK asks the wallet to sign). Call deposit() again to sign a new intent.`,
+            ...error.cause !== undefined && {
+                cause: error.cause
+            }
+        });
+    }
+    return error;
+}
+function isEarnServiceCode(trace, code) {
+    return typeof trace === 'object' && trace !== null && 'earnServiceCode' in trace && trace.earnServiceCode === code;
+}
+
 /**
  * Build cross-chain deposit instructions via the bridge API.
  *
@@ -19232,7 +20001,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)) {
@@ -19578,13 +20347,31 @@ function finishElapsedWait(lastStatus, lastError) {
             const adapterContractAddress = requireAdapterContract(chain);
             const { adapter } = params.from;
             const vaultAddress = assertHexAddress('vaultAddress', params.vaultAddress, 'Vault address must be a 0x-prefixed 20-byte hex address.');
-            const { execId, executionParams, signature } = await this.runPhase(ctx, 'deposit', 'fetchParams', async ()=>fetchDeposit({
+            const { execId, executionParams, signature } = await this.runPhase(ctx, 'deposit', 'fetchParams', async ()=>{
+                // Veda vaults mint shares straight to `address`, so the service
+                // needs proof that `address` asked for this deposit. Sign it here,
+                // inside fetchParams, so a rejected prompt fails this phase.
+                const resolution = await resolveDepositIntent({
+                    adapter,
+                    chain,
+                    address,
                     vaultAddress,
                     amount: params.amount,
-                    address,
-                    chain: apiChain,
                     config
-                }), ()=>undefined);
+                });
+                try {
+                    return await fetchDeposit({
+                        vaultAddress,
+                        amount: params.amount,
+                        address,
+                        chain: apiChain,
+                        intent: resolution.intent,
+                        config
+                    });
+                } catch (error) {
+                    throw resolveDepositError(resolution, error);
+                }
+            }, ()=>undefined);
             validateExecutionDeadline(executionParams);
             const transactionReportContext = {
                 execId,
@@ -22591,7 +23378,7 @@ registerKit(`${pkg$2.name}/${pkg$2.version}`);
 };
 
 var name = "@circle-fin/borrow-kit";
-var version = "1.0.0";
+var version = "1.1.1";
 var pkg = {
 	name: name,
 	version: version};