@circle-fin/app-kit 1.8.1 → 1.9.0

package/index.mjs

@@ -22,6 +22,7 @@ import { parseUnits as parseUnits$1, formatUnits as formatUnits$1 } from '@ether
 import { hexlify, hexZeroPad } from '@ethersproject/bytes';
 import { getAddress } from '@ethersproject/address';
 import bs58 from 'bs58';
+import '@ethersproject/abi';
 import { PublicKey } from '@solana/web3.js';
 import 'bn.js';
 import '@coral-xyz/anchor';
@@ -3551,7 +3552,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
@@ -3627,6 +3628,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'
     }
 };
 
@@ -3654,7 +3660,7 @@ function getOptionalString(value) {
  *
  * 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,13 @@ function getOptionalString(value) {
             recoverability: 'FATAL'
         }
     ],
+    [
+        380416,
+        {
+            errorDef: EarnError.POSITION_PNL_PENDING,
+            recoverability: 'RETRYABLE'
+        }
+    ],
     // Bridge (380_5XX)
     [
         380500,
@@ -3985,6 +3998,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";
@@ -4067,6 +4082,7 @@ var BridgeChain;
     BridgeChain["Avalanche"] = "Avalanche";
     BridgeChain["Base"] = "Base";
     BridgeChain["Codex"] = "Codex";
+    BridgeChain["Cronos"] = "Cronos";
     BridgeChain["Edge"] = "Edge";
     BridgeChain["Ethereum"] = "Ethereum";
     BridgeChain["HyperEVM"] = "HyperEVM";
@@ -4091,6 +4107,7 @@ var BridgeChain;
     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";
@@ -5157,6 +5174,96 @@ var EarnChain;
     }
 });
 
+/**
+ * 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: 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: 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
@@ -7508,6 +7615,8 @@ var Chains = /*#__PURE__*/Object.freeze({
   CeloAlfajoresTestnet: CeloAlfajoresTestnet,
   Codex: Codex,
   CodexTestnet: CodexTestnet,
+  Cronos: Cronos,
+  CronosTestnet: CronosTestnet,
   Edge: Edge,
   EdgeTestnet: EdgeTestnet,
   Ethereum: Ethereum,
@@ -9882,6 +9991,7 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Base]: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
         [Blockchain.Celo]: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
         [Blockchain.Codex]: '0xd996633a415985DBd7D6D12f4A4343E31f5037cf',
+        [Blockchain.Cronos]: '0x3D7F2C478aAfdB65542BCB44bCeeC05849999d2D',
         [Blockchain.Edge]: '0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c',
         [Blockchain.Ethereum]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
         [Blockchain.Hedera]: '0.0.456858',
@@ -9915,6 +10025,7 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Avalanche_Fuji]: '0x5425890298aed601595a70AB815c96711a31Bc65',
         [Blockchain.Base_Sepolia]: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
         [Blockchain.Codex_Testnet]: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f',
+        [Blockchain.Cronos_Testnet]: '0xEb33dc5fac03833e132593659e1dE7256aB59794',
         [Blockchain.Edge_Testnet]: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B',
         [Blockchain.Ethereum_Sepolia]: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
         [Blockchain.Hedera_Testnet]: '0.0.429274',
@@ -9987,6 +10098,7 @@ function parseOrThrow(value, schema, context) {
         // =========================================================================
         [Blockchain.Avalanche]: '0xc891EB4cbdEFf6e073e859e987815Ed1505c2ACD',
         [Blockchain.Base]: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+        [Blockchain.Cronos]: '0xA6dE01a2d62C6B5f3525d768f34d276652C554c8',
         [Blockchain.Ethereum]: '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
         [Blockchain.Solana]: 'HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr',
         [Blockchain.World_Chain]: '0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B',
@@ -9995,6 +10107,7 @@ function parseOrThrow(value, schema, context) {
         // =========================================================================
         [Blockchain.Arc_Testnet]: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
         [Blockchain.Base_Sepolia]: '0x808456652fdb597867f38412077A9182bf77359F',
+        [Blockchain.Cronos_Testnet]: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46',
         [Blockchain.Ethereum_Sepolia]: '0x08210F9170F89Ab7658F0B5E3fF39b0E03C594D4'
     }
 };
@@ -11509,11 +11622,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.1";
-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');
 /**
@@ -13539,7 +13652,7 @@ var TransferSpeed;
     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 = {
@@ -14209,6 +14322,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.
  *
@@ -14237,6 +14359,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.
@@ -14383,10 +14526,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);
 };
 /**
@@ -14429,11 +14569,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);
 };
 /**
@@ -14493,10 +14631,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);
 };
 /**
@@ -14562,14 +14697,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.
@@ -15444,6 +15704,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
  *
@@ -15458,7 +15720,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'
@@ -15471,7 +15733,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, {
@@ -15543,7 +15807,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)
     });
 }
 
@@ -15570,7 +15835,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)
     });
 }
 
@@ -15656,11 +15922,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 {
@@ -15698,136 +15971,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.
  *
@@ -15841,6 +15984,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
@@ -15849,10 +15993,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',
@@ -15868,7 +16015,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) {
@@ -15962,7 +16109,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,
@@ -15970,7 +16117,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({
@@ -16301,16 +16451,16 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$3 = "1.8.5";
-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.
@@ -16683,7 +16833,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.
@@ -17007,6 +17157,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.
  *
@@ -17075,9 +17258,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,
@@ -17503,11 +17715,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) {
@@ -17524,6 +17732,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
@@ -17577,11 +17828,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;
@@ -17866,8 +18113,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
+        } : {})
     ];
 
 /**
@@ -17978,7 +18230,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.
  *
@@ -18019,7 +18271,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.
@@ -18110,7 +18362,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 ?? []
@@ -18119,7 +18373,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){
@@ -18641,7 +18895,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.
@@ -18690,6 +18944,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) {
@@ -18707,11 +18964,11 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
     return kit;
 };
 
-var name$2 = "@circle-fin/swap-kit";
-var version$2 = "1.3.1";
-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 = z.custom((value)=>chainIdentifierSchema.safeParse(value).success, {
     message: 'chain must be a valid chain identifier'
@@ -30081,7 +30338,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.
  *
@@ -30204,7 +30461,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
         };
     }
@@ -30660,7 +30917,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.
@@ -30755,11 +31012,11 @@ registerKit(`${pkg$2.name}/${pkg$2.version}`);
     return kit;
 };
 
-var name$1 = "@circle-fin/earn-kit";
-var version$1 = "1.2.1";
-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'
@@ -32331,10 +32588,11 @@ const bridgeDepositPrepareReviewSchema = z.object({
  * 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 = z.object({
@@ -32606,6 +32864,60 @@ const bridgeDepositPrepareReviewSchema = z.object({
     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).
@@ -32616,9 +32928,16 @@ const bridgeDepositPrepareReviewSchema = z.object({
  * @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
         };
     }
@@ -32634,6 +32953,7 @@ const bridgeDepositPrepareReviewSchema = z.object({
             ...DEFAULT_CONFIG,
             headers: {
                 ...DEFAULT_CONFIG.headers,
+                [SDK_VERSION_HEADER]: sdkVersion,
                 Authorization: `Bearer ${serviceConfig.kitKey}`
             }
         },
@@ -33366,9 +33686,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
@@ -36587,7 +36913,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.
@@ -36682,12 +37008,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.
@@ -36714,7 +37045,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.
@@ -36744,7 +37075,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
  *
@@ -36998,8 +37329,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.
@@ -37092,6 +37426,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);
@@ -37118,12 +37467,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.
@@ -37141,6 +37491,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({
@@ -37182,21 +37543,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.
@@ -37903,7 +38265,7 @@ async function deposit$2(context, params) {
 }
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.2.1";
+var version = "1.2.2";
 var pkg = {
 	name: name,
 	version: version};