@circle-fin/app-kit 1.16.0 → 1.17.0

package/earn.mjs

@@ -743,6 +743,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.
@@ -1165,6 +1170,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.
  *
@@ -1219,6 +1267,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.
  *
@@ -2004,7 +2128,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
@@ -2065,6 +2189,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',
@@ -2537,6 +2670,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 = {}));
@@ -3869,7 +4004,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -4738,7 +4874,8 @@ var BorrowChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -6628,6 +6765,56 @@ var Chains = /*#__PURE__*/Object.freeze({
     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
@@ -6881,8 +7068,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([
@@ -7287,7 +7474,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).
@@ -7308,14 +7495,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;
@@ -7326,7 +7513,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.
@@ -8199,11 +8386,13 @@ const swapTokenEnumSchema = 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',
@@ -8262,6 +8451,7 @@ const swapTokenEnumSchema = z.enum([
         [Blockchain.Arbitrum]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
         [Blockchain.Avalanche]: '0xd586E7F844cEa2F87f50152665BCbc2C279D8d70',
         [Blockchain.Base]: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+        [Blockchain.Cronos]: '0xF2001B145b43032AAF5Ee2884e456CCd805F677D',
         [Blockchain.Ethereum]: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
         [Blockchain.Linea]: '0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5',
         [Blockchain.Optimism]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
@@ -8324,7 +8514,9 @@ const swapTokenEnumSchema = 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'
@@ -8343,6 +8535,7 @@ const swapTokenEnumSchema = z.enum([
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -9361,7 +9554,7 @@ const swapTokenEnumSchema = z.enum([
 }
 
 var name$4 = "@circle-fin/bridge-kit";
-var version$4 = "1.15.2";
+var version$4 = "1.15.3";
 var pkg$4 = {
 	name: name$4,
 	version: version$4};
@@ -11157,7 +11350,7 @@ const validateQuoteItemSchema = 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.0";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -11499,6 +11692,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.
  *
@@ -11584,10 +11835,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
 });
@@ -11803,19 +12051,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({
@@ -11953,6 +12188,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
 });
 
@@ -14915,6 +15152,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',
@@ -15003,6 +15250,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.optional(),
     slippageBps: z.number().int().min(0).optional(),
@@ -15013,7 +15261,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,
@@ -15206,7 +15457,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.9.0";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -16956,6 +17207,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',
@@ -17001,6 +17433,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}.
  *
@@ -17022,7 +17458,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)
@@ -17965,7 +18401,7 @@ const bridgeDepositPrepareReviewSchema = z.object({
 }
 
 var name$1 = "@circle-fin/provider-earn-service";
-var version$1 = "1.7.1";
+var version$1 = "1.7.2";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -19226,7 +19662,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)) {
@@ -22585,7 +23021,7 @@ registerKit(`${pkg$2.name}/${pkg$2.version}`);
 };
 
 var name = "@circle-fin/borrow-kit";
-var version = "1.0.0";
+var version = "1.1.0";
 var pkg = {
 	name: name,
 	version: version};