@circle-fin/usdckit 0.24.1 → 0.25.1

package/dist/esm/providers/circle-wallets/index.js

@@ -52,6 +52,7 @@ export const SUPPORTED_CONTRACT_QUERY_CHAINS = [
     MATIC_AMOY,
     ARB,
     ARB_SEPOLIA,
+    ARC_TESTNET,
     UNI,
     UNI_SEPOLIA,
     BASE,

package/dist/esm/providers/circle-wallets/transports/index.js

@@ -116,17 +116,47 @@ export class Provider extends BaseProvider {
     }
     async eth_call(params, blockIdentifier = 'latest') {
         // NOTE: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call
-        // In JSON-RPC `eth_call` spec, blockIdentifier is a required parameter.
-        // It is a hex string of the block number, 'latest', 'earliest', 'pending', 'safe' or 'finalized'.
-        // Although Circle's query contract API does not support it, we still add it to be compatible with the JSON-RPC spec.
+        // Circle's query contract API has a narrow surface (blockchain, to, data, from). For anything
+        // it cannot represent, throw `MethodNotFoundRpcError` so `Provider.request` falls back to the
+        // embedded viem RPC transport instead of hard-failing the caller. This matters in particular
+        // for viem-based adapters (e.g. the Circle Wallets adapter's pre-flight `publicClient.call`
+        // during a swap), which forward `gas`/`value` into `eth_call` as a matter of course.
         if (blockIdentifier !== 'latest') {
-            throw new Error('Only `latest` block identifier is supported');
+            throw new MethodNotFoundRpcError(new Error('Only `latest` block identifier is supported by Circle queryContract'), {
+                method: 'eth_call',
+            });
+        }
+        // gas / gasPrice / maxFeePerGas / maxPriorityFeePerGas are EVM-visible during the target
+        // call: `gas` bounds `gasleft()` and affects out-of-gas behavior; the fee fields determine
+        // `tx.gasprice`, which contracts can read. Circle's queryContract cannot thread these
+        // through, so surface `MethodNotFoundRpcError` to trigger fallback rather than silently
+        // returning an SCP result that ignored the caller's explicit simulation constraints.
+        const gasPricingParams = ['gas', 'gasPrice', 'maxFeePerGas', 'maxPriorityFeePerGas'];
+        if (gasPricingParams.some((param) => params[param] !== undefined)) {
+            throw new MethodNotFoundRpcError(new Error('gas / gasPrice / maxFeePerGas / maxPriorityFeePerGas are not supported by Circle queryContract'), { method: 'eth_call' });
+        }
+        // `nonce` is transaction-level and not EVM-visible inside eth_call, so silently drop it —
+        // forwarding would be a no-op and throwing would break callers that forward nonce for parity.
+        // `value` is the one remaining param with read semantics (payable view calls). `0x0` / `0n`
+        // mean "no native value" and are accepted; anything else cannot be expressed through
+        // queryContract, so fall back to the RPC transport. Accept both the typed `bigint` and the
+        // runtime JSON-RPC `Hex` shape (viem's `TransactionRequest.value` is typed `bigint`, but
+        // transports deliver hex).
+        const rawValue = params.value;
+        let valueAsBigInt;
+        if (rawValue === undefined) {
+            valueAsBigInt = 0n;
         }
-        // Since Circle's query contract API does not support some transaction params,
-        // to prevent misuse, we throw an error if they are provided.
-        const unsupportedTransactionParams = ['gas', 'gasPrice', 'maxFeePerGas', 'maxPriorityFeePerGas', 'nonce', 'value'];
-        if (unsupportedTransactionParams.some((param) => params[param] !== undefined)) {
-            throw new Error(`Unsupported transaction params: ${unsupportedTransactionParams.join(', ')}`);
+        else if (typeof rawValue === 'bigint') {
+            valueAsBigInt = rawValue;
+        }
+        else {
+            valueAsBigInt = hexToBigInt(rawValue);
+        }
+        if (valueAsBigInt !== 0n) {
+            throw new MethodNotFoundRpcError(new Error('Non-zero `value` is not supported by Circle queryContract'), {
+                method: 'eth_call',
+            });
         }
         // Provider's chainId is used to determine the blockchain
         // When the chain is not supported by Circle's query contract API, throw MethodNotFoundRpcError to fallback.

package/dist/esm/providers/circle-wallets/transports/index.test.js

@@ -1851,12 +1851,21 @@ describe('Provider', () => {
         });
     });
     describe('eth_call', () => {
+        // Build a provider with `fallbackTransport: null` so the inner `eth_call` errors
+        // surface raw instead of being silently retried on the fallback RPC transport.
+        // The production default IS to fall back; these tests pin the inner contract.
+        const makeProviderWithoutFallback = (chainId) => new Provider({
+            apiKey: 'test-api-key',
+            entitySecret: 'test-entity-secret',
+            chainId,
+            fallbackTransport: null,
+        });
+        const baseParams = {
+            to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
+            data: '0x70a08231000000000000000000000000742d35cc6634c0532925a3b8d0c8c0c8d8d8d8d8',
+            from: '0x123456789abcdef123456789abcdef123456789a',
+        };
         it('should perform contract query successfully', async () => {
-            const params = {
-                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
-                data: '0x70a08231000000000000000000000000742d35cc6634c0532925a3b8d0c8c0c8d8d8d8d8',
-                from: '0x123456789abcdef123456789abcdef123456789a',
-            };
             mockScp.queryContract.mockResolvedValue({
                 data: {
                     outputData: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
@@ -1864,36 +1873,18 @@ describe('Provider', () => {
             });
             const result = await provider.request({
                 method: 'eth_call',
-                params: [params],
+                params: [baseParams],
             });
             expect(result).toBe('0x0000000000000000000000000000000000000000000000000de0b6b3a7640000');
             expect(mockScp.queryContract).toHaveBeenCalledWith({
                 blockchain: 'ETH',
-                address: params.to,
-                callData: params.data,
-                fromAddress: params.from,
+                address: baseParams.to,
+                callData: baseParams.data,
+                fromAddress: baseParams.from,
             });
         });
-        it('should throw UnsupportedChainError when chainId is not supported for contract queries', async () => {
-            const provider = new Provider({
-                apiKey: 'test-api-key',
-                entitySecret: 'test-entity-secret',
-                chainId: 999999, // Unsupported chain
-            });
-            const params = {
-                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
-                data: '0x70a08231',
-            };
-            await expect(provider.request({
-                method: 'eth_call',
-                params: [params],
-            })).rejects.toThrow();
-        });
         it('should work without from parameter', async () => {
-            const params = {
-                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
-                data: '0x70a08231000000000000000000000000742d35cc6634c0532925a3b8d0c8c0c8d8d8d8d8',
-            };
+            const params = { to: baseParams.to, data: baseParams.data };
             mockScp.queryContract.mockResolvedValue({
                 data: {
                     outputData: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
@@ -1911,52 +1902,111 @@ describe('Provider', () => {
                 fromAddress: undefined,
             });
         });
-        it('should throw error when blockIdentifier is not "latest"', async () => {
-            const params = {
-                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
-                data: '0x70a08231',
-            };
+        // gas / gasPrice / maxFeePerGas / maxPriorityFeePerGas are EVM-visible during the call:
+        // `gas` affects `gasleft()` and the fee fields determine `tx.gasprice`. Circle's
+        // queryContract cannot represent them, so surface MethodNotFoundRpcError to trigger
+        // fallback rather than silently returning an SCP result that ignored the constraints.
+        it.each([
+            { label: 'gas', param: { gas: numberToHex(1000000n) } },
+            { label: 'gasPrice', param: { gasPrice: numberToHex(parseEther('0.00000001')) } },
+            { label: 'maxFeePerGas', param: { maxFeePerGas: numberToHex(parseEther('0.00000001')) } },
+            {
+                label: 'maxPriorityFeePerGas',
+                param: { maxPriorityFeePerGas: numberToHex(parseEther('0.000000001')) },
+            },
+        ])('should throw MethodNotFoundRpcError when $label is set (fallback trigger)', async ({ param }) => {
+            const provider = makeProviderWithoutFallback(1);
             await expect(provider.request({
                 method: 'eth_call',
-                params: [params, 'earliest'],
-            })).rejects.toThrow('Only `latest` block identifier is supported');
+                params: [{ ...baseParams, ...param }],
+            })).rejects.toBeInstanceOf(MethodNotFoundRpcError);
+            expect(mockScp.queryContract).not.toHaveBeenCalled();
+        });
+        // `nonce` is transaction-level and not visible inside eth_call, so it's fine to silently
+        // drop — forwarding would be a no-op and throwing would break callers (e.g. viem's
+        // publicClient.call) that may surface nonce for parity with standard JSON-RPC shapes.
+        it('should silently ignore nonce', async () => {
+            mockScp.queryContract.mockResolvedValue({ data: { outputData: '0xok' } });
+            const result = await provider.request({
+                method: 'eth_call',
+                params: [{ ...baseParams, nonce: numberToHex(42n) }],
+            });
+            expect(result).toBe('0xok');
+            // nonce must not be forwarded — queryContract only accepts {blockchain, to, data, from}.
+            expect(mockScp.queryContract).toHaveBeenCalledWith({
+                blockchain: 'ETH',
+                address: baseParams.to,
+                callData: baseParams.data,
+                fromAddress: baseParams.from,
+            });
+        });
+        // `value` arrives as a `Hex` at runtime from JSON-RPC transports, but the
+        // TypeScript surface (`ExactPartial<TransactionRequest>`) admits `bigint`.
+        // Exercise both shapes so the dual-type contract is regression-tested.
+        it.each([
+            { label: 'hex 0x0', value: '0x0' },
+            { label: 'bigint 0n', value: 0n },
+        ])('should accept zero value ($label) as equivalent to no native value', async ({ value }) => {
+            mockScp.queryContract.mockResolvedValue({ data: { outputData: '0xzero' } });
+            const result = await provider.request({
+                method: 'eth_call',
+                params: [{ ...baseParams, value }],
+            });
+            expect(result).toBe('0xzero');
+            expect(mockScp.queryContract).toHaveBeenCalledTimes(1);
+        });
+        // `value` is the one param with read semantics (payable view calls). Non-zero must
+        // surface `MethodNotFoundRpcError` so `Provider.request` falls back to the RPC transport.
+        // Again, cover both the hex and bigint shapes.
+        it.each([
+            { label: 'hex 0x1', value: numberToHex(1n) },
+            { label: 'bigint 1n', value: 1n },
+        ])('should throw MethodNotFoundRpcError for non-zero value ($label) (fallback trigger)', async ({ value }) => {
+            const provider = makeProviderWithoutFallback(1);
             await expect(provider.request({
                 method: 'eth_call',
-                params: [params, '0x1234'],
-            })).rejects.toThrow('Only `latest` block identifier is supported');
+                params: [{ ...baseParams, value }],
+            })).rejects.toBeInstanceOf(MethodNotFoundRpcError);
+            expect(mockScp.queryContract).not.toHaveBeenCalled();
         });
-        it('should throw error when unsupported transaction params are provided', async () => {
-            const baseParams = {
-                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
-                data: '0x70a08231',
-            };
-            // Test each unsupported parameter individually
-            const unsupportedParams = [
-                { gas: '0x186A0' },
-                { gasPrice: '0x3B9ACA00' },
-                { maxFeePerGas: '0x3B9ACA00' },
-                { maxPriorityFeePerGas: '0x3B9ACA00' },
-                { nonce: '0x1' },
-                { value: '0x0' },
-            ];
-            for (const param of unsupportedParams) {
-                const testParams = { ...baseParams, ...param };
-                await expect(provider.request({
-                    method: 'eth_call',
-                    params: [testParams],
-                })).rejects.toThrow();
-            }
-            // Test multiple unsupported params together
-            const multipleUnsupportedParams = {
-                ...baseParams,
-                gas: '0x186A0',
-                value: '0x0',
-                nonce: '0x1',
-            };
+        it('should throw MethodNotFoundRpcError when blockIdentifier is not "latest" (fallback trigger)', async () => {
+            const provider = makeProviderWithoutFallback(1);
             await expect(provider.request({
                 method: 'eth_call',
-                params: [multipleUnsupportedParams],
-            })).rejects.toThrow();
+                params: [baseParams, 'earliest'],
+            })).rejects.toBeInstanceOf(MethodNotFoundRpcError);
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [baseParams, '0x1234'],
+            })).rejects.toBeInstanceOf(MethodNotFoundRpcError);
+            expect(mockScp.queryContract).not.toHaveBeenCalled();
+        });
+        // AVAX_FUJI (43113) is in SUPPORTED_CHAINS but NOT SUPPORTED_CONTRACT_QUERY_CHAINS.
+        it('should throw MethodNotFoundRpcError when chain is not supported by queryContract (fallback trigger)', async () => {
+            const provider = makeProviderWithoutFallback(43113);
+            await expect(provider.request({ method: 'eth_call', params: [baseParams] })).rejects.toBeInstanceOf(MethodNotFoundRpcError);
+            expect(mockScp.queryContract).not.toHaveBeenCalled();
+        });
+        // ARC_TESTNET (5042002) IS in SUPPORTED_CONTRACT_QUERY_CHAINS — reads flow through Circle's SCP.
+        it('should route Arc Testnet eth_call through queryContract', async () => {
+            // `vi.restoreAllMocks` in the outer beforeEach clears the module-level mock
+            // return; re-prime it before constructing a second Provider for Arc Testnet.
+            ;
+            initiateSmartContractPlatformClient.mockReturnValue(mockScp);
+            const arcProvider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 5042002, // ARC_TESTNET
+            });
+            mockScp.queryContract.mockResolvedValue({ data: { outputData: '0xarc' } });
+            const result = await arcProvider.request({ method: 'eth_call', params: [baseParams] });
+            expect(result).toBe('0xarc');
+            expect(mockScp.queryContract).toHaveBeenCalledWith({
+                blockchain: 'ARC-TESTNET',
+                address: baseParams.to,
+                callData: baseParams.data,
+                fromAddress: baseParams.from,
+            });
         });
     });
     describe('eth_estimateGas', () => {

package/dist/esm/providers/cross-chain-transfer-protocol/chains/ARB.d.ts

@@ -255,8 +255,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 3;
     readonly blockchainId: "ARB";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/ARB_SEPOLIA.d.ts

@@ -255,8 +255,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 3;
     readonly blockchainId: "ARB-SEPOLIA";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/AVAX.d.ts

@@ -537,8 +537,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 1;
     readonly blockchainId: "AVAX";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/AVAX_FUJI.d.ts

@@ -396,8 +396,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 1;
     readonly blockchainId: "AVAX-FUJI";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/BASE.d.ts

@@ -436,6 +436,7 @@ export declare const chain: {
     sourceId: 1;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -501,16 +502,16 @@ export declare const chain: {
                 r: import("viem").Hex;
                 s: import("viem").Hex;
                 v: bigint;
-                value: bigint;
-                gas: bigint;
                 to: import("viem").Address | null;
                 from: import("viem").Address;
+                gas: bigint;
                 nonce: number;
+                value: bigint;
                 blockHash: `0x${string}` | null;
                 blockNumber: bigint | null;
-                transactionIndex: number | null;
                 hash: import("viem").Hash;
                 input: import("viem").Hex;
+                transactionIndex: number | null;
                 typeHex: import("viem").Hex | null;
                 accessList?: undefined | undefined;
                 authorizationList?: undefined | undefined;
@@ -647,6 +648,7 @@ export declare const chain: {
                 blobGasUsed?: bigint | undefined;
                 blockHash: import("viem").Hash;
                 blockNumber: bigint;
+                blockTimestamp?: bigint | undefined;
                 contractAddress: import("viem").Address | null | undefined;
                 cumulativeGasUsed: bigint;
                 effectiveGasPrice: bigint;
@@ -668,9 +670,17 @@ export declare const chain: {
             type: "transactionReceipt";
         };
     };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers: {
         readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
     };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 6;
     readonly blockchainId: "BASE";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/BASE_SEPOLIA.d.ts

@@ -436,6 +436,7 @@ export declare const chain: {
     sourceId: 11155111;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -501,16 +502,16 @@ export declare const chain: {
                 r: import("viem").Hex;
                 s: import("viem").Hex;
                 v: bigint;
-                value: bigint;
-                gas: bigint;
                 to: import("viem").Address | null;
                 from: import("viem").Address;
+                gas: bigint;
                 nonce: number;
+                value: bigint;
                 blockHash: `0x${string}` | null;
                 blockNumber: bigint | null;
-                transactionIndex: number | null;
                 hash: import("viem").Hash;
                 input: import("viem").Hex;
+                transactionIndex: number | null;
                 typeHex: import("viem").Hex | null;
                 accessList?: undefined | undefined;
                 authorizationList?: undefined | undefined;
@@ -647,6 +648,7 @@ export declare const chain: {
                 blobGasUsed?: bigint | undefined;
                 blockHash: import("viem").Hash;
                 blockNumber: bigint;
+                blockTimestamp?: bigint | undefined;
                 contractAddress: import("viem").Address | null | undefined;
                 cumulativeGasUsed: bigint;
                 effectiveGasPrice: bigint;
@@ -668,9 +670,17 @@ export declare const chain: {
             type: "transactionReceipt";
         };
     };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers: {
         readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
     };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 6;
     readonly blockchainId: "BASE-SEPOLIA";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/ETH.d.ts

@@ -541,8 +541,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 0;
     readonly blockchainId: "ETH";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/ETH_SEPOLIA.d.ts

@@ -400,8 +400,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 0;
     readonly blockchainId: "ETH-SEPOLIA";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/MATIC.d.ts

@@ -3,7 +3,7 @@ export declare const chain: {
         readonly default: {
             readonly name: "PolygonScan";
             readonly url: "https://polygonscan.com";
-            readonly apiUrl: "https://api.polygonscan.com/api";
+            readonly apiUrl: "https://api.etherscan.io/v2/api";
         };
     };
     blockTime: 2000;
@@ -249,14 +249,23 @@ export declare const chain: {
     experimental_preconfirmationTime?: number | undefined | undefined;
     rpcUrls: {
         readonly default: {
-            readonly http: readonly ["https://polygon-rpc.com"];
+            readonly http: readonly ["https://polygon.drpc.org"];
         };
     };
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 7;
     readonly blockchainId: "MATIC";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/MATIC_AMOY.d.ts

@@ -3,7 +3,7 @@ export declare const chain: {
         readonly default: {
             readonly name: "PolygonScan";
             readonly url: "https://amoy.polygonscan.com";
-            readonly apiUrl: "https://api-amoy.polygonscan.com/api";
+            readonly apiUrl: "https://api.etherscan.io/v2/api";
         };
     };
     blockTime?: number | undefined | undefined;
@@ -255,8 +255,17 @@ export declare const chain: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 7;
     readonly blockchainId: "MATIC-AMOY";
     readonly blockchainVm: "EVM";

package/dist/esm/providers/cross-chain-transfer-protocol/chains/OP.d.ts

@@ -293,6 +293,7 @@ export declare const chain: {
     sourceId: 1;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -358,16 +359,16 @@ export declare const chain: {
                 r: import("viem").Hex;
                 s: import("viem").Hex;
                 v: bigint;
-                value: bigint;
-                gas: bigint;
                 to: import("viem").Address | null;
                 from: import("viem").Address;
+                gas: bigint;
                 nonce: number;
+                value: bigint;
                 blockHash: `0x${string}` | null;
                 blockNumber: bigint | null;
-                transactionIndex: number | null;
                 hash: import("viem").Hash;
                 input: import("viem").Hex;
+                transactionIndex: number | null;
                 typeHex: import("viem").Hex | null;
                 accessList?: undefined | undefined;
                 authorizationList?: undefined | undefined;
@@ -504,6 +505,7 @@ export declare const chain: {
                 blobGasUsed?: bigint | undefined;
                 blockHash: import("viem").Hash;
                 blockNumber: bigint;
+                blockTimestamp?: bigint | undefined;
                 contractAddress: import("viem").Address | null | undefined;
                 cumulativeGasUsed: bigint;
                 effectiveGasPrice: bigint;
@@ -525,9 +527,17 @@ export declare const chain: {
             type: "transactionReceipt";
         };
     };
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers: {
         readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
     };
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly domainId: 2;
     readonly blockchainId: "OP";
     readonly blockchainVm: "EVM";