@circle-fin/provider-cctp-v2 1.8.5 → 1.9.0

package/index.cjs

@@ -35,6 +35,7 @@ var units = require('@ethersproject/units');
 var bytes = require('@ethersproject/bytes');
 var address = require('@ethersproject/address');
 var bs58 = require('bs58');
+require('@ethersproject/abi');
 
 function _interopDefault (e) { return e && e.__esModule ? e.default : e; }
 
@@ -84,6 +85,8 @@ var bs58__default = /*#__PURE__*/_interopDefault(bs58);
     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";
@@ -166,6 +169,7 @@ var BridgeChain;
     BridgeChain["Avalanche"] = "Avalanche";
     BridgeChain["Base"] = "Base";
     BridgeChain["Codex"] = "Codex";
+    BridgeChain["Cronos"] = "Cronos";
     BridgeChain["Edge"] = "Edge";
     BridgeChain["Ethereum"] = "Ethereum";
     BridgeChain["HyperEVM"] = "HyperEVM";
@@ -190,6 +194,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";
@@ -1235,6 +1240,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
@@ -3586,6 +3681,8 @@ var Chains = {
   CeloAlfajoresTestnet: CeloAlfajoresTestnet,
   Codex: Codex,
   CodexTestnet: CodexTestnet,
+  Cronos: Cronos,
+  CronosTestnet: CronosTestnet,
   Edge: Edge,
   EdgeTestnet: EdgeTestnet,
   Ethereum: Ethereum,
@@ -7360,6 +7457,7 @@ class KitError extends Error {
         [Blockchain.Base]: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
         [Blockchain.Celo]: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
         [Blockchain.Codex]: '0xd996633a415985DBd7D6D12f4A4343E31f5037cf',
+        [Blockchain.Cronos]: '0x3D7F2C478aAfdB65542BCB44bCeeC05849999d2D',
         [Blockchain.Edge]: '0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c',
         [Blockchain.Ethereum]: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
         [Blockchain.Hedera]: '0.0.456858',
@@ -7393,6 +7491,7 @@ class KitError extends Error {
         [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',
@@ -7465,6 +7564,7 @@ class KitError extends Error {
         // =========================================================================
         [Blockchain.Avalanche]: '0xc891EB4cbdEFf6e073e859e987815Ed1505c2ACD',
         [Blockchain.Base]: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+        [Blockchain.Cronos]: '0xA6dE01a2d62C6B5f3525d768f34d276652C554c8',
         [Blockchain.Ethereum]: '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
         [Blockchain.Solana]: 'HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr',
         [Blockchain.World_Chain]: '0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B',
@@ -7473,6 +7573,7 @@ class KitError extends Error {
         // =========================================================================
         [Blockchain.Arc_Testnet]: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
         [Blockchain.Base_Sepolia]: '0x808456652fdb597867f38412077A9182bf77359F',
+        [Blockchain.Cronos_Testnet]: '0x31f7538adb53cF16350e6B0c89d03D91b7D12c46',
         [Blockchain.Ethereum_Sepolia]: '0x08210F9170F89Ab7658F0B5E3fF39b0E03C594D4'
     }
 };
@@ -9182,6 +9283,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.
  *
@@ -9210,6 +9320,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,
+        ...internalDefaults,
+        ...config,
+        headers: {
+            ...DEFAULT_CONFIG.headers,
+            ...internalDefaults.headers,
+            ...config.headers
+        }
+    });
 /**
  * Type guard that verifies if an unknown value matches the AttestationMessage shape
  * and has all required properties.
@@ -9356,10 +9487,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,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config);
     return await pollApiGet(url, isAttestationResponse, effectiveConfig);
 };
 /**
@@ -9402,11 +9530,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,
-        maxRetries: 3,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config, {
+        maxRetries: 3
+    });
     return await pollApiGet(url, isAttestationResponseWithoutStatusCheck, effectiveConfig);
 };
 /**
@@ -9466,10 +9592,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,
-        ...config
-    };
+    const effectiveConfig = mergeAttestationConfig(config);
     return await pollApiGet(url, isReAttestedAttestationResponse, effectiveConfig);
 };
 /**
@@ -9535,14 +9658,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,
-        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.
@@ -10417,6 +10665,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
  *
@@ -10431,7 +10681,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'
@@ -10444,7 +10694,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, {
@@ -10516,7 +10768,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)
     });
 }
 
@@ -10543,7 +10796,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)
     });
 }
 
@@ -10629,11 +10883,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 {
@@ -10671,136 +10932,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,
-        ...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.
  *
@@ -10814,6 +10945,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
@@ -10822,10 +10954,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',
@@ -10841,7 +10976,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) {
@@ -10935,7 +11070,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,
@@ -10943,7 +11078,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({
@@ -12152,7 +12290,7 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version = "1.8.5";
+var version = "1.9.0";
 var pkg = {
 	version: version};
 
@@ -13178,6 +13316,39 @@ var pkg = {
     }
 }
 
+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(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(`${field}.${name}`, value, 'header values must be strings');
+        }
+    }
+}
+function assertCCTPV2Config(config) {
+    if (!isPlainObject(config)) {
+        throw createValidationFailedError('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('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.
  *
@@ -13246,9 +13417,38 @@ var pkg = {
    * @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,
@@ -13674,11 +13874,7 @@ var pkg = {
    */ 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) {
@@ -13695,6 +13891,49 @@ var pkg = {
         }
     }
     /**
+   * 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('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
@@ -13748,11 +13987,7 @@ var pkg = {
             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;