@circle-fin/app-kit 1.8.0 → 1.9.0

package/index.cjs

@@ -24,6 +24,7 @@ var units = require('@ethersproject/units');
 var bytes = require('@ethersproject/bytes');
 var address = require('@ethersproject/address');
 var bs58 = require('bs58');
+require('@ethersproject/abi');
 var web3_js = require('@solana/web3.js');
 require('bn.js');
 require('@coral-xyz/anchor');
@@ -3558,7 +3559,7 @@ class KitError extends Error {
  *
  * Error code ranges:
  * - 1100-1105: INPUT errors — invalid inputs, unsupported configurations
- * - 8100-8104: SERVICE errors — retryable backend/provider failures
+ * - 8100-8105: SERVICE errors — retryable backend/provider failures
  *
  * @example
  * ```typescript
@@ -3634,6 +3635,11 @@ class KitError extends Error {
         code: 8104,
         name: 'EARN_PAUSED',
         type: 'SERVICE'
+    },
+    /** Position PnL is still reconciling and can be retried. */ POSITION_PNL_PENDING: {
+        code: 8105,
+        name: 'EARN_POSITION_PNL_PENDING',
+        type: 'SERVICE'
     }
 };
 
@@ -3657,11 +3663,11 @@ function getOptionalString(value) {
  * - vault-not-found, unsupported-chain, unsupported-vault,
  *   signature-rejected, invalid-id, invalid-batch-size, position-not-registered,
  *   withdrawal-max-exceeded, insufficient-balance, bridge prepare idempotency
- *   conflicts
+ *   conflicts, invalid vault-asset amount precision
  *
  * SERVICE errors (RETRYABLE) — try again later:
  * - signing-failed, provider-error, rewards-fetch-failed,
- *   internal-error, vault-refresh-busy, off-chain-paused,
+ *   internal-error, vault-refresh-busy, off-chain-paused, position-PnL-pending,
  *   bridge failures/status lookup failures
  *
  * Unrecognized codes fall through to `parseApiError` for HTTP-status-based
@@ -3841,6 +3847,20 @@ function getOptionalString(value) {
             recoverability: 'RETRYABLE'
         }
     ],
+    [
+        380415,
+        {
+            errorDef: EarnError.INVALID_INPUT,
+            recoverability: 'FATAL'
+        }
+    ],
+    [
+        380416,
+        {
+            errorDef: EarnError.POSITION_PNL_PENDING,
+            recoverability: 'RETRYABLE'
+        }
+    ],
     // Bridge (380_5XX)
     [
         380500,
@@ -3876,6 +3896,13 @@ function getOptionalString(value) {
             errorDef: EarnError.PROVIDER_ERROR,
             recoverability: 'RETRYABLE'
         }
+    ],
+    [
+        380505,
+        {
+            errorDef: EarnError.PROVIDER_ERROR,
+            recoverability: 'FATAL'
+        }
     ]
 ]);
 /**
@@ -3978,6 +4005,8 @@ function getOptionalString(value) {
     Blockchain["Celo_Alfajores_Testnet"] = "Celo_Alfajores_Testnet";
     Blockchain["Codex"] = "Codex";
     Blockchain["Codex_Testnet"] = "Codex_Testnet";
+    Blockchain["Cronos"] = "Cronos";
+    Blockchain["Cronos_Testnet"] = "Cronos_Testnet";
     Blockchain["Edge"] = "Edge";
     Blockchain["Edge_Testnet"] = "Edge_Testnet";
     Blockchain["Ethereum"] = "Ethereum";
@@ -4060,6 +4089,7 @@ exports.BridgeChain = void 0;
     BridgeChain["Avalanche"] = "Avalanche";
     BridgeChain["Base"] = "Base";
     BridgeChain["Codex"] = "Codex";
+    BridgeChain["Cronos"] = "Cronos";
     BridgeChain["Edge"] = "Edge";
     BridgeChain["Ethereum"] = "Ethereum";
     BridgeChain["HyperEVM"] = "HyperEVM";
@@ -4084,6 +4114,7 @@ exports.BridgeChain = void 0;
     BridgeChain["Avalanche_Fuji"] = "Avalanche_Fuji";
     BridgeChain["Base_Sepolia"] = "Base_Sepolia";
     BridgeChain["Codex_Testnet"] = "Codex_Testnet";
+    BridgeChain["Cronos_Testnet"] = "Cronos_Testnet";
     BridgeChain["Edge_Testnet"] = "Edge_Testnet";
     BridgeChain["Ethereum_Sepolia"] = "Ethereum_Sepolia";
     BridgeChain["HyperEVM_Testnet"] = "HyperEVM_Testnet";
@@ -4335,23 +4366,6 @@ exports.EarnChain = void 0;
     }
 });
 
-/**
- * Standard decimal places for tokens.
- *
- * These constants define the decimal precision used by different token types
- * across the SDK. They are used for amount conversions between human-readable
- * format and smallest units (base units).
- *
- * @remarks
- * - Most stablecoins (USDC, EURC, USDT, PYUSD) use 6 decimal places
- * - Some stablecoins (DAI, USDE) and most native tokens (ETH, POL, PLUME) use 18 decimals
- * - The NATIVE alias uses chain-specific decimals which may vary (e.g., SOL uses 9)
- */ /**
- * Standard decimal places for 6-decimal tokens.
- *
- * Used by most stablecoins: USDC, EURC, USDT, PYUSD
- */ const TOKEN_DECIMALS_6 = 6;
-
 /**
  * @packageDocumentation
  * @module SwapTokenRegistry
@@ -5167,6 +5181,96 @@ exports.EarnChain = void 0;
     }
 });
 
+/**
+ * Cronos Mainnet chain definition
+ * @remarks
+ * This represents the official production network for the Cronos blockchain.
+ * Cronos is an EVM-compatible blockchain.
+ */ const Cronos = defineChain({
+    type: 'evm',
+    chain: exports.Blockchain.Cronos,
+    name: 'Cronos',
+    title: 'Cronos Mainnet',
+    nativeCurrency: {
+        name: 'Cronos',
+        symbol: 'CRO',
+        decimals: 18
+    },
+    chainId: 25,
+    isTestnet: false,
+    explorerUrl: 'https://cronoscan.com/tx/{hash}',
+    rpcEndpoints: [
+        'https://evm.cronos.org'
+    ],
+    eurcAddress: '0xA6dE01a2d62C6B5f3525d768f34d276652C554c8',
+    usdcAddress: '0x3D7F2C478aAfdB65542BCB44bCeeC05849999d2D',
+    usdtAddress: null,
+    cctp: {
+        domain: 32,
+        contracts: {
+            v2: {
+                type: 'split',
+                tokenMessenger: '0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d',
+                messageTransmitter: '0x81D40F21F12A8F0E3252Bccb954D722d4c464B64',
+                confirmations: 1,
+                fastConfirmations: 1
+            }
+        },
+        forwarderSupported: {
+            source: false,
+            destination: false
+        }
+    },
+    kitContracts: {
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+    }
+});
+
+/**
+ * Cronos Testnet chain definition
+ * @remarks
+ * This represents the official test network for the Cronos blockchain.
+ * Cronos is an EVM-compatible blockchain.
+ */ const CronosTestnet = defineChain({
+    type: 'evm',
+    chain: exports.Blockchain.Cronos_Testnet,
+    name: 'Cronos Testnet',
+    title: 'Cronos Testnet',
+    nativeCurrency: {
+        name: 'CRO',
+        symbol: 'tCRO',
+        decimals: 18
+    },
+    chainId: 338,
+    isTestnet: true,
+    explorerUrl: 'https://explorer.cronos.org/testnet/tx/{hash}',
+    rpcEndpoints: [
+        'https://evm-t3.cronos.org'
+    ],
+    eurcAddress: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46',
+    usdcAddress: '0xEb33dc5fac03833e132593659e1dE7256aB59794',
+    usdtAddress: null,
+    cctp: {
+        domain: 32,
+        contracts: {
+            v2: {
+                type: 'split',
+                tokenMessenger: '0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA',
+                messageTransmitter: '0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275',
+                confirmations: 1,
+                fastConfirmations: 1
+            }
+        },
+        forwarderSupported: {
+            source: false,
+            destination: false
+        }
+    },
+    kitContracts: {
+        bridge: BRIDGE_CONTRACT_EVM_TESTNET
+    }
+});
+
 /**
  * Edge Mainnet chain definition
  * @remarks
@@ -7518,6 +7622,8 @@ var Chains = {
   CeloAlfajoresTestnet: CeloAlfajoresTestnet,
   Codex: Codex,
   CodexTestnet: CodexTestnet,
+  Cronos: Cronos,
+  CronosTestnet: CronosTestnet,
   Edge: Edge,
   EdgeTestnet: EdgeTestnet,
   Ethereum: Ethereum,
@@ -9892,6 +9998,7 @@ function parseOrThrow(value, schema, context) {
         [exports.Blockchain.Base]: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
         [exports.Blockchain.Celo]: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
         [exports.Blockchain.Codex]: '0xd996633a415985DBd7D6D12f4A4343E31f5037cf',
+        [exports.Blockchain.Cronos]: '0x3D7F2C478aAfdB65542BCB44bCeeC05849999d2D',
         [exports.Blockchain.Edge]: '0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c',
         [exports.Blockchain.Ethereum]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
         [exports.Blockchain.Hedera]: '0.0.456858',
@@ -9925,6 +10032,7 @@ function parseOrThrow(value, schema, context) {
         [exports.Blockchain.Avalanche_Fuji]: '0x5425890298aed601595a70AB815c96711a31Bc65',
         [exports.Blockchain.Base_Sepolia]: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
         [exports.Blockchain.Codex_Testnet]: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f',
+        [exports.Blockchain.Cronos_Testnet]: '0xEb33dc5fac03833e132593659e1dE7256aB59794',
         [exports.Blockchain.Edge_Testnet]: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B',
         [exports.Blockchain.Ethereum_Sepolia]: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
         [exports.Blockchain.Hedera_Testnet]: '0.0.429274',
@@ -9992,13 +10100,22 @@ function parseOrThrow(value, schema, context) {
     symbol: 'EURC',
     decimals: 6,
     locators: {
+        // =========================================================================
+        // Mainnets
+        // =========================================================================
         [exports.Blockchain.Avalanche]: '0xc891EB4cbdEFf6e073e859e987815Ed1505c2ACD',
         [exports.Blockchain.Base]: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+        [exports.Blockchain.Cronos]: '0xA6dE01a2d62C6B5f3525d768f34d276652C554c8',
         [exports.Blockchain.Ethereum]: '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
         [exports.Blockchain.Solana]: 'HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr',
         [exports.Blockchain.World_Chain]: '0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B',
+        // =========================================================================
         // Testnets
-        [exports.Blockchain.Arc_Testnet]: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a'
+        // =========================================================================
+        [exports.Blockchain.Arc_Testnet]: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
+        [exports.Blockchain.Base_Sepolia]: '0x808456652fdb597867f38412077A9182bf77359F',
+        [exports.Blockchain.Cronos_Testnet]: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46',
+        [exports.Blockchain.Ethereum_Sepolia]: '0x08210F9170F89Ab7658F0B5E3fF39b0E03C594D4'
     }
 };
 
@@ -10208,8 +10325,7 @@ function parseOrThrow(value, schema, context) {
  * cirBTC (Circle Bitcoin) token definition with addresses and metadata.
  *
  * @remarks
- * Built-in cirBTC definition for the TokenRegistry. Currently deployed
- * on Arc Testnet.
+ * Built-in cirBTC definition for the TokenRegistry.
  *
  * @example
  * ```typescript
@@ -10225,7 +10341,15 @@ function parseOrThrow(value, schema, context) {
     symbol: 'cirBTC',
     decimals: 8,
     locators: {
-        [exports.Blockchain.Arc_Testnet]: '0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF'
+        // =========================================================================
+        // Mainnets
+        // =========================================================================
+        [exports.Blockchain.Ethereum]: '0x72DFB2E44f59C5AD2bAFE84314E5b99a7cd5075E',
+        // =========================================================================
+        // Testnets
+        // =========================================================================
+        [exports.Blockchain.Arc_Testnet]: '0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF',
+        [exports.Blockchain.Ethereum_Sepolia]: '0x3a3fe695F684Bf9b9e43CF43C2b895Ea5e392bB3'
     }
 };
 
@@ -11505,11 +11629,11 @@ function resolveOptions(options) {
     void emitAnalyticsLog(buildPayload$1(config, stepEntry?.[1] ?? fallbackEventType, errorDetails, context));
 }
 
-var name$3 = "@circle-fin/bridge-kit";
-var version$4 = "1.11.0";
-var pkg$4 = {
-	name: name$3,
-	version: version$4};
+var name$4 = "@circle-fin/bridge-kit";
+var version$5 = "1.12.0";
+var pkg$5 = {
+	name: name$4,
+	version: version$5};
 
 const assertCustomFeePolicySymbol$2 = Symbol('assertCustomFeePolicy');
 /**
@@ -13535,7 +13659,7 @@ exports.TransferSpeed = void 0;
     const bridgeKitCaller = {
         type: 'kit',
         name: 'BridgeKit',
-        version: pkg$4.version
+        version: pkg$5.version
     };
     // Create default runtime and tokens for invocation context resolution
     const defaults = {
@@ -14205,6 +14329,15 @@ const CUSTOM_BURN_GAS_ESTIMATE_EVM = 201_525n // p99 and max are same here: 201_
 ;
 const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_839n) / 2 = 237_401n
 ;
+// Hard execution caps: observed max + ~30% buffer, used as gasLimit overrides on
+// chains whose eth_estimateGas under-reports (e.g. Cronos EIP-7623 calldata floor).
+// Kept separate from the fee-estimate averages above.
+const APPROVE_GAS_LIMIT_EVM = 100_000n // ERC-20 approve observed max ~46k
+;
+const DEPOSIT_FOR_BURN_GAS_LIMIT_EVM = 300_000n // observed max 226_506 + ~30%
+;
+const RECEIVE_MESSAGE_GAS_LIMIT_EVM = 400_000n // observed max 310_839 + ~30%
+;
 /**
  * The minimum finality threshold for CCTPv2 transfers.
  *
@@ -14233,6 +14366,27 @@ const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_8
         'Content-Type': 'application/json'
     }
 };
+/**
+ * Merges caller-provided polling overrides on top of {@link DEFAULT_CONFIG}.
+ *
+ * Headers are merged independently so caller-supplied headers augment the
+ * defaults (such as `Content-Type`) rather than replacing them wholesale.
+ *
+ * @param config - Caller-provided polling configuration overrides
+ * @param internalDefaults - Internal defaults applied before `config` (for example a
+ *   reduced `maxRetries` for one-shot requests); `config` still wins on conflict
+ * @returns The effective polling configuration
+ * @internal
+ */ const mergeAttestationConfig = (config, internalDefaults = {})=>({
+        ...DEFAULT_CONFIG$2,
+        ...internalDefaults,
+        ...config,
+        headers: {
+            ...DEFAULT_CONFIG$2.headers,
+            ...internalDefaults.headers,
+            ...config.headers
+        }
+    });
 /**
  * Type guard that verifies if an unknown value matches the AttestationMessage shape
  * and has all required properties.
@@ -14379,10 +14533,7 @@ const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_8
  * ```
  */ const fetchAttestation = async (sourceDomainId, transactionHash, isTestnet, config = {})=>{
     const url = buildIrisUrl(sourceDomainId, transactionHash, isTestnet);
-    const effectiveConfig = {
-        ...DEFAULT_CONFIG$2,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config);
     return await pollApiGet(url, isAttestationResponse, effectiveConfig);
 };
 /**
@@ -14425,11 +14576,9 @@ const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_8
  */ const fetchAttestationWithoutStatusCheck = async (sourceDomainId, transactionHash, isTestnet, config = {})=>{
     const url = buildIrisUrl(sourceDomainId, transactionHash, isTestnet);
     // Use minimal retries since we're just fetching existing data
-    const effectiveConfig = {
-        ...DEFAULT_CONFIG$2,
-        maxRetries: 3,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config, {
+        maxRetries: 3
+    });
     return await pollApiGet(url, isAttestationResponseWithoutStatusCheck, effectiveConfig);
 };
 /**
@@ -14489,10 +14638,7 @@ const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_8
  * ```
  */ const fetchReAttestedAttestation = async (sourceDomainId, transactionHash, isTestnet, config = {})=>{
     const url = buildIrisUrl(sourceDomainId, transactionHash, isTestnet);
-    const effectiveConfig = {
-        ...DEFAULT_CONFIG$2,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config);
     return await pollApiGet(url, isReAttestedAttestationResponse, effectiveConfig);
 };
 /**
@@ -14558,14 +14704,139 @@ const RECEIVE_MESSAGE_GAS_ESTIMATE_EVM = 237_401n // (99p: 163_963n + max: 310_8
  */ const requestReAttestation = async (nonce, isTestnet, config = {})=>{
     const url = buildReAttestUrl(nonce, isTestnet);
     // Use minimal retries since we're just submitting a request, not polling for state
-    const effectiveConfig = {
-        ...DEFAULT_CONFIG$2,
-        maxRetries: 3,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config, {
+        maxRetries: 3
+    });
     return await pollApiPost(url, {}, isReAttestationResponse, effectiveConfig);
 };
 
+/**
+ * Type guard that checks if the relayer has confirmed the mint transaction.
+ *
+ * This function validates that:
+ * 1. The response has valid AttestationResponse structure
+ * 2. At least one message has forwardState === 'CONFIRMED' (or 'COMPLETE') and a valid forwardTxHash
+ *
+ * If forwardState is 'FAILED', throws a non-retryable KitError.
+ * If forwardState is 'PENDING' or not present, throws a RETRYABLE KitError to continue polling.
+ *
+ * @param obj - The value to check, typically a parsed JSON response
+ * @returns True if the relayer has confirmed the mint
+ * @throws {KitError} With FATAL recoverability if structure is invalid
+ * @throws {KitError} With RESUMABLE recoverability if forwardState is 'FAILED'
+ * @throws {KitError} With RETRYABLE recoverability if still pending
+ * @internal
+ */ const isRelayerMintConfirmed = (obj)=>{
+    // First check if the structure is valid
+    if (!hasValidAttestationStructure(obj)) {
+        throw new KitError({
+            ...InputError.VALIDATION_FAILED,
+            recoverability: 'FATAL',
+            message: 'Invalid attestation response structure from IRIS API.'
+        });
+    }
+    // Find the first message (typically there's only one)
+    const message = obj.messages[0];
+    if (!message) {
+        throw new KitError({
+            ...InputError.VALIDATION_FAILED,
+            recoverability: 'FATAL',
+            message: 'No attestation messages found in IRIS API response.'
+        });
+    }
+    // Check for FAILED state - this is a permanent failure
+    if (message.forwardState === 'FAILED') {
+        throw new KitError({
+            ...NetworkError.RELAYER_FORWARD_FAILED,
+            recoverability: 'RESUMABLE',
+            message: 'Circle relayer failed to forward the mint transaction. The mint may still have succeeded if another party submitted it. Check the recipient wallet balance before retrying. If the mint did not occur, you can manually submit it using the attestation data in the error cause.',
+            cause: {
+                trace: {
+                    eventNonce: message.eventNonce,
+                    attestation: message.attestation,
+                    message: message.message
+                }
+            }
+        });
+    }
+    // Check if mint is confirmed (or complete) with a valid transaction hash
+    // We accept both CONFIRMED and COMPLETE since COMPLETE implies CONFIRMED
+    if ((message.forwardState === 'CONFIRMED' || message.forwardState === 'COMPLETE') && typeof message.forwardTxHash === 'string' && message.forwardTxHash.trim().length > 0) {
+        return true;
+    }
+    // Still pending or not yet processed - throw RETRYABLE error to continue polling
+    throw new KitError({
+        ...NetworkError.RELAYER_PENDING,
+        recoverability: 'RETRYABLE',
+        message: 'Relayer mint not ready. Waiting for confirmation.'
+    });
+};
+/**
+ * Polls the attestation API until the relayer's mint transaction is confirmed.
+ *
+ * This function is used when `useForwarder` is enabled. Instead of the user
+ * submitting the mint transaction, Circle's Orbit relayer handles it automatically.
+ * This function polls until the relayer has submitted and confirmed the mint transaction.
+ *
+ * @remarks
+ * - Uses a 20-minute timeout by default (600 retries × 2 seconds)
+ * - Throws immediately if `forwardState` is 'FAILED'
+ * - Waits for `forwardState` to be 'CONFIRMED' or 'COMPLETE' (COMPLETE implies CONFIRMED)
+ * - Returns the attestation message with `forwardTxHash` populated
+ *
+ * @param sourceDomainId - The CCTP domain ID of the source chain
+ * @param transactionHash - The transaction hash of the burn operation
+ * @param isTestnet - Whether this is for a testnet chain (true) or mainnet (false)
+ * @param config - Optional configuration overrides for polling behavior
+ * @returns The attestation message with confirmed forwardTxHash
+ * @throws {KitError} With code 'NETWORK_RELAYER_FORWARD_FAILED' if relayer failed
+ * @throws {KitError} If timeout is reached while still pending
+ *
+ * @example
+ * ```typescript
+ * const attestation = await fetchRelayerMint(0, '0xabc...', false)
+ * console.log('Relayer mint tx:', attestation.forwardTxHash)
+ * ```
+ */ const fetchRelayerMint = async (sourceDomainId, transactionHash, isTestnet, config = {})=>{
+    const url = buildIrisUrl(sourceDomainId, transactionHash, isTestnet);
+    const effectiveConfig = mergeAttestationConfig(config);
+    let response;
+    try {
+        response = await pollApiGet(url, isRelayerMintConfirmed, effectiveConfig);
+    } catch (error) {
+        // Enrich RELAYER_FORWARD_FAILED errors with the burn transaction hash
+        if (error instanceof KitError && error.name === 'NETWORK_RELAYER_FORWARD_FAILED') {
+            throw new KitError({
+                ...NetworkError.RELAYER_FORWARD_FAILED,
+                recoverability: error.recoverability,
+                message: error.message,
+                cause: {
+                    ...error.cause,
+                    trace: {
+                        ...error.cause?.trace,
+                        burnTxHash: transactionHash
+                    }
+                }
+            });
+        }
+        throw error;
+    }
+    // Return the first message (which should have forwardTxHash)
+    // Note: This check is needed for TypeScript type safety even though
+    // isRelayerMintConfirmed validates messages[0] exists. The type guard
+    // narrows the type at the call site, but TypeScript can't infer that
+    // the array still has elements after pollApiGet returns.
+    const message = response.messages[0];
+    if (!message) {
+        throw new KitError({
+            ...InputError.VALIDATION_FAILED,
+            recoverability: 'FATAL',
+            message: 'No attestation messages found in response after polling.'
+        });
+    }
+    return message;
+};
+
 const assertCCTPv2WalletContextSymbol = Symbol('assertCCTPv2WalletContext');
 /**
  * Asserts that the provided parameters match the CCTPv2 wallet context interface.
@@ -15440,6 +15711,8 @@ function hasPendingState(analysis, result) {
  *   - `adapter`: The adapter that will execute the transaction
  *   - `confirmations`: The number of confirmations to wait for (defaults to 1)
  *   - `timeout`: The timeout for the request in milliseconds
+ *   - `gasLimit`: Optional explicit gas limit (number) forwarded to EVM execute,
+ *     bypassing `eth_estimateGas`; ignored for non-EVM requests
  * @returns The bridge step with the transaction details and explorer URL
  * @throws If the transaction execution fails
  *
@@ -15454,7 +15727,7 @@ function hasPendingState(analysis, result) {
  * })
  * console.log('Transaction hash:', step.txHash)
  * ```
- */ async function executePreparedChainRequest({ name, request, adapter, chain, confirmations = 1, timeout }) {
+ */ async function executePreparedChainRequest({ name, request, adapter, chain, confirmations = 1, timeout, gasLimit }) {
     const step = {
         name,
         state: 'pending'
@@ -15467,7 +15740,9 @@ function hasPendingState(analysis, result) {
             step.state = 'noop';
             return step;
         }
-        const txHash = await request.execute();
+        const txHash = request.type === 'evm' && gasLimit !== undefined ? await request.execute({
+            gasLimit
+        }) : await request.execute();
         step.txHash = txHash;
         const retryOptions = {
             isRetryable: (err)=>isRetryableError$1(parseBlockchainError(err, {
@@ -15539,7 +15814,8 @@ function hasPendingState(analysis, result) {
         name: 'approve',
         adapter: params.source.adapter,
         chain: params.source.chain,
-        request: await provider.approve(params.source, approvalAmount)
+        request: await provider.approve(params.source, approvalAmount),
+        gasLimit: Number(APPROVE_GAS_LIMIT_EVM)
     });
 }
 
@@ -15566,7 +15842,8 @@ function hasPendingState(analysis, result) {
         name: 'burn',
         adapter: params.source.adapter,
         chain: params.source.chain,
-        request: await provider.burn(params)
+        request: await provider.burn(params),
+        gasLimit: Number(DEPOSIT_FOR_BURN_GAS_LIMIT_EVM)
     });
 }
 
@@ -15652,11 +15929,18 @@ function hasPendingState(analysis, result) {
  */ async function bridgeMint({ params, provider }, attestation) {
     // Validate attestation message matches transfer params
     await assertCCTPv2AttestationParams(attestation, params);
+    const mintRequest = await provider.mint(params.source, params.destination, attestation);
     const step = await executePreparedChainRequest({
         name: 'mint',
         adapter: params.destination.adapter,
         chain: params.destination.chain,
-        request: await provider.mint(params.source, params.destination, attestation)
+        request: mintRequest,
+        // Some chains (e.g. Cronos) enforce an EIP-7623 calldata gas floor that
+        // eth_estimateGas does not account for, returning a below-floor value
+        // without reverting. Pinning to a value above the observed execution max
+        // (310_839) bypasses re-estimation and guarantees we clear both the floor
+        // and the actual execution cost.
+        gasLimit: Number(RECEIVE_MESSAGE_GAS_LIMIT_EVM)
     });
     // Add forwarded: false for non-relayer mints
     return {
@@ -15694,136 +15978,6 @@ const mockAttestationMessage = {
     delayReason: null
 };
 
-/**
- * Type guard that checks if the relayer has confirmed the mint transaction.
- *
- * This function validates that:
- * 1. The response has valid AttestationResponse structure
- * 2. At least one message has forwardState === 'CONFIRMED' (or 'COMPLETE') and a valid forwardTxHash
- *
- * If forwardState is 'FAILED', throws a non-retryable KitError.
- * If forwardState is 'PENDING' or not present, throws a RETRYABLE KitError to continue polling.
- *
- * @param obj - The value to check, typically a parsed JSON response
- * @returns True if the relayer has confirmed the mint
- * @throws {KitError} With FATAL recoverability if structure is invalid
- * @throws {KitError} With RESUMABLE recoverability if forwardState is 'FAILED'
- * @throws {KitError} With RETRYABLE recoverability if still pending
- * @internal
- */ const isRelayerMintConfirmed = (obj)=>{
-    // First check if the structure is valid
-    if (!hasValidAttestationStructure(obj)) {
-        throw new KitError({
-            ...InputError.VALIDATION_FAILED,
-            recoverability: 'FATAL',
-            message: 'Invalid attestation response structure from IRIS API.'
-        });
-    }
-    // Find the first message (typically there's only one)
-    const message = obj.messages[0];
-    if (!message) {
-        throw new KitError({
-            ...InputError.VALIDATION_FAILED,
-            recoverability: 'FATAL',
-            message: 'No attestation messages found in IRIS API response.'
-        });
-    }
-    // Check for FAILED state - this is a permanent failure
-    if (message.forwardState === 'FAILED') {
-        throw new KitError({
-            ...NetworkError.RELAYER_FORWARD_FAILED,
-            recoverability: 'RESUMABLE',
-            message: 'Circle relayer failed to forward the mint transaction. The mint may still have succeeded if another party submitted it. Check the recipient wallet balance before retrying. If the mint did not occur, you can manually submit it using the attestation data in the error cause.',
-            cause: {
-                trace: {
-                    eventNonce: message.eventNonce,
-                    attestation: message.attestation,
-                    message: message.message
-                }
-            }
-        });
-    }
-    // Check if mint is confirmed (or complete) with a valid transaction hash
-    // We accept both CONFIRMED and COMPLETE since COMPLETE implies CONFIRMED
-    if ((message.forwardState === 'CONFIRMED' || message.forwardState === 'COMPLETE') && typeof message.forwardTxHash === 'string' && message.forwardTxHash.trim().length > 0) {
-        return true;
-    }
-    // Still pending or not yet processed - throw RETRYABLE error to continue polling
-    throw new KitError({
-        ...NetworkError.RELAYER_PENDING,
-        recoverability: 'RETRYABLE',
-        message: 'Relayer mint not ready. Waiting for confirmation.'
-    });
-};
-/**
- * Polls the attestation API until the relayer's mint transaction is confirmed.
- *
- * This function is used when `useForwarder` is enabled. Instead of the user
- * submitting the mint transaction, Circle's Orbit relayer handles it automatically.
- * This function polls until the relayer has submitted and confirmed the mint transaction.
- *
- * @remarks
- * - Uses a 20-minute timeout by default (600 retries × 2 seconds)
- * - Throws immediately if `forwardState` is 'FAILED'
- * - Waits for `forwardState` to be 'CONFIRMED' or 'COMPLETE' (COMPLETE implies CONFIRMED)
- * - Returns the attestation message with `forwardTxHash` populated
- *
- * @param sourceDomainId - The CCTP domain ID of the source chain
- * @param transactionHash - The transaction hash of the burn operation
- * @param isTestnet - Whether this is for a testnet chain (true) or mainnet (false)
- * @param config - Optional configuration overrides for polling behavior
- * @returns The attestation message with confirmed forwardTxHash
- * @throws {KitError} With code 'NETWORK_RELAYER_FORWARD_FAILED' if relayer failed
- * @throws {KitError} If timeout is reached while still pending
- *
- * @example
- * ```typescript
- * const attestation = await fetchRelayerMint(0, '0xabc...', false)
- * console.log('Relayer mint tx:', attestation.forwardTxHash)
- * ```
- */ const fetchRelayerMint = async (sourceDomainId, transactionHash, isTestnet, config = {})=>{
-    const url = buildIrisUrl(sourceDomainId, transactionHash, isTestnet);
-    const effectiveConfig = {
-        ...DEFAULT_CONFIG$2,
-        ...config
-    };
-    let response;
-    try {
-        response = await pollApiGet(url, isRelayerMintConfirmed, effectiveConfig);
-    } catch (error) {
-        // Enrich RELAYER_FORWARD_FAILED errors with the burn transaction hash
-        if (error instanceof KitError && error.name === 'NETWORK_RELAYER_FORWARD_FAILED') {
-            throw new KitError({
-                ...NetworkError.RELAYER_FORWARD_FAILED,
-                recoverability: error.recoverability,
-                message: error.message,
-                cause: {
-                    ...error.cause,
-                    trace: {
-                        ...error.cause?.trace,
-                        burnTxHash: transactionHash
-                    }
-                }
-            });
-        }
-        throw error;
-    }
-    // Return the first message (which should have forwardTxHash)
-    // Note: This check is needed for TypeScript type safety even though
-    // isRelayerMintConfirmed validates messages[0] exists. The type guard
-    // narrows the type at the call site, but TypeScript can't infer that
-    // the array still has elements after pollApiGet returns.
-    const message = response.messages[0];
-    if (!message) {
-        throw new KitError({
-            ...InputError.VALIDATION_FAILED,
-            recoverability: 'FATAL',
-            message: 'No attestation messages found in response after polling.'
-        });
-    }
-    return message;
-};
-
 /**
  * Executes the mint step for forwarding mode where Circle's relayer handles the mint.
  *
@@ -15837,6 +15991,7 @@ const mockAttestationMessage = {
  * immediately after the API confirms the mint.
  *
  * @param params - The bridge parameters containing source, destination, amount and config
+ * @param provider - The CCTP v2 bridging provider
  * @param context - The step context containing burnTxHash from the burn step
  * @returns Promise resolving to the bridge step with transaction details
  * @throws {KitError} If burnTxHash is not available in context
@@ -15845,10 +16000,13 @@ const mockAttestationMessage = {
  *
  * @example
  * ```typescript
- * const step = await bridgeRelayerMint(params, { burnTxHash: '0x...' })
+ * const step = await bridgeRelayerMint(
+ *   { params, provider },
+ *   { burnTxHash: '0x...' }
+ * )
  * console.log('Relayer mint tx:', step.txHash)
  * ```
- */ async function bridgeRelayerMint(params, context) {
+ */ async function bridgeRelayerMint({ params, provider }, context) {
     const step = {
         name: 'mint',
         state: 'pending',
@@ -15864,7 +16022,7 @@ const mockAttestationMessage = {
     }
     try {
         // Poll attestation API until relayer confirms the mint
-        const attestation = await fetchRelayerMint(params.source.chain.cctp.domain, context.burnTxHash, params.source.chain.isTestnet ?? false);
+        const attestation = await provider.fetchRelayerMint(params.source, context.burnTxHash);
         // Extract the relayer's mint transaction hash
         const forwardTxHash = attestation.forwardTxHash;
         if (!forwardTxHash) {
@@ -15958,7 +16116,7 @@ const mockAttestationMessage = {
             name: 'mint',
             // bridgeRelayerMint validates context.burnTxHash internally with a KitError
             // bridgeMint requires attestationData which is validated here
-            executor: useForwarder ? async (params, _provider, context)=>{
+            executor: useForwarder ? async (params, provider, context)=>{
                 if (!context) {
                     throw new KitError({
                         ...InputError.VALIDATION_FAILED,
@@ -15966,7 +16124,10 @@ const mockAttestationMessage = {
                         message: 'Step context is required for relayer mint'
                     });
                 }
-                return bridgeRelayerMint(params, context);
+                return bridgeRelayerMint({
+                    params,
+                    provider
+                }, context);
             } : async (params, provider, context)=>{
                 if (!context?.attestationData) {
                     throw new KitError({
@@ -16297,16 +16458,16 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$3 = "1.8.4";
-var pkg$3 = {
-	version: version$3};
+var version$4 = "1.9.0";
+var pkg$4 = {
+	version: version$4};
 
 /**
  * Provider caller component for bridge operations.
  */ const BRIDGE_CALLER = {
     type: 'provider',
     name: 'CCTPV2BridgingProvider.bridge',
-    version: pkg$3.version
+    version: pkg$4.version
 };
 /**
  * Resolve invocation context for bridge operations.
@@ -16679,7 +16840,7 @@ var pkg$3 = {
  */ const RETRY_CALLER = {
     type: 'provider',
     name: 'CCTPV2BridgingProvider.retry',
-    version: pkg$3.version
+    version: pkg$4.version
 };
 /**
  * Resolve invocation context for retry operations.
@@ -17003,6 +17164,39 @@ var pkg$3 = {
     }
 }
 
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertHeadersConfig(headers, field) {
+    if (headers === undefined) {
+        return;
+    }
+    if (!isPlainObject(headers)) {
+        throw createValidationFailedError$1(field, headers, `${field} must be a plain object with string header values when provided`);
+    }
+    for (const [name, value] of Object.entries(headers)){
+        if (typeof value !== 'string') {
+            throw createValidationFailedError$1(`${field}.${name}`, value, 'header values must be strings');
+        }
+    }
+}
+function assertCCTPV2Config(config) {
+    if (!isPlainObject(config)) {
+        throw createValidationFailedError$1('config', config, 'config must be a plain object when provided');
+    }
+    assertHeadersConfig(config['headers'], 'config.headers');
+    const attestation = config['attestation'];
+    if (attestation !== undefined) {
+        if (!isPlainObject(attestation)) {
+            throw createValidationFailedError$1('config.attestation', attestation, 'config.attestation must be a plain object when provided');
+        }
+        assertHeadersConfig(attestation['headers'], 'config.attestation.headers');
+    }
+}
 /**
  * All chains that are supported by the CCTP v2 provider.
  *
@@ -17071,9 +17265,38 @@ var pkg$3 = {
    * @param config - Optional configuration overrides for the provider
    */ constructor(config = {}){
         super();
+        assertCCTPV2Config(config);
         this.config = config;
     }
     /**
+   * Resolves the effective polling configuration for an attestation request.
+   *
+   * Precedence (lowest to highest): provider `config.attestation`, then the
+   * per-call `config`. Headers merge independently across
+   * `config.attestation.headers`, the provider-level `config.headers`, and any
+   * per-call `config.headers`, so a more specific header augments rather than
+   * replaces the broader ones. The `headers` key is omitted entirely when no
+   * headers are configured, leaving the attestation fetchers' defaults intact.
+   *
+   * @param config - Optional per-call polling configuration overrides
+   * @returns The merged polling configuration passed to the attestation fetchers
+   */ resolveAttestationConfig(config) {
+        const headers = {
+            ...this.config?.attestation?.headers,
+            ...this.config?.headers,
+            ...config?.headers
+        };
+        // Polling fields follow normal precedence; headers are merged separately
+        // below so narrower config layers augment rather than replace broader ones.
+        return {
+            ...this.config?.attestation,
+            ...config,
+            ...Object.keys(headers).length > 0 ? {
+                headers
+            } : {}
+        };
+    }
+    /**
    * Execute a cross-chain USDC bridge operation using the CCTP v2 protocol.
    *
    * This method orchestrates the complete CCTP v2 bridge flow including validation,
@@ -17499,11 +17722,7 @@ var pkg$3 = {
    */ async fetchAttestation(source, transactionHash, config) {
         assertCCTPv2WalletContext(source);
         try {
-            // Merge configs: defaults <- global config <- per-call config
-            const effectiveConfig = {
-                ...this.config?.attestation,
-                ...config
-            };
+            const effectiveConfig = this.resolveAttestationConfig(config);
             const response = await fetchAttestation(source.chain.cctp.domain, transactionHash, source.chain.isTestnet, effectiveConfig);
             const message = response.messages[0];
             if (!message) {
@@ -17520,6 +17739,49 @@ var pkg$3 = {
         }
     }
     /**
+   * Polls attestation data until Circle's relayer mint transaction is confirmed.
+   *
+   * This method is used by forwarded transfers. It polls the same Iris
+   * attestation endpoint as {@link CCTPV2BridgingProvider.fetchAttestation},
+   * but waits for a completed relayer forward state and returns the attestation
+   * message containing `forwardTxHash`.
+   *
+   * @typeParam TFromAdapterCapabilities - The type representing the capabilities of the source adapter
+   * @param source - The source wallet context containing the chain definition and wallet address
+   * @param transactionHash - The transaction hash of the burn operation
+   * @param config - Optional polling configuration overrides for timeout, retries, delay, and headers
+   * @returns A promise that resolves to the attestation message with `forwardTxHash`
+   * @throws KitError If the relayer forward fails, the response is invalid, or polling times out
+   *
+   * @example
+   * ```typescript
+   * import { CCTPV2BridgingProvider } from '@circle-fin/provider-cctp-v2'
+   * import { Chains } from '@core/chains'
+   *
+   * const provider = new CCTPV2BridgingProvider({
+   *   headers: { 'X-Partner-UUID': '00000000-0000-0000-0000-000000000000' },
+   * })
+   *
+   * const attestation = await provider.fetchRelayerMint(
+   *   {
+   *     adapter,
+   *     chain: Chains.EthereumSepolia,
+   *     address: '0x1234...',
+   *   },
+   *   '0xabc123...',
+   * )
+   *
+   * console.log('Relayer mint tx:', attestation.forwardTxHash)
+   * ```
+   */ async fetchRelayerMint(source, transactionHash, config) {
+        assertCCTPv2WalletContext(source);
+        if (typeof transactionHash !== 'string' || transactionHash.trim() === '') {
+            throw createValidationFailedError$1('transactionHash', transactionHash, 'transactionHash must be a non-empty string');
+        }
+        const effectiveConfig = this.resolveAttestationConfig(config);
+        return await fetchRelayerMint(source.chain.cctp.domain, transactionHash, source.chain.isTestnet, effectiveConfig);
+    }
+    /**
    * Requests a fresh attestation for an expired attestation.
    *
    * This method is used when the original attestation has expired before the mint
@@ -17573,11 +17835,7 @@ var pkg$3 = {
             throw new Error('Failed to re-attest: Invalid transaction hash');
         }
         try {
-            // Merge configs: defaults <- global config <- per-call config
-            const effectiveConfig = {
-                ...this.config?.attestation,
-                ...config
-            };
+            const effectiveConfig = this.resolveAttestationConfig(config);
             // Step 1: Get existing attestation data to extract nonce
             const existingAttestation = await fetchAttestationWithoutStatusCheck(source.chain.cctp.domain, transactionHash, source.chain.isTestnet, effectiveConfig);
             const nonce = existingAttestation.messages[0]?.eventNonce;
@@ -17862,8 +18120,13 @@ var pkg$3 = {
 /**
  * The default providers that will be used in addition to the providers provided
  * to the BridgeKit constructor.
- */ const getDefaultProviders$3 = ()=>[
-        new CCTPV2BridgingProvider()
+ *
+ * @param config - Optional configuration forwarded to the default providers
+ * @returns The default bridging providers
+ */ const getDefaultProviders$3 = (config = {})=>[
+        new CCTPV2BridgingProvider(config.headers ? {
+            headers: config.headers
+        } : {})
     ];
 
 /**
@@ -17974,7 +18237,7 @@ var pkg$3 = {
     ]
 ];
 
-/** SDK name used in telemetry payloads. */ const SDK_NAME$2 = resolveKitSdkName(pkg$4.name);
+/** SDK name used in telemetry payloads. */ const SDK_NAME$2 = resolveKitSdkName(pkg$5.name);
 /**
  * Pick the most-relevant `txHash` to attach to an error telemetry payload.
  *
@@ -18015,7 +18278,7 @@ var pkg$3 = {
  */ const BRIDGE_KIT_CALLER = {
     type: 'kit',
     name: 'BridgeKit',
-    version: pkg$4.version
+    version: pkg$5.version
 };
 /**
  * Merge BridgeKit's caller into the invocation metadata for retry operations.
@@ -18106,7 +18369,9 @@ var pkg$3 = {
    * ```
    */ constructor(config = {}){
         // Handle provider configuration
-        const defaultProviders = getDefaultProviders$3();
+        const defaultProviders = getDefaultProviders$3(config.headers ? {
+            headers: config.headers
+        } : {});
         this.providers = [
             ...defaultProviders,
             ...config.providers ?? []
@@ -18115,7 +18380,7 @@ var pkg$3 = {
         this.disableErrorReporting = config.disableErrorReporting === true;
         this.telemetryConfig = {
             sdkName: SDK_NAME$2,
-            sdkVersion: pkg$4.version,
+            sdkVersion: pkg$5.version,
             disabled: this.disableErrorReporting
         };
         for (const provider of this.providers){
@@ -18637,7 +18902,7 @@ var pkg$3 = {
 }
 
 // Auto-register this kit for user agent tracking
-registerKit(`${pkg$4.name}/${pkg$4.version}`);
+registerKit(`${pkg$5.name}/${pkg$5.version}`);
 
 /**
  * Create a BridgeKit instance with optional developer fee configuration.
@@ -18686,6 +18951,9 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
     const kit = new BridgeKit({
         ...context.disableErrorReporting != null && {
             disableErrorReporting: context.disableErrorReporting
+        },
+        ...context.headers != null && {
+            headers: context.headers
         }
     });
     if (hasBoth) {
@@ -18703,11 +18971,11 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
     return kit;
 };
 
-var name$2 = "@circle-fin/swap-kit";
-var version$2 = "1.3.0";
-var pkg$2 = {
-	name: name$2,
-	version: version$2};
+var name$3 = "@circle-fin/swap-kit";
+var version$3 = "1.3.2";
+var pkg$3 = {
+	name: name$3,
+	version: version$3};
 
 const chainIdentifierField = zod.z.custom((value)=>chainIdentifierSchema.safeParse(value).success, {
     message: 'chain must be a valid chain identifier'
@@ -23639,7 +23907,7 @@ function writeBytes32(buffer, hex, offset) {
     }
 }
 
-const TOKEN_REGISTRY$3 = createTokenRegistry();
+const TOKEN_REGISTRY$4 = createTokenRegistry();
 /**
  * Resolve token alias to contract address for the given chain.
  *
@@ -23728,7 +23996,7 @@ const TOKEN_REGISTRY$3 = createTokenRegistry();
             }
         });
     }
-    const tokenDefinition = TOKEN_REGISTRY$3.get(upperToken);
+    const tokenDefinition = TOKEN_REGISTRY$4.get(upperToken);
     if (tokenDefinition !== undefined) {
         const resolvedAddress = tokenDefinition.locators[chain.chain];
         if (!resolvedAddress) {
@@ -23745,7 +24013,7 @@ const TOKEN_REGISTRY$3 = createTokenRegistry();
                 }
             });
         }
-        return TOKEN_REGISTRY$3.resolve(upperToken, chain.chain).locator;
+        return TOKEN_REGISTRY$4.resolve(upperToken, chain.chain).locator;
     }
     // Not an alias - return as-is (assumed to be address)
     return token;
@@ -23842,11 +24110,11 @@ function resolveFeePayoutChain(tokenIn, tokenOut, sourceChain, destinationChain)
     if (destinationChain.chain !== sourceChain.chain) {
         return sourceChain;
     }
-    const inputIsOk = isOkToken(tokenIn, sourceChain, TOKEN_REGISTRY$3, OK_TOKEN_SYMBOLS$1);
+    const inputIsOk = isOkToken(tokenIn, sourceChain, TOKEN_REGISTRY$4, OK_TOKEN_SYMBOLS$1);
     if (inputIsOk) {
         return sourceChain;
     }
-    const outputIsOk = isOkToken(tokenOut, destinationChain, TOKEN_REGISTRY$3, OK_TOKEN_SYMBOLS$1);
+    const outputIsOk = isOkToken(tokenOut, destinationChain, TOKEN_REGISTRY$4, OK_TOKEN_SYMBOLS$1);
     return outputIsOk ? destinationChain : sourceChain;
 }
 /**
@@ -25137,7 +25405,7 @@ function resolveFeePayoutChain(tokenIn, tokenOut, sourceChain, destinationChain)
     }
 }
 
-const TOKEN_REGISTRY$2 = createTokenRegistry();
+const TOKEN_REGISTRY$3 = createTokenRegistry();
 /**
  * Resolve a token identifier to its canonical symbol for the Stablecoin Service Swap Provider.
  *
@@ -25181,7 +25449,7 @@ const TOKEN_REGISTRY$2 = createTokenRegistry();
         return NATIVE_TOKEN;
     }
     // For known registry aliases, return canonical symbol directly.
-    if (TOKEN_REGISTRY$2.get(upperToken) !== undefined) {
+    if (TOKEN_REGISTRY$3.get(upperToken) !== undefined) {
         return upperToken;
     }
     // For EVM chains, normalize addresses to lowercase for case-insensitive comparison.
@@ -25191,7 +25459,7 @@ const TOKEN_REGISTRY$2 = createTokenRegistry();
     // Native address is given
     if (isNativeEvmAddress(token) || isNativeSolanaAddress(token)) return NATIVE_TOKEN;
     try {
-        const { symbol } = TOKEN_REGISTRY$2.resolveByAddress(normalizedToken, chain.chain);
+        const { symbol } = TOKEN_REGISTRY$3.resolveByAddress(normalizedToken, chain.chain);
         if (symbol === undefined) {
             return null;
         }
@@ -25322,7 +25590,7 @@ const TOKEN_REGISTRY$2 = createTokenRegistry();
     return `Insufficient ${displaySymbol} balance for swap operation.\n\n` + `Wallet: ${walletAddress}\n` + `Current balance: ${currentDisplay}\n` + `Required: ${requiredDisplay}\n` + `Shortfall: ${shortfallDisplay}\n\n` + `This swap requires ${requiredSummary} to complete the transaction.\n\n` + `Action: Add at least ${actionAmount} to your wallet to complete this swap.`;
 }
 
-const TOKEN_REGISTRY$1 = createTokenRegistry();
+const TOKEN_REGISTRY$2 = createTokenRegistry();
 /**
  * Format a raw base-unit amount into a human-readable decimal string.
  *
@@ -25382,12 +25650,12 @@ const TOKEN_REGISTRY$1 = createTokenRegistry();
                     value,
                     token: resolvedSymbol,
                     chain,
-                    tokens: TOKEN_REGISTRY$1
+                    tokens: TOKEN_REGISTRY$2
                 }),
                 token: resolvedSymbol
             };
         }
-        const tokenDef = TOKEN_REGISTRY$1.get(resolvedSymbol);
+        const tokenDef = TOKEN_REGISTRY$2.get(resolvedSymbol);
         if (tokenDef) {
             const decimals = resolveTokenDecimals$1(tokenDef, chain.chain);
             return {
@@ -25418,7 +25686,7 @@ const TOKEN_REGISTRY$1 = createTokenRegistry();
  * i.e. 1 + 0.2 + 0.1 = 1.3. Use the greater of (local estimate × this multiplier)
  * or the proxy's gasLimit.
  */ const GAS_SAFETY_MULTIPLIER = 1.3;
-const TOKEN_REGISTRY = createTokenRegistry();
+const TOKEN_REGISTRY$1 = createTokenRegistry();
 /**
  * Enhances a KitError with transaction details (txHash and explorerUrl).
  *
@@ -25494,6 +25762,19 @@ const TOKEN_REGISTRY = createTokenRegistry();
  *
  * @internal
  */ const SUPPORTED_CHAINS$1 = getSwapSupportedChains(Chains);
+/**
+ * Inter-poll delays (ms) for the same-chain `amountOut` enrichment loop.
+ *
+ * A same-chain swap is already terminal `DONE` once its source transaction
+ * confirms; this short, escalating budget (~5s total across up to four polls)
+ * gives the service a brief window to resolve the output amount before
+ * `swap()` returns. The loop exits the instant `amountOut` is available.
+ */ const SAME_CHAIN_AMOUNT_OUT_POLL_DELAYS_MS = [
+    1_000,
+    2_000,
+    2_000
+];
+const sleep$3 = async (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
 function buildSwapProgress(statusResult) {
     return {
         status: statusResult.status,
@@ -25513,29 +25794,46 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
             }
         };
     }
-    try {
-        const statusResult = await getSwapStatus$2({
-            txHash,
-            chain: chain.chain,
-            apiKey
-        });
-        const progress = buildSwapProgress(statusResult);
-        if (statusResult.status === 'DONE' && statusResult.amountOut !== undefined) {
+    // A same-chain swap completes atomically in the source transaction, which
+    // has already been confirmed (and receipt-checked for revert) by the time we
+    // get here. Its terminal status is therefore `DONE`. We briefly poll the
+    // status endpoint to enrich `amountOut`, which the service usually resolves
+    // within a few seconds. A non-DONE/erroneous peek never downgrades the
+    // status — once the short budget is exhausted we return `DONE` without
+    // `amountOut`, and the caller can fetch it later via `getSwapStatus`.
+    for(let attempt = 0;; attempt += 1){
+        try {
+            const statusResult = await getSwapStatus$2({
+                txHash,
+                chain: chain.chain,
+                apiKey
+            });
+            if (statusResult.status === 'DONE' && statusResult.amountOut !== undefined) {
+                return {
+                    progress: buildSwapProgress(statusResult),
+                    amountOut: statusResult.amountOut
+                };
+            }
+        } catch  {
+            // Reachability/parse failure during enrichment — non-fatal; the swap
+            // already succeeded on-chain. `getSwapStatus` already retried transient
+            // network errors internally, so further polling is unlikely to help.
             return {
-                progress,
-                amountOut: statusResult.amountOut
+                progress: {
+                    status: 'DONE'
+                }
             };
         }
-        return {
-            progress
-        };
-    } catch  {
-        // Non-fatal — the swap already succeeded on-chain. status stays PENDING.
-        return {
-            progress: {
-                status: 'PENDING'
-            }
-        };
+        const delayMs = SAME_CHAIN_AMOUNT_OUT_POLL_DELAYS_MS[attempt];
+        if (delayMs === undefined) {
+            // Budget exhausted — terminal `DONE`, `amountOut` not yet available.
+            return {
+                progress: {
+                    status: 'DONE'
+                }
+            };
+        }
+        await sleep$3(delayMs);
     }
 }
 /**
@@ -25816,7 +26114,7 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
             return true;
         }
         // At least one token must be supported for fee collection
-        return getSwapOkTokenStatus(tokenInAddress, tokenOutAddress, chain, TOKEN_REGISTRY, OK_TOKEN_SYMBOLS$1).hasOkToken;
+        return getSwapOkTokenStatus(tokenInAddress, tokenOutAddress, chain, TOKEN_REGISTRY$1, OK_TOKEN_SYMBOLS$1).hasOkToken;
     }
     /**
    * Estimate swap costs and output amount by delegating to the Stablecoin Service quote API.
@@ -26413,14 +26711,14 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
         }
         // Build swap fees with adapter-backed formatting for unregistered tokens
         const swapResultFees = serviceResponse.fees ? await this.buildFormattedFees(serviceResponse.fees, chain, destinationChain, adapter, config?.customFee?.recipientAddress) : undefined;
-        // Best-effort enrichment: fetch amountOut and provider-reported status.
-        // Only performed for same-chain swaps — they typically reach DONE within
-        // a few seconds of source-tx confirmation, so the peek is useful UX and
-        // adds minimal latency. Cross-chain swaps are skipped because the
-        // destination mint takes minutes (CCTPv2 attestation), meaning the peek
-        // would always return PENDING/WAIT_DESTINATION_TRANSACTION while still
-        // burning up to 30s of the load balancer's server-side wait. Callers
-        // should use `kit.getSwapStatus()` to poll cross-chain swaps to DONE.
+        // Best-effort enrichment: briefly poll for amountOut on same-chain swaps.
+        // They complete atomically in the (already-confirmed) source tx, so the
+        // result is terminal `DONE` regardless; the short poll only adds amountOut
+        // once the service has resolved it. Cross-chain swaps are skipped because
+        // the destination mint takes minutes (CCTPv2 attestation), so polling would
+        // always return PENDING/WAIT_DESTINATION_TRANSACTION while burning the
+        // budget. Callers should use `kit.getSwapStatus()` to poll cross-chain
+        // swaps to DONE.
         const statusSnapshot = await fetchSameChainStatusSnapshot({
             isCrossChainSwap,
             txHash,
@@ -30047,7 +30345,7 @@ function resolveTokenEntry(entry, index, chain, chainDef, context) {
     ESTIMATE: 'swap_estimate'
 };
 
-/** SDK name used in telemetry payloads. */ const SDK_NAME$1 = resolveKitSdkName(pkg$2.name);
+/** SDK name used in telemetry payloads. */ const SDK_NAME$1 = resolveKitSdkName(pkg$3.name);
 /**
  * A high-level class-based interface for same-chain and cross-chain token swap operations.
  *
@@ -30170,7 +30468,7 @@ function resolveTokenEntry(entry, index, chain, chainDef, context) {
         this.disableErrorReporting = config.disableErrorReporting === true;
         this.telemetryConfig = {
             sdkName: SDK_NAME$1,
-            sdkVersion: pkg$2.version,
+            sdkVersion: pkg$3.version,
             disabled: this.disableErrorReporting
         };
     }
@@ -30626,7 +30924,7 @@ function resolveTokenEntry(entry, index, chain, chainDef, context) {
 }
 
 // Auto-register this kit for user agent tracking
-registerKit(`${pkg$2.name}/${pkg$2.version}`);
+registerKit(`${pkg$3.name}/${pkg$3.version}`);
 
 /**
  * Create a SwapKit instance with optional developer fee configuration.
@@ -30721,12 +31019,15 @@ registerKit(`${pkg$2.name}/${pkg$2.version}`);
     return kit;
 };
 
-var name$1 = "@circle-fin/earn-kit";
-var version$1 = "1.2.0";
-var pkg$1 = {
-	name: name$1,
-	version: version$1};
+var name$2 = "@circle-fin/earn-kit";
+var version$2 = "1.2.2";
+var pkg$2 = {
+	name: name$2,
+	version: version$2};
 
+const EARN_BRIDGE_ERC3009_TOKEN_SYMBOLS = [
+    'USDC'
+];
 /**
  * Default base URL for the Earn Service API.
  *
@@ -30771,20 +31072,7 @@ var pkg$1 = {
  */ const EARN_BRIDGE_DESTINATION_CHAIN_TO_API = {
     [exports.Blockchain.Arc_Testnet]: CHAIN_TO_API[exports.Blockchain.Arc_Testnet]
 };
-/**
- * Expected EIP-712 domain of the ERC-3009 authorization token per source
- * chain.
- *
- * Cross-chain Earn deposits are USDC-only, but USDC deployments differ on the
- * EIP-712 domain name: newer deployments use `USDC` while older ones (for
- * example Arbitrum Sepolia) kept `USD Coin` from the FiatToken V2 upgrade.
- * These values mirror the bridge service's per-chain domain table and the
- * on-chain `DOMAIN_SEPARATOR` inputs. Asserted before signing so a tampered
- * prepare response cannot point the signature at another token. The
- * `satisfies` check forces a domain entry whenever a source chain is added.
- *
- * @internal
- */ const EARN_BRIDGE_ERC3009_DOMAINS = {
+const EARN_BRIDGE_USDC_ERC3009_DOMAINS = {
     [exports.Blockchain.Arbitrum_Sepolia]: {
         name: 'USD Coin',
         version: '2'
@@ -30798,6 +31086,21 @@ var pkg$1 = {
         version: '2'
     }
 };
+/**
+ * Expected EIP-712 domain of the ERC-3009 authorization token per
+ * cross-chain-supported source token and source chain.
+ *
+ * The bridge service prepares an ERC-3009 payload for the deposited token. We
+ * keep this table as an explicit SDK allowlist because token deployments can
+ * differ by source chain and by domain name/version. These values mirror the
+ * bridge service's per-chain domain table and the on-chain DOMAIN_SEPARATOR
+ * inputs. Asserted before signing so a tampered prepare response cannot point
+ * the signature at another token or unexpected token domain.
+ *
+ * @internal
+ */ const EARN_BRIDGE_ERC3009_DOMAINS = {
+    USDC: EARN_BRIDGE_USDC_ERC3009_DOMAINS
+};
 /**
  * Maximum tolerated remaining lifetime of a prepared ERC-3009 authorization.
  *
@@ -31257,6 +31560,16 @@ const GAS_SAFETY_MULTIPLIER_DENOMINATOR = 10n;
     return approvalTxHash;
 }
 
+/** @internal */ function isSameAddress(actual, expected) {
+    return actual.toLowerCase() === expected.toLowerCase();
+}
+/** @internal */ function assertDecimalPlaces(field, value, tokenDecimals, reason) {
+    const decimals = value.split('.')[1]?.length ?? 0;
+    if (decimals > tokenDecimals) {
+        throw createValidationFailedError$1(field, value, reason);
+    }
+}
+
 /**
  * Build the `tokenInputs` array forwarded to the adapter contract's
  * `execute(executeParams, tokenInputs, signature)` call.
@@ -31280,15 +31593,17 @@ const GAS_SAFETY_MULTIPLIER_DENOMINATOR = 10n;
  *
  * @example
  * ```typescript
- * const approvedToken = assertHexAddress(
- *   'chain.usdcAddress',
- *   chain.usdcAddress,
- * )
- *
- * const tokenInputs = buildEarnTokenInputs(
+ * const approvalToken = resolveEarnApprovalToken(
  *   executionPayload.executionParams,
- *   approvedToken,
  * )
+ *
+ * const tokenInputs =
+ *   approvalToken === undefined
+ *     ? []
+ *     : buildEarnTokenInputs(
+ *         executionPayload.executionParams,
+ *         approvalToken,
+ *       )
  * ```
  *
  * @internal
@@ -31300,7 +31615,7 @@ const GAS_SAFETY_MULTIPLIER_DENOMINATOR = 10n;
             return;
         }
         const { tokenIn } = instruction;
-        if (tokenIn.toLowerCase() !== approvedToken.toLowerCase()) {
+        if (!isSameAddress(tokenIn, approvedToken)) {
             throw createValidationFailedError$1(`executionParams.instructions[${index.toString()}].tokenIn`, tokenIn, 'tokenIn must match the token approved for adapter spending');
         }
         tokenInputs.push({
@@ -31312,6 +31627,33 @@ const GAS_SAFETY_MULTIPLIER_DENOMINATOR = 10n;
     });
     return tokenInputs;
 }
+/**
+ * Resolve the single token that needs adapter allowance from signed Earn
+ * instructions.
+ *
+ * @param executionParams - Service-signed `ExecutionParams` forwarded to the adapter.
+ * @returns The token requested by positive approval instructions, or `undefined`.
+ * @throws {@link KitError} If positive approval instructions reference multiple tokens.
+ *
+ * @internal
+ */ function resolveEarnApprovalToken(executionParams) {
+    let approvedToken;
+    executionParams.instructions.forEach((instruction, index)=>{
+        const amount = BigInt(instruction.amountToApprove);
+        if (amount <= 0n) {
+            return;
+        }
+        const { tokenIn } = instruction;
+        if (approvedToken === undefined) {
+            approvedToken = tokenIn;
+            return;
+        }
+        if (!isSameAddress(tokenIn, approvedToken)) {
+            throw createValidationFailedError$1(`executionParams.instructions[${index.toString()}].tokenIn`, tokenIn, 'tokenIn must match the token approved for adapter spending');
+        }
+    });
+    return approvedToken;
+}
 
 /**
  * Prepare an earn adapter action, execute it, wait for confirmation, and
@@ -31803,6 +32145,7 @@ const hexSignatureSchema = evmSignatureSchema;
 const hexAddressSchema = evmAddressSchema;
 // '0x' prefix + 32 bytes * 2 hex chars.
 const BYTES32_HEX_LENGTH = 66;
+const bridgeFeeTokenSchema = hexAddressSchema;
 /**
  * Zod schema for a non-negative uint256-like value.
  *
@@ -32089,14 +32432,12 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
  *
  * The bridge prepare path returns one item per collected source fee (e.g.
  * `PRE_FINALITY` for the fast-burn fee and `FORWARD` for the destination
- * forward fee), all denominated in the shared `feeToken`. The signed
- * authorization `value` is `principal + sum(items[].amount)`, so the pre-sign
- * guard parses these to recompute the expected value. Each item's `amount` is
- * a base-unit decimal string in `feeToken` units.
+ * forward fee), all denominated in the shared `feeToken`. Each item's `amount`
+ * is a base-unit decimal string in `feeToken` units.
  *
  * @internal
  */ const bridgeFeeQuoteSchema = zod.z.object({
-    feeToken: hexAddressSchema,
+    feeToken: bridgeFeeTokenSchema,
     items: zod.z.array(zod.z.object({
         type: zod.z.string(),
         amount: uint256LikeSchema
@@ -32112,6 +32453,12 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
     erc3009TypedData: erc3009TypedDataSchema,
     feeQuote: bridgeFeeQuoteSchema
 }).passthrough();
+const bridgeDepositPrepareReviewSchema = zod.z.object({
+    sourceChain: zod.z.string(),
+    destinationChain: zod.z.string(),
+    amount: amountJsonSchema,
+    vaultAddress: hexAddressSchema
+}).passthrough();
 /**
  * Zod schema for the bridge deposit prepare payload.
  *
@@ -32123,7 +32470,7 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
     execId: bridgeDepositExecIdSchema,
     erc3009TypedData: bridgeDepositPreparedBundleSchema,
     expiresAt: zod.z.string().datetime(),
-    review: zod.z.unknown().optional()
+    review: bridgeDepositPrepareReviewSchema
 });
 /**
  * Zod schema for the `POST /v1/earnKit/bridge/deposit/prepare` API response.
@@ -32248,10 +32595,11 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
  * Zod schema for a fee entry in an EarnKit API response.
  *
  * Shared across deposit and withdrawal responses (and reusable for real
- * charged fees, not just quote estimates). `type` identifies the fee category —
- * for cross-chain deposit quotes this is the kits-proxy fee-quote item type
- * (e.g. `'FORWARD'`, `'PRE_FINALITY'`). `status` qualifies the fee (e.g.
- * `'estimated'` for a pre-sign cross-chain fee). Both are omitted on plain fees.
+ * charged fees, not just quote estimates). `type` identifies the fee category.
+ * For cross-chain deposit quotes this is the kits-proxy fee-quote item type
+ * (e.g. `'FORWARD'`, `'PRE_FINALITY'`). For withdrawal quotes, Circle fees use
+ * `type: 'circle'`. `status` qualifies the fee (e.g. `'estimated'` for a
+ * pre-sign cross-chain fee). Both are omitted on plain fees.
  *
  * @internal
  */ const feeSchema = zod.z.object({
@@ -32523,6 +32871,60 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
     return claimRewardsQuoteResponseSchema.safeParse(value).success;
 }
 
+var name$1 = "@circle-fin/provider-earn-service";
+var version$1 = "1.2.2";
+var pkg$1 = {
+	name: name$1,
+	version: version$1};
+
+/**
+ * HTTP header name used to report the EarnKit SDK version to the backend.
+ *
+ * @internal
+ */ const SDK_VERSION_HEADER = 'X-EarnKit-SDK-Version';
+/**
+ * Resolve the SDK version string from its source components.
+ *
+ * Resolution order:
+ * 1. The registered kit identifier (preferred) — e.g. `@circle-fin/earn-kit/1.1.0`
+ *    becomes `earn-kit/1.1.0`.
+ * 2. The provider package itself (fallback when no kit is registered) —
+ *    e.g. `provider-earn-service/1.1.0`.
+ * 3. The literal `unknown` when neither source is available.
+ *
+ * Kept as a pure function (no global / module reads) so every branch is
+ * unit-testable.
+ *
+ * @param kitId - The registered kit identifier, or `undefined`.
+ * @param providerName - The provider package name (e.g. `@circle-fin/provider-earn-service`).
+ * @param providerVersion - The provider package version, or `undefined`.
+ * @returns The formatted SDK version string.
+ *
+ * @internal
+ */ function formatSdkVersion(kitId, providerName, providerVersion) {
+    if (kitId !== undefined && kitId !== '') {
+        // e.g. '@circle-fin/earn-kit/1.1.0' -> 'earn-kit/1.1.0'
+        return resolveKitSdkName(kitId);
+    }
+    {
+        // e.g. '@circle-fin/provider-earn-service' + '1.1.0' -> 'provider-earn-service/1.1.0'
+        return `${resolveKitSdkName(providerName)}/${providerVersion}`;
+    }
+}
+/**
+ * Resolve the value for the {@link SDK_VERSION_HEADER} header.
+ *
+ * Reads the kit registered at runtime via {@link createRequestContext} and
+ * falls back to this provider package's own version when no kit is registered.
+ *
+ * @returns The SDK version string, e.g. `earn-kit/1.1.0` or
+ *   `provider-earn-service/1.1.0`, or `unknown`.
+ *
+ * @internal
+ */ function resolveSdkVersionHeader() {
+    return formatSdkVersion(createRequestContext().kit, pkg$1.name, pkg$1.version);
+}
+
 /**
  * Build an API polling config with optional authorization header,
  * and resolve the base URL (configurable for testing).
@@ -32533,9 +32935,16 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
  * @internal
  */ function buildConfig(serviceConfig) {
     const baseUrl = serviceConfig?.baseUrl ?? EARN_SERVICE_BASE_URL;
+    const sdkVersion = resolveSdkVersionHeader();
     if (serviceConfig?.kitKey === undefined) {
         return {
-            pollingConfig: DEFAULT_CONFIG,
+            pollingConfig: {
+                ...DEFAULT_CONFIG,
+                headers: {
+                    ...DEFAULT_CONFIG.headers,
+                    [SDK_VERSION_HEADER]: sdkVersion
+                }
+            },
             baseUrl
         };
     }
@@ -32551,6 +32960,7 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
             ...DEFAULT_CONFIG,
             headers: {
                 ...DEFAULT_CONFIG.headers,
+                [SDK_VERSION_HEADER]: sdkVersion,
                 Authorization: `Bearer ${serviceConfig.kitKey}`
             }
         },
@@ -32851,7 +33261,8 @@ function toPositionInfo(data) {
         return {
             execId: response.data.execId,
             preparedBundle,
-            expiresAt: response.data.expiresAt
+            expiresAt: response.data.expiresAt,
+            review: response.data.review
         };
     } catch (error) {
         throw parseEarnApiError(error, {
@@ -32962,47 +33373,34 @@ const VALID_AFTER_CLOCK_SKEW_SECONDS = 60n;
  * @throws If any typed-data field does not match the expected bridge deposit intent.
  * @internal
  */ function assertBridgeDepositTypedDataMatchesIntent(intent) {
-    const { preparedBundle, sourceChain, sourceAddress, sourceTokenAddress, authorizationRecipient, amount, maxFee, tokenDecimals, nowSeconds = BigInt(Math.floor(Date.now() / 1000)) } = intent;
+    const { preparedBundle, sourceChain, sourceAddress, sourceTokenAddress, expectedDomain, authorizationRecipient, amount, maxFee, tokenDecimals, amountRaw, nowSeconds = BigInt(Math.floor(Date.now() / 1000)) } = intent;
     const { domain, message } = preparedBundle.erc3009TypedData;
-    // USDC deployments differ on the EIP-712 domain name per chain, so the
-    // expected domain is looked up for the source chain being signed on.
-    const expectedDomain = EARN_BRIDGE_ERC3009_DOMAINS[sourceChain.chain];
-    if (expectedDomain === undefined) {
-        throw createValidationFailedError$1('sourceChain.chain', sourceChain.chain, 'no expected ERC-3009 domain is configured for the source chain');
-    }
-    if (domain.name !== expectedDomain.name) {
-        throw createValidationFailedError$1('preparedBundle.erc3009TypedData.domain.name', domain.name, `domain name must be ${expectedDomain.name}`);
-    }
-    if (domain.version !== expectedDomain.version) {
-        throw createValidationFailedError$1('preparedBundle.erc3009TypedData.domain.version', domain.version, `domain version must be ${expectedDomain.version}`);
-    }
     assertSameAddress('preparedBundle.erc3009TypedData.domain.verifyingContract', domain.verifyingContract, sourceTokenAddress, 'verifyingContract must match the source token contract');
     assertSameBigInt('preparedBundle.erc3009TypedData.domain.chainId', domain.chainId, BigInt(sourceChain.chainId), 'chainId must match the source chain');
+    assertSameString('preparedBundle.erc3009TypedData.domain.name', domain.name, expectedDomain.name, 'domain name must match the source token');
+    assertSameString('preparedBundle.erc3009TypedData.domain.version', domain.version, expectedDomain.version, 'domain version must match the source token');
     assertSameAddress('preparedBundle.erc3009TypedData.message.from', message.from, sourceAddress, 'from must match the source wallet');
     assertSameAddress('preparedBundle.erc3009TypedData.message.to', message.to, authorizationRecipient, 'to must match the configured authorization recipient');
-    // The prepare path folds the source fee into the signed authorization:
-    // message.value = principal + sum(feeQuote.items[].amount), all denominated
-    // in the source token. The fee items only add up to a meaningful total when
-    // they are priced in the same token as the principal, so first pin the fee
-    // token to the source token contract before summing.
-    assertSameAddress('preparedBundle.feeQuote.feeToken', preparedBundle.feeQuote.feeToken, sourceTokenAddress, 'feeQuote.feeToken must match the source token contract');
-    // Recompute the expected value from locally trusted inputs (the caller
-    // principal) plus the bundle's own fee items so the guard accepts fee-bearing
-    // deposits while still rejecting any other value tampering. The fee quote is
-    // service-supplied, so bound it to the caller-accepted quote-derived cap
-    // before including it in the signed value.
-    const principal = Amount.parse(amount, {
+    // Recompute the expected ERC-3009 value from locally trusted inputs. Bridge
+    // source fees are paid in the source ERC-20 and are part of the authorization.
+    assertDecimalPlaces('amount', amount, tokenDecimals, `amount must have at most ${String(tokenDecimals)} decimal places for the cross-chain Earn deposit source token`);
+    const parsedAmount = Amount.parse(amount, {
         decimals: tokenDecimals
     }).raw;
+    const principal = amountRaw === undefined ? parsedAmount : parseReviewedAmount(amountRaw, parsedAmount);
+    const feeQuote = preparedBundle.feeQuote;
     const feeTotal = sumBridgeFeeItems(preparedBundle.feeQuote);
+    assertFeeTokenMatchesSourceToken(feeQuote.feeToken, sourceTokenAddress);
+    const feeDecimals = tokenDecimals;
+    assertDecimalPlaces('maxFee', maxFee, feeDecimals, `maxFee must have at most ${String(feeDecimals)} decimal places for the cross-chain Earn deposit fee token`);
     const maxFeeRaw = Amount.parse(maxFee, {
-        decimals: tokenDecimals
+        decimals: feeDecimals
     }).raw;
     if (feeTotal > maxFeeRaw) {
         throw createValidationFailedError$1('preparedBundle.feeQuote.items', feeTotal.toString(), 'fee total must not exceed maxFee in base units');
     }
     const expectedValue = principal + feeTotal;
-    assertSameBigInt('preparedBundle.erc3009TypedData.message.value', message.value, expectedValue, 'value must match the requested amount plus the bundle fee in base units');
+    assertSameBigInt('preparedBundle.erc3009TypedData.message.value', message.value, expectedValue, 'value must match the requested amount plus source-token fees in base units');
     const window = checkErc3009ValidityWindow({
         validAfter: BigInt(message.validAfter),
         validBefore: BigInt(message.validBefore),
@@ -33076,14 +33474,19 @@ const VALID_AFTER_CLOCK_SKEW_SECONDS = 60n;
 /**
  * Sum the source-collected fee items in a prepared bundle's fee quote.
  *
- * Each item amount is a base-unit value in the shared `feeToken`; the total is
- * what the prepare path adds to the principal when building `message.value`.
+ * Each item amount is a base-unit value in the shared `feeToken`.
  *
  * @param feeQuote - Fee quote parsed from the prepared bundle.
- * @returns Total fee in source token base units (0n when there are no items).
+ * @returns Total fee in fee-token base units (0n when there are no items).
  */ function sumBridgeFeeItems(feeQuote) {
     return feeQuote.items.reduce((total, item)=>total + BigInt(item.amount), 0n);
 }
+function assertFeeTokenMatchesSourceToken(feeToken, sourceTokenAddress) {
+    if (isSameAddress(feeToken, sourceTokenAddress)) {
+        return;
+    }
+    throw createValidationFailedError$1('preparedBundle.feeQuote.feeToken', feeToken, 'fee token must match the cross-chain Earn deposit source token');
+}
 function assertNever(value) {
     throw new KitError({
         ...EarnError.INTERNAL_ERROR,
@@ -33091,8 +33494,23 @@ function assertNever(value) {
         message: `Unexpected validity window reason: ${String(value)}`
     });
 }
+function parseReviewedAmount(amountRaw, parsedAmount) {
+    let reviewedAmount;
+    try {
+        reviewedAmount = BigInt(amountRaw);
+    } catch  {
+        throw createValidationFailedError$1('prepared.review.amount.raw', amountRaw, 'amount must be a non-negative integer string');
+    }
+    if (reviewedAmount < 0n) {
+        throw createValidationFailedError$1('prepared.review.amount.raw', amountRaw, 'amount must be a non-negative integer string');
+    }
+    if (reviewedAmount !== parsedAmount) {
+        throw createValidationFailedError$1('prepared.review.amount.raw', amountRaw, 'review amount must match the requested amount');
+    }
+    return reviewedAmount;
+}
 function assertSameAddress(field, actual, expected, reason) {
-    if (actual.toLowerCase() !== expected.toLowerCase()) {
+    if (!isSameAddress(actual, expected)) {
         throw createValidationFailedError$1(field, actual, reason);
     }
 }
@@ -33101,6 +33519,11 @@ function assertSameBigInt(field, actual, expected, reason) {
         throw createValidationFailedError$1(field, actual, reason);
     }
 }
+function assertSameString(field, actual, expected, reason) {
+    if (actual !== expected) {
+        throw createValidationFailedError$1(field, actual, reason);
+    }
+}
 
 /**
  * Build signed withdrawal instructions via the Earn Service API.
@@ -33270,9 +33693,15 @@ function toWithdrawalQuoteInfo(data) {
             symbol: data.asset,
             amount: Amount.fromJSON(data.maxWithdrawable)
         },
-        fees: data.fees.map((fee)=>({
-                symbol: fee.token,
-                amount: Amount.fromJSON(fee.amount)
+        fees: data.fees.map(({ token, amount, type, status })=>({
+                symbol: token,
+                amount: Amount.fromJSON(amount),
+                ...type !== undefined && {
+                    type
+                },
+                ...status !== undefined && {
+                    status
+                }
             })),
         gasFees: [],
         // Wire format uses `warnings`, but the SDK surface uses
@@ -33458,6 +33887,9 @@ function toWithdrawalQuoteInfo(data) {
     'CONFIRMED',
     'COMPLETE'
 ]);
+// Intentionally built-ins-only: Earn bridge support is limited to SDK-known
+// token contracts plus the explicit ERC-3009 domain allowlist below.
+const TOKEN_REGISTRY = createTokenRegistry();
 /**
  * Build the typed error raised when a cross-chain wait is cancelled via its
  * `AbortSignal`. Mirrors `@core/adapter-base`'s `createAbortError` (same
@@ -33787,24 +34219,20 @@ function finishElapsedWait(lastStatus, lastError) {
             }
             const { address, chain: apiChain, chainDefinition: chain } = await resolveAdapterContext(params.from);
             const adapterContractAddress = requireAdapterContract(chain);
-            const rawUsdcAddress = chain.usdcAddress;
-            if (rawUsdcAddress === null) {
-                throw createUnsupportedTokenError('USDC', chain.name);
-            }
-            const usdcAddress = assertHexAddress('chain.usdcAddress', rawUsdcAddress, `USDC address for chain ${chain.name} must be a 0x-prefixed 20-byte hex address.`);
             const { adapter } = params.from;
+            const vaultAddress = assertHexAddress('vaultAddress', params.vaultAddress, 'Vault address must be a 0x-prefixed 20-byte hex address.');
             const { executionParams, signature } = await this.runPhase(ctx, 'deposit', 'fetchParams', async ()=>fetchDeposit({
-                    vaultAddress: params.vaultAddress,
+                    vaultAddress,
                     amount: params.amount,
                     address,
                     chain: apiChain,
                     config
                 }), ()=>undefined);
             validateExecutionDeadline(executionParams);
-            const tokenInputs = buildEarnTokenInputs(executionParams, usdcAddress);
-            const approvalToken = tokenInputs[0]?.token;
+            const approvalToken = resolveEarnApprovalToken(executionParams);
+            const tokenInputs = approvalToken === undefined ? [] : buildEarnTokenInputs(executionParams, approvalToken);
             const requiredAllowance = sumTokenInputAmounts(tokenInputs);
-            if (!options.skipApprove && approvalToken !== undefined) {
+            if (!options.skipApprove && approvalToken !== undefined && requiredAllowance > 0n) {
                 await this.runPhase(ctx, 'approve', 'approve', async ()=>approveAllowanceIfNeeded({
                         adapter,
                         chain,
@@ -33812,7 +34240,7 @@ function finishElapsedWait(lastStatus, lastError) {
                         delegate: adapterContractAddress,
                         address,
                         requiredAllowance,
-                        revertMessage: 'USDC approval reverted on-chain'
+                        revertMessage: 'Earn deposit token approval reverted on-chain'
                     }), (txHash)=>txHash);
             }
             const { txHash, explorerUrl } = await this.runPhase(ctx, 'deposit', 'execute', async ()=>executeEarnAction({
@@ -33831,7 +34259,7 @@ function finishElapsedWait(lastStatus, lastError) {
                 kind: 'same-chain',
                 txHash,
                 explorerUrl,
-                vaultAddress: params.vaultAddress,
+                vaultAddress,
                 amount: params.amount
             };
         } catch (error) {
@@ -33853,13 +34281,6 @@ function finishElapsedWait(lastStatus, lastError) {
         const sourceAddress = assertHexAddress('from.address', await resolveCrossChainSourceAddress(params.from, sourceChain), `Source address for chain ${sourceChain.name} must be a 0x-prefixed 20-byte hex address.`);
         const destinationAddress = assertHexAddress('to.recipientAddress', params.to.recipientAddress, `Destination address for chain ${destinationChain.name} must be a 0x-prefixed 20-byte hex address.`);
         const vaultAddress = assertHexAddress('vaultAddress', params.vaultAddress, 'Vault address must be a 0x-prefixed 20-byte hex address.');
-        // The signed ERC-3009 value is denominated in USDC's 6 decimals. More
-        // precise inputs would be silently truncated by Amount.parse, so the
-        // result would claim a larger deposit than was actually authorized.
-        const amountDecimals = params.amount.split('.')[1]?.length ?? 0;
-        if (amountDecimals > TOKEN_DECIMALS_6) {
-            throw createValidationFailedError$1('amount', params.amount, `amount must have at most ${String(TOKEN_DECIMALS_6)} decimal places for cross-chain Earn deposits`);
-        }
         const execId = params.idempotencyKey;
         const prepared = await this.runPhase(ctx, 'crossChainDeposit', 'prepare', async ()=>fetchBridgeDepositPrepare({
                 execId,
@@ -33879,17 +34300,19 @@ function finishElapsedWait(lastStatus, lastError) {
             // the error trace, instead of ending the event stream unannounced
             // after the prepare success event.
             assertPreparedBundleMatchesTypedDataNonce(prepared.preparedBundle);
+            const sourceToken = resolvePreparedBridgeSourceToken(prepared.preparedBundle, route.sourceChain);
+            validatePreparedReviewAmountDecimals(prepared.review.amount.decimals, sourceToken.decimals);
             assertBridgeDepositTypedDataMatchesIntent({
                 preparedBundle: prepared.preparedBundle,
                 sourceChain: route.sourceChain,
                 sourceAddress,
-                sourceTokenAddress: route.sourceTokenAddress,
+                sourceTokenAddress: sourceToken.address,
+                expectedDomain: sourceToken.erc3009Domain,
                 authorizationRecipient: route.authorizationRecipient,
                 amount: params.amount,
                 maxFee: params.maxFee,
-                // Cross-chain Earn is USDC-only today. USDC uses 6 decimals on all
-                // configured source chains.
-                tokenDecimals: TOKEN_DECIMALS_6
+                tokenDecimals: sourceToken.decimals,
+                amountRaw: prepared.review.amount.raw
             });
             return signBridgeDepositAuthorization({
                 adapter: bridgeSigningAdapter,
@@ -34112,21 +34535,17 @@ function finishElapsedWait(lastStatus, lastError) {
         const { adapter, chain, apiChain, address, vaultAddress, amount, config } = params;
         try {
             const adapterContractAddress = requireAdapterContract(chain);
-            const rawUsdcAddress = chain.usdcAddress;
-            if (rawUsdcAddress === null) {
-                throw createUnsupportedTokenError('USDC', chain.name);
-            }
-            const usdcAddress = assertHexAddress('chain.usdcAddress', rawUsdcAddress, `USDC address for chain ${chain.name} must be a 0x-prefixed 20-byte hex address.`);
+            const normalizedVaultAddress = assertHexAddress('vaultAddress', vaultAddress, 'Vault address must be a 0x-prefixed 20-byte hex address.');
             const { executionParams, signature } = await fetchDeposit({
-                vaultAddress,
+                vaultAddress: normalizedVaultAddress,
                 amount,
                 address,
                 chain: apiChain,
                 config
             });
             validateExecutionDeadline(executionParams);
-            const tokenInputs = buildEarnTokenInputs(executionParams, usdcAddress);
-            const approvalToken = tokenInputs[0]?.token;
+            const approvalToken = resolveEarnApprovalToken(executionParams);
+            const tokenInputs = approvalToken === undefined ? [] : buildEarnTokenInputs(executionParams, approvalToken);
             const requiredAllowance = sumTokenInputAmounts(tokenInputs);
             return await estimateEarnQuoteGasFees({
                 adapter,
@@ -34139,7 +34558,7 @@ function finishElapsedWait(lastStatus, lastError) {
                     tokenInputs,
                     signature
                 },
-                approval: approvalToken !== undefined ? {
+                approval: approvalToken !== undefined && requiredAllowance > 0n ? {
                     token: approvalToken,
                     delegate: adapterContractAddress,
                     requiredAllowance
@@ -34383,11 +34802,6 @@ function validateCrossChainDepositRoute(sourceChain, destinationChain) {
     if (destinationApiChain === undefined) {
         throw createUnsupportedCrossChainDepositError(destinationChain, 'destination chain is not enabled for cross-chain Earn deposits');
     }
-    const sourceTokenAddressRaw = sourceChain.usdcAddress;
-    if (sourceTokenAddressRaw === null) {
-        throw createUnsupportedTokenError('USDC', sourceChain.name);
-    }
-    const sourceTokenAddress = assertHexAddress('sourceChain.usdcAddress', sourceTokenAddressRaw, `USDC address for chain ${sourceChain.name} must be a 0x-prefixed 20-byte hex address.`);
     if (sourceChain.cctp == null) {
         throw createBridgeRouteNotConfiguredError(sourceChain, 'source chain does not support CCTP');
     }
@@ -34411,10 +34825,50 @@ function validateCrossChainDepositRoute(sourceChain, destinationChain) {
         destinationApiChain,
         destinationDomain: destinationChain.cctp.domain,
         sourceChain,
-        sourceTokenAddress,
         authorizationRecipient
     };
 }
+function resolvePreparedBridgeSourceToken(preparedBundle, sourceChain) {
+    const sourceTokenAddress = assertHexAddress('preparedBundle.erc3009TypedData.domain.verifyingContract', preparedBundle.erc3009TypedData.domain.verifyingContract, `Source token for chain ${sourceChain.name} must be a 0x-prefixed 20-byte hex address.`);
+    let sourceToken;
+    try {
+        sourceToken = TOKEN_REGISTRY.resolveByAddress(sourceTokenAddress, sourceChain.chain);
+    } catch  {
+        throw createValidationFailedError$1('preparedBundle.erc3009TypedData.domain.verifyingContract', sourceTokenAddress, `source token ${sourceTokenAddress} is not configured on source chain ${sourceChain.name} for cross-chain Earn deposits`);
+    }
+    const registryAddress = assertHexAddress('sourceToken.locator', sourceToken.locator, `Source token ${sourceToken.symbol ?? sourceTokenAddress} for chain ${sourceChain.name} must be a 0x-prefixed 20-byte hex address.`);
+    if (!isSameAddress(sourceTokenAddress, registryAddress)) {
+        throw createValidationFailedError$1('preparedBundle.erc3009TypedData.domain.verifyingContract', sourceTokenAddress, `source token must match the configured ${sourceToken.symbol ?? 'token'} address on source chain ${sourceChain.name}`);
+    }
+    const { symbol } = sourceToken;
+    if (symbol === undefined) {
+        throw createValidationFailedError$1('preparedBundle.erc3009TypedData.domain.verifyingContract', sourceTokenAddress, `source token ${sourceTokenAddress} is not a registered Earn bridge token on source chain ${sourceChain.name}`);
+    }
+    return {
+        address: sourceTokenAddress,
+        erc3009Domain: resolveBridgeErc3009Domain(symbol, sourceChain),
+        decimals: sourceToken.decimals
+    };
+}
+function validatePreparedReviewAmountDecimals(reviewedDecimals, tokenDecimals) {
+    if (reviewedDecimals !== tokenDecimals) {
+        throw createValidationFailedError$1('prepared.review.amount.decimals', reviewedDecimals, `review amount decimals must match the cross-chain Earn deposit source token decimals ${String(tokenDecimals)}`);
+    }
+}
+function resolveBridgeErc3009Domain(tokenSymbol, sourceChain) {
+    if (!isEarnBridgeErc3009TokenSymbol(tokenSymbol)) {
+        throw createValidationFailedError$1('sourceToken.symbol', tokenSymbol, `ERC-3009 domain is not configured for ${tokenSymbol} on source chain ${sourceChain.name}`);
+    }
+    const domainsByChain = EARN_BRIDGE_ERC3009_DOMAINS[tokenSymbol];
+    const domain = domainsByChain[sourceChain.chain];
+    if (domain === undefined) {
+        throw createValidationFailedError$1('sourceToken.symbol', tokenSymbol, `ERC-3009 domain is not configured for ${tokenSymbol} on source chain ${sourceChain.name}`);
+    }
+    return domain;
+}
+function isEarnBridgeErc3009TokenSymbol(tokenSymbol) {
+    return EARN_BRIDGE_ERC3009_TOKEN_SYMBOLS.includes(tokenSymbol);
+}
 function createUnsupportedCrossChainDepositError(chain, reason) {
     return new KitError({
         ...EarnError.UNSUPPORTED_CHAIN,
@@ -34487,7 +34941,6 @@ function createUnsupportedCrossChainDepositError(chain, reason) {
     // Untyped callers can pass anything here; without these guards a null
     // config crashes with a raw TypeError on `config.providers` instead of
     // the structured validation error every other public surface throws.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- JS consumers may pass null or a non-object config
     if (typeof config !== 'object' || config === null || Array.isArray(config)) {
         throw createValidationFailedError$1('config', config, 'config must be a plain object when provided');
     }
@@ -34854,10 +35307,9 @@ const sourceAdapterContextSchema = zod.z.object({
  * Schema for validating human-readable decimal amount strings.
  *
  * Accept positive decimal strings like '100', '100.50', '0.001'. Reject
- * zero, negative, non-numeric, and non-canonical strings. EarnKit
- * same-chain amounts are USDC/EURC (6 decimals), so precision is capped at
- * 6 to match the Earn Service and fail fast locally instead of leaking
- * 7+ decimal-place inputs to the server.
+ * zero, negative, non-numeric, and non-canonical strings. Same-chain
+ * EarnKit vaults can use different asset precisions, so the service enforces
+ * the vault-specific decimal cap after resolving the vault asset.
  *
  * @internal
  */ const amountSchema$1 = zod.z.string({
@@ -34866,32 +35318,15 @@ const sourceAdapterContextSchema = zod.z.object({
     allowZero: false,
     regexMessage: AMOUNT_FORMAT_ERROR_MESSAGE,
     attributeName: 'amount',
-    maxDecimals: 6
-})(zod.z.string())).refine((value)=>CANONICAL_AMOUNT_REGEX.test(value), AMOUNT_FORMAT_ERROR_MESSAGE);
-/**
- * Schema for cross-chain deposit amount strings.
- *
- * Cross-chain Earn deposits are USDC-only, and the signed ERC-3009 value is
- * denominated in USDC's 6 decimals. Reject more precise inputs up front so
- * the signed value always equals the requested amount instead of a silent
- * truncation. Non-canonical forms (leading dot, leading zeros) are rejected
- * too, matching the Earn Service.
- *
- * @internal
- */ const crossChainAmountSchema = zod.z.string({
-    required_error: 'amount is required'
-}).min(1, 'amount is required').pipe(createDecimalStringValidator({
-    allowZero: false,
-    regexMessage: AMOUNT_FORMAT_ERROR_MESSAGE,
-    attributeName: 'amount',
-    maxDecimals: 6
+    maxDecimals: 18
 })(zod.z.string())).refine((value)=>CANONICAL_AMOUNT_REGEX.test(value), AMOUNT_FORMAT_ERROR_MESSAGE);
 /**
  * Schema for cross-chain source fee caps.
  *
- * Cross-chain source fees are denominated in USDC base units. Zero is valid
- * when the quote contains no source-collected fees; otherwise the cap should be
- * the caller-accepted total from a recent quote.
+ * Cross-chain source fees are denominated in the quote's fee token. Zero is
+ * valid when the quote contains no source-collected fees; otherwise the cap
+ * should be the caller-accepted total from a recent quote. The provider
+ * enforces the prepared bundle's fee-token precision before signing.
  *
  * @internal
  */ const crossChainMaxFeeSchema = zod.z.string({
@@ -34900,7 +35335,7 @@ const sourceAdapterContextSchema = zod.z.object({
     allowZero: true,
     regexMessage: AMOUNT_FORMAT_ERROR_MESSAGE,
     attributeName: 'maxFee',
-    maxDecimals: 6
+    maxDecimals: 18
 })(zod.z.string())).refine((value)=>CANONICAL_AMOUNT_REGEX.test(value), AMOUNT_FORMAT_ERROR_MESSAGE);
 /**
  * Build a schema for an optional non-negative decimal filter string.
@@ -35061,7 +35496,7 @@ const crossChainDepositDestinationSchema = zod.z.object({
     from: sourceAdapterContextSchema,
     to: crossChainDepositDestinationSchema,
     vaultAddress: vaultAddressSchema,
-    amount: crossChainAmountSchema,
+    amount: amountSchema$1,
     maxFee: crossChainMaxFeeSchema,
     transferSpeed: zod.z.enum([
         'FAST',
@@ -36485,7 +36920,7 @@ function formatRetryResult(operation, result) {
 }
 
 // Auto-register this kit for user agent tracking
-registerKit(`${pkg$1.name}/${pkg$1.version}`);
+registerKit(`${pkg$2.name}/${pkg$2.version}`);
 
 /**
  * Create an EarnKit instance for AppKit earn operations.
@@ -36580,12 +37015,17 @@ registerKit(`${pkg$1.name}/${pkg$1.version}`);
  * The type annotation `readonly TokenAlias[]` ensures this array stays in sync
  * with the TokenAlias type definition - TypeScript will enforce any changes.
  *
- * For swap operations, additional tokens (EURC, DAI, USDE, PYUSD) are supported
+ * `USDC`, `USDT`, and `NATIVE` map to dedicated adapter transfer actions.
+ * `EURC` has no dedicated action — it resolves to the chain's `eurcAddress`
+ * and uses the generic token transfer action (see {@link prepareSend}).
+ *
+ * For swap operations, additional tokens (DAI, USDE, PYUSD) are supported
  * via SwapKit's SupportedToken type.
  */ const TOKEN_ALIASES = [
     'USDC',
     'USDT',
-    'NATIVE'
+    'NATIVE',
+    'EURC'
 ];
 /**
  * Check if a token string is a known alias.
@@ -36612,7 +37052,7 @@ registerKit(`${pkg$1.name}/${pkg$1.version}`);
  * Type guard to check if a string is a valid token address for a chain.
  *
  * This function verifies that a token string is:
- * 1. Not a known alias ('USDC', 'USDT', 'NATIVE')
+ * 1. Not a known alias ('USDC', 'USDT', 'NATIVE', 'EURC')
  * 2. A valid address format for the specified chain
  *
  * Use this to narrow the type to `TokenAddress` in TypeScript.
@@ -36642,7 +37082,7 @@ registerKit(`${pkg$1.name}/${pkg$1.version}`);
  * Validate and classify a token identifier.
  *
  * This function determines whether a token string is:
- * 1. A known alias ('USDC', 'USDT', or 'NATIVE')
+ * 1. A known alias ('USDC', 'USDT', 'NATIVE', or 'EURC')
  * 2. A valid token address for the given chain
  * 3. An invalid/unrecognized token identifier
  *
@@ -36896,8 +37336,11 @@ const tokens = createTokenRegistry();
  * from `to` (explicit address string or adapter), and normalize the human‑readable
  * `amount` into token units.
  *
- * For known token aliases, uses dedicated transfer actions
- * with hardcoded decimals (USDC and USDT use 6 decimals; native uses the source chain's native decimals). For custom token addresses, uses the generic token.transfer
+ * For the `USDC`, `USDT`, and `NATIVE` aliases, uses dedicated transfer actions
+ * with hardcoded decimals (USDC and USDT use 6 decimals; native uses the source chain's native decimals).
+ * The `EURC` alias resolves to the chain's `eurcAddress` (6 decimals from the token
+ * registry) and routes through the generic token.transfer action; it is rejected on
+ * chains where `eurcAddress` is not set. For custom token addresses, uses the generic token.transfer
  * action and fetches decimals dynamically from the contract.
  *
  * @param params - The send parameters including source context, destination, amount and token.
@@ -36990,6 +37433,21 @@ const tokens = createTokenRegistry();
                     preparedSendRequest = await fromAdapter.prepareAction('native.transfer', requestParams, operationContext);
                     break;
                 }
+            case 'EURC':
+                {
+                    // EURC has no dedicated transfer action. Resolve its contract address
+                    // from the chain definition and route through the generic
+                    // token.transfer action. `eurcAddress` is null where EURC isn't deployed.
+                    const eurcAddress = fromChain.eurcAddress;
+                    if (eurcAddress === null) {
+                        throw createUnsupportedTokenError(token, fromChain.name);
+                    }
+                    preparedSendRequest = await fromAdapter.prepareAction('token.transfer', {
+                        ...requestParams,
+                        tokenAddress: eurcAddress
+                    }, operationContext);
+                    break;
+                }
             default:
                 {
                     throw createUnsupportedTokenError(String(token), fromChain.name);
@@ -37016,12 +37474,13 @@ const tokens = createTokenRegistry();
  * Fully prepares and executes the send transaction to transfer the specified amount and
  * token to the specified destination.
  *
- * For known token aliases ('USDC', 'USDT', 'NATIVE'), uses optimized dedicated actions.
- * For custom token addresses, uses the generic token.transfer action with dynamically
- * fetched decimals.
+ * For the 'USDC', 'USDT', and 'NATIVE' aliases, uses optimized dedicated actions.
+ * The 'EURC' alias resolves to the chain's `eurcAddress` and routes through the generic
+ * token.transfer action. For custom token addresses, uses the generic token.transfer action
+ * with dynamically fetched decimals.
  *
  * @param params - The send parameters: source context, destination (address or adapter),
- * human-readable `amount`, and optional `token` ('USDC' | 'USDT' | 'NATIVE' or custom address, defaults to 'USDC').
+ * human-readable `amount`, and optional `token` ('USDC' | 'USDT' | 'NATIVE' | 'EURC' or custom address, defaults to 'USDC').
  * @returns A BridgeStep object with transaction details including hash, status, and explorer URL.
  * @throws KitError INPUT_VALIDATION_FAILED if parameters are invalid.
  * @throws KitError INPUT_UNSUPPORTED_TOKEN if the token is invalid for the chain.
@@ -37039,6 +37498,17 @@ const tokens = createTokenRegistry();
  * console.log('Transaction hash:', step.txHash)
  * ```
  *
+ * @example Sending EURC on a chain where EURC is deployed (e.g. Arc Testnet)
+ * ```typescript
+ * const step = await send({
+ *   from: { adapter: sourceAdapter, chain: 'Arc_Testnet' },
+ *   to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+ *   amount: '5.0',
+ *   token: 'EURC',
+ * })
+ * console.log('Transaction hash:', step.txHash)
+ * ```
+ *
  * @example Sending a custom token (DAI) to an explicit address
  * ```typescript
  * const step = await send({
@@ -37080,21 +37550,22 @@ const tokens = createTokenRegistry();
 };
 
 /**
- * Estimate the network fees to send USDC, USDT, or a supported native token.
+ * Estimate the network fees to send USDC, USDT, EURC, or a supported native token.
  *
  * Prepare the send operation (including validating inputs and resolving the recipient when
  * provided as an adapter) and return an {@link EstimatedGas} object. This function does
  * not submit any transaction.
  *
  * @remarks
- * - Selects the transfer handler based on `token` ('USDC' by default, 'USDT', or 'NATIVE').
+ * - Selects the transfer handler based on `token` ('USDC' by default, 'USDT', 'NATIVE', or 'EURC').
+ *   'EURC' is only supported on chains where `eurcAddress` is configured.
  * - When `to` is an {@link Adapter}, the recipient address is derived from the adapter.
  * - Rejects transfers where the resolved `to` equals the source `from` address.
  * - Interprets `amount` as a human-readable decimal string (USDC and USDT scaled to 6 decimals,
  *   native EVM value typically scaled to 18 decimals).
  *
  * @param params - The send parameters: source context, destination (address or adapter),
- * human-readable `amount`, and optional `token` ('USDC' | 'USDT' | 'NATIVE', defaults to 'USDC').
+ * human-readable `amount`, and optional `token` ('USDC' | 'USDT' | 'NATIVE' | 'EURC', defaults to 'USDC').
  * @returns The estimated gas information including `gas`, `gasPrice`, and total `fee`.
  * @throws Error If parameters are invalid.
  * @throws Error If the token is unsupported or the send cannot be prepared.
@@ -37801,7 +38272,7 @@ async function deposit$2(context, params) {
 }
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.2.0";
+var version = "1.2.2";
 var pkg = {
 	name: name,
 	version: version};