@circle-fin/usdckit 0.21.0 → 0.22.0

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

@@ -10,10 +10,13 @@
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { initiateDeveloperControlledWalletsClient } from '@circle-fin/developer-controlled-wallets';
 import { initiateSmartContractPlatformClient } from '@circle-fin/smart-contract-platform';
-import { formatGwei } from 'viem';
+import { formatGwei, MethodNotFoundRpcError, numberToHex, parseEther } from 'viem';
 import { describe, test, expect, vi, beforeEach, it } from 'vitest';
+import { UnsupportedChainError } from '../../../errors/index.js';
 import * as generateIdempotencyKeyMod from '../../../utils/generateIdempotencyKey.js';
+import { AVAX } from '../../cross-chain-transfer-protocol/chains/index.js';
 import { SENTINEL_FEES } from '../index.js';
+import * as circleWalletsIndex from '../index.js';
 import { Provider } from './index.js';
 vi.mock('@circle-fin/smart-contract-platform');
 vi.mock('@circle-fin/developer-controlled-wallets');
@@ -24,6 +27,7 @@ vi.mock('@circle-fin/developer-controlled-wallets', () => ({
 describe('Provider', () => {
     let provider;
     let mockClient;
+    let mockScp;
     beforeEach(() => {
         mockClient = {
             createWalletSet: vi.fn(),
@@ -31,22 +35,29 @@ describe('Provider', () => {
             listWallets: vi.fn(),
             getWallet: vi.fn(),
             estimateTransferFee: vi.fn(),
+            estimateContractExecutionFee: vi.fn(),
             createTransaction: vi.fn(),
+            createContractExecutionTransaction: vi.fn(),
             getTransaction: vi.fn(),
             getWalletTokenBalance: vi.fn(),
             deriveWallet: vi.fn(),
             getNotificationSignature: vi.fn(),
             getWalletsWithBalances: vi.fn(),
             requestTestnetTokens: vi.fn(() => ''),
-            signTypedData: vi.fn(),
             signTransaction: vi.fn(),
+            signTypedData: vi.fn(),
             listTransactions: vi.fn(),
         };
+        mockScp = {
+            queryContract: vi.fn(),
+        };
         initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
+        initiateSmartContractPlatformClient.mockReturnValue(mockScp);
         provider = new Provider({
             apiKey: 'test-api-key',
             entitySecret: 'test-entity-secret',
             baseUrl: 'base-url',
+            chainId: 1,
         });
     });
     beforeEach(() => {
@@ -56,7 +67,7 @@ describe('Provider', () => {
         const params = { name: 'test-wallet-set' };
         const response = { data: { walletSet: 'test-wallet-set-id' } };
         mockClient.createWalletSet.mockResolvedValue(response);
-        const result = await provider.circle_createWalletSet(params);
+        const result = await provider.request({ method: 'circle_createWalletSet', params: [params] });
         expect(result).toBe('test-wallet-set-id');
         expect(mockClient.createWalletSet).toHaveBeenCalledWith(params);
     });
@@ -68,7 +79,7 @@ describe('Provider', () => {
         };
         const response = { data: { wallets: ['wallet1'] } };
         mockClient.createWallets.mockResolvedValue(response);
-        const result = await provider.circle_createWallets(params);
+        const result = await provider.request({ method: 'circle_createWallets', params: [params] });
         expect(result).toEqual(['wallet1']);
         expect(mockClient.createWallets).toHaveBeenCalledWith(params);
     });
@@ -76,7 +87,7 @@ describe('Provider', () => {
         const params = { walletSetId: 'test-wallet-set-id' };
         const response = { data: { wallets: ['wallet1', 'wallet2'] } };
         mockClient.listWallets.mockResolvedValue(response);
-        const result = await provider.circle_listWallets(params);
+        const result = await provider.request({ method: 'circle_listWallets', params: [params] });
         expect(result).toEqual(['wallet1', 'wallet2']);
         expect(mockClient.listWallets).toHaveBeenCalledWith(params);
     });
@@ -88,7 +99,7 @@ describe('Provider', () => {
         ];
         const response = { data: { transactions } };
         mockClient.listTransactions.mockResolvedValue(response);
-        const result = await provider.circle_listTransactions(params);
+        const result = await provider.request({ method: 'circle_listTransactions', params: [params] });
         expect(result).toEqual(transactions);
         expect(mockClient.listTransactions).toHaveBeenCalledWith(params);
     });
@@ -96,7 +107,7 @@ describe('Provider', () => {
         const params = { walletId: 'empty-wallet-id' };
         const response = { data: {} }; // No transactions property
         mockClient.listTransactions.mockResolvedValue(response);
-        const result = await provider.circle_listTransactions(params);
+        const result = await provider.request({ method: 'circle_listTransactions', params: [params] });
         expect(result).toEqual([]);
         expect(mockClient.listTransactions).toHaveBeenCalledWith(params);
     });
@@ -115,7 +126,7 @@ describe('Provider', () => {
             },
         };
         mockClient.estimateTransferFee.mockResolvedValue(response);
-        const result = await provider.circle_estimateTransferFee(params);
+        const result = await provider.request({ method: 'circle_estimateTransferFee', params: [params] });
         expect(result).toEqual({
             high: {
                 gasLimit: '4',
@@ -151,7 +162,7 @@ describe('Provider', () => {
             },
         };
         mockClient.estimateTransferFee.mockResolvedValue(response);
-        const result = await provider.circle_estimateTransferFee(params);
+        const result = await provider.request({ method: 'circle_estimateTransferFee', params: [params] });
         expect(result).toEqual({
             high: {
                 gasLimit: '4',
@@ -185,7 +196,7 @@ describe('Provider', () => {
             const getTransactionResult = { ...createTransactionResult, state: 'COMPLETE', txHash: '0x1234' };
             mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
             mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
-            const result = await provider.circle_createTransaction(params);
+            const result = await provider.request({ method: 'circle_createTransaction', params: [params] });
             expect(mockClient.createTransaction).toHaveBeenCalledWith({
                 walletId: 'test-wallet-id',
                 amount: ['100'],
@@ -210,7 +221,7 @@ describe('Provider', () => {
             const getTransactionResult = { ...createTransactionResult, state: 'COMPLETE', txHash: '0x1234' };
             mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
             mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
-            const result = await provider.circle_createTransaction(params);
+            const result = await provider.request({ method: 'circle_createTransaction', params: [params] });
             expect(mockClient.createTransaction).toHaveBeenCalledWith({
                 walletId: 'test-wallet-id',
                 amount: ['100'],
@@ -244,7 +255,7 @@ describe('Provider', () => {
             });
             mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
             mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
-            const result = await provider.circle_createTransaction(params);
+            const result = await provider.request({ method: 'circle_createTransaction', params: [params] });
             expect(mockClient.createTransaction).toHaveBeenCalledWith({
                 destinationAddress: '0x456',
                 blockchain: 'MATIC-AMOY',
@@ -270,7 +281,74 @@ describe('Provider', () => {
             mockClient.listWallets.mockResolvedValue({
                 data: { wallets: [] },
             });
-            await expect(provider.circle_createTransaction(params)).rejects.toThrowError('156001');
+            await expect(provider.request({ method: 'circle_createTransaction', params: [params] })).rejects.toThrowError('156001');
+        });
+        it('should wait for transaction hash when waitForTransactionHash is true', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: true,
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'QUEUED' };
+            const getTransactionResult = { id: 'transaction-id', state: 'COMPLETE', txHash: '0x123' };
+            mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
+            const result = await provider.request({ method: 'circle_createTransaction', params: [params] });
+            expect(result).toEqual(getTransactionResult);
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: true,
+            });
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({ id: 'transaction-id' });
+        });
+        it('should not wait for transaction hash when waitForTransactionHash is false', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: false,
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'QUEUED' };
+            mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: createTransactionResult } });
+            const result = await provider.request({ method: 'circle_createTransaction', params: [params] });
+            expect(result).toEqual(createTransactionResult);
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: false,
+            });
+            // Should call getTransaction once to get the transaction structure, but not wait for txHash
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({ id: 'transaction-id' });
+            expect(mockClient.getTransaction).toHaveBeenCalledTimes(1);
         });
     });
     describe('circle_getTransaction', () => {
@@ -278,7 +356,7 @@ describe('Provider', () => {
             const params = { id: 'transaction-id' };
             const getTransactionResult = { ...params, state: 'COMPLETE', txHash: '0x123' };
             mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
-            const result = await provider.circle_getTransaction(params);
+            const result = await provider.request({ method: 'circle_getTransaction', params: [params] });
             expect(mockClient.getTransaction).toHaveBeenCalledWith(params);
             expect(result).toMatchObject(getTransactionResult);
         });
@@ -430,7 +508,7 @@ describe('Provider', () => {
             const params = { id: 'wallet-id', blockchain: 'MATIC-AMOY' };
             const expectedResult = { id: 'wallet-id', blockchain: 'MATIC-AMOY' };
             mockClient.deriveWallet.mockResolvedValue({ data: { wallet: expectedResult } });
-            const result = await provider.circle_deriveWallet(params);
+            const result = await provider.request({ method: 'circle_deriveWallet', params: [params] });
             expect(mockClient.deriveWallet).toHaveBeenCalledWith(params);
             expect(result).toEqual(expectedResult);
         });
@@ -440,7 +518,7 @@ describe('Provider', () => {
             const params = { id: 'wallet-id' };
             const expectedResult = { id: 'wallet-id', blockchain: 'ETH-SEPOLIA' };
             mockClient.getWallet.mockResolvedValue({ data: { wallet: expectedResult } });
-            const result = await provider.circle_getWallet(params);
+            const result = await provider.request({ method: 'circle_getWallet', params: [params] });
             expect(mockClient.getWallet).toHaveBeenCalledWith(params);
             expect(result).toEqual(expectedResult);
         });
@@ -515,38 +593,44 @@ describe('Provider', () => {
                 },
             ];
             mockClient.getWalletsWithBalances.mockResolvedValue({ data: { wallets: expectedResult } });
-            const result = await provider.circle_getWalletsWithBalances(params);
+            const result = await provider.request({ method: 'circle_getWalletsWithBalances', params: [params] });
             expect(mockClient.getWalletsWithBalances).toHaveBeenCalledWith(params);
             expect(result).toEqual(expectedResult);
         });
     });
-    describe('circle_signTypedData', () => {
-        it('should return signed typed data', async () => {
+    describe('circle_signTransaction', () => {
+        it('should return signed transaction', async () => {
             const params = {
                 walletId: '00000000-0000-0000-0000-000000000000',
-                data: '{"types": {"Data": [{ "name": "dummy", "type": "string" }],"EIP712Domain":[{ "name": "name", "type": "string" },{ "name": "chainId", "type": "uint256" }]}, "domain": { "name": "Test", "chainId": 1337 }, "primaryType": "Data", "message": { "dummy": "dummy" }}',
+                transaction: '{"nonce":1,"to":"0x9e4ebf23f713268b8e72cd162337f20c536357c9","value":"10000000000000000","gas":"21000","maxFeePerGas":"42000000000","maxPriorityFeePerGas":"25000000000","chainId":80002}',
+                memo: 'hello world',
             };
             const expectedResult = {
-                signature: '3W6r38STvZuBSmk2bbbct132SjEsYSARo3CJi3JQvNUaFoYu',
+                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
+                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
+                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
             };
-            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
-            const result = await provider.circle_signTypedData(params);
-            expect(mockClient.signTypedData).toHaveBeenCalledWith(params);
+            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
+            const result = await provider.request({ method: 'circle_signTransaction', params: [params] });
+            expect(mockClient.signTransaction).toHaveBeenCalledWith(params);
             expect(result).toEqual(expectedResult);
         });
         it('should resolve address and blockchain to walletId', async () => {
             const params = {
                 address: '0x9e4ebf23f713268b8e72cd162337f20c536357c9',
-                blockchain: 'ETH-SEPOLIA',
-                data: '{"types": {"Data": [{ "name": "dummy", "type": "string" }],"EIP712Domain":[{ "name": "name", "type": "string" },{ "name": "chainId", "type": "uint256" }]}, "domain": { "name": "Test", "chainId": 1337 }, "primaryType": "Data", "message": { "dummy": "dummy" }}',
+                blockchain: 'EVM-TESTNET',
+                transaction: '{"nonce":1,"to":"0x9e4ebf23f713268b8e72cd162337f20c536357c9","value":"10000000000000000","gas":"21000","maxFeePerGas":"42000000000","maxPriorityFeePerGas":"25000000000","chainId":80002}',
+                memo: 'hello world',
             };
             const expectedResult = {
-                signature: '3W6r38STvZuBSmk2bbbct132SjEsYSARo3CJi3JQvNUaFoYu',
+                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
+                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
+                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
             };
-            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
+            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
             mockClient.listWallets.mockResolvedValue({ data: { wallets: [{ id: 'my-wallet-id' }] } });
-            await provider.circle_signTypedData(params);
-            expect(mockClient.signTypedData).toHaveBeenCalledWith({
+            await provider.request({ method: 'circle_signTransaction', params: [params] });
+            expect(mockClient.signTransaction).toHaveBeenCalledWith({
                 ...params,
                 address: undefined,
                 blockchain: undefined,
@@ -554,45 +638,154 @@ describe('Provider', () => {
             });
         });
     });
-    describe('circle_signTransaction', () => {
-        it('should return signed transaction', async () => {
+    describe('circle_signTypedData', () => {
+        it('should return signed typed data', async () => {
             const params = {
                 walletId: '00000000-0000-0000-0000-000000000000',
-                transaction: '{"nonce":1,"to":"0x9e4ebf23f713268b8e72cd162337f20c536357c9","value":"10000000000000000","gas":"21000","maxFeePerGas":"42000000000","maxPriorityFeePerGas":"25000000000","chainId":80002}',
-                memo: 'hello world',
+                data: '{"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"wallet","type":"address"}]},"primaryType":"Person","domain":{"name":"Ether Mail","version":"1","chainId":1,"verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"}}',
+                memo: 'test signature',
             };
             const expectedResult = {
-                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
-                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
-                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
+                signature: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
             };
-            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
-            const result = await provider.circle_signTransaction(params);
-            expect(mockClient.signTransaction).toHaveBeenCalledWith(params);
+            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
+            const result = await provider.request({ method: 'circle_signTypedData', params: [params] });
+            expect(mockClient.signTypedData).toHaveBeenCalledWith(params);
             expect(result).toEqual(expectedResult);
         });
         it('should resolve address and blockchain to walletId', async () => {
             const params = {
                 address: '0x9e4ebf23f713268b8e72cd162337f20c536357c9',
-                blockchain: 'EVM-TESTNET',
-                transaction: '{"nonce":1,"to":"0x9e4ebf23f713268b8e72cd162337f20c536357c9","value":"10000000000000000","gas":"21000","maxFeePerGas":"42000000000","maxPriorityFeePerGas":"25000000000","chainId":80002}',
-                memo: 'hello world',
+                blockchain: 'ETH-SEPOLIA',
+                data: '{"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"wallet","type":"address"}]},"primaryType":"Person","domain":{"name":"Ether Mail","version":"1","chainId":1,"verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"}}',
+                memo: 'test signature',
             };
             const expectedResult = {
-                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
-                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
-                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
+                signature: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
             };
-            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
+            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
             mockClient.listWallets.mockResolvedValue({ data: { wallets: [{ id: 'my-wallet-id' }] } });
-            await provider.circle_signTransaction(params);
-            expect(mockClient.signTransaction).toHaveBeenCalledWith({
+            await provider.request({ method: 'circle_signTypedData', params: [params] });
+            expect(mockClient.signTypedData).toHaveBeenCalledWith({
                 ...params,
                 address: undefined,
                 blockchain: undefined,
                 walletId: 'my-wallet-id',
             });
         });
+        it('should throw error when wallet not found for address and blockchain', async () => {
+            const params = {
+                address: '0xNotFound',
+                blockchain: 'ETH-SEPOLIA',
+                data: '{"types":{"EIP712Domain":[]},"primaryType":"Person","domain":{},"message":{}}',
+            };
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+            await expect(provider.request({ method: 'circle_signTypedData', params: [params] })).rejects.toThrowError('156001');
+        });
+    });
+    describe('eth_signTypedData_v4', () => {
+        it('should sign typed data and return signature', async () => {
+            const address = '0x9e4ebf23f713268b8e72cd162337f20c536357c9';
+            const message = '{"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"wallet","type":"address"}]},"primaryType":"Person","domain":{"name":"Ether Mail","version":"1","chainId":1,"verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"}}';
+            const expectedSignature = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12';
+            mockClient.signTypedData.mockResolvedValue({
+                data: { signature: expectedSignature },
+            });
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'my-wallet-id' }] },
+            });
+            const result = await provider.request({ method: 'eth_signTypedData_v4', params: [address, message] });
+            expect(result).toBe(expectedSignature);
+            expect(mockClient.signTypedData).toHaveBeenCalledWith({
+                walletId: 'my-wallet-id',
+                data: message,
+            });
+        });
+        it('should use provider chainId regardless of message domain chainId', async () => {
+            const address = '0x9e4ebf23f713268b8e72cd162337f20c536357c9';
+            // Message contains Sepolia chainId (11155111) in domain, but provider uses mainnet (chainId: 1)
+            const message = '{"types":{"EIP712Domain":[{"name":"chainId","type":"uint256"}],"Person":[]},"primaryType":"Person","domain":{"chainId":11155111},"message":{}}';
+            const expectedSignature = '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890';
+            mockClient.signTypedData.mockResolvedValue({
+                data: { signature: expectedSignature },
+            });
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'mainnet-wallet-id' }] },
+            });
+            const result = await provider.request({ method: 'eth_signTypedData_v4', params: [address, message] });
+            expect(result).toBe(expectedSignature);
+            expect(mockClient.signTypedData).toHaveBeenCalledWith({
+                walletId: 'mainnet-wallet-id',
+                data: message,
+            });
+            // Verify that listWallets was called with ETH blockchain (derived from provider's chainId 1)
+            // not ETH-SEPOLIA (which would be derived from message domain chainId 11155111)
+            expect(mockClient.listWallets).toHaveBeenCalledWith({
+                address,
+                blockchain: 'ETH',
+            });
+        });
+        it('should throw error for unsupported provider chain ID', async () => {
+            // Create a provider with an unsupported chainId
+            const mockUnsupportedClient = {
+                signTypedData: vi.fn(),
+                listWallets: vi.fn(),
+            };
+            initiateDeveloperControlledWalletsClient.mockReturnValueOnce(mockUnsupportedClient);
+            const unsupportedProvider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                chainId: 999999, // Unsupported chainId
+            });
+            const address = '0x9e4ebf23f713268b8e72cd162337f20c536357c9';
+            const message = '{"types":{"EIP712Domain":[{"name":"chainId","type":"uint256"}],"Person":[]},"primaryType":"Person","domain":{"chainId":1},"message":{}}';
+            await expect(unsupportedProvider.request({ method: 'eth_signTypedData_v4', params: [address, message] })).rejects.toThrow();
+        });
+        it('should throw error when wallet not found', async () => {
+            const address = '0xNotFound';
+            const message = '{"types":{"EIP712Domain":[{"name":"chainId","type":"uint256"}],"Person":[]},"primaryType":"Person","domain":{"chainId":1},"message":{}}';
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+            await expect(provider.request({ method: 'eth_signTypedData_v4', params: [address, message] })).rejects.toThrowError('156001');
+        });
+        it('should use provider chainId instead of message domain chainId', async () => {
+            // Mock the client for the new provider instance
+            const mockSepoliaClient = {
+                signTypedData: vi.fn(),
+                listWallets: vi.fn(),
+            };
+            initiateDeveloperControlledWalletsClient.mockReturnValueOnce(mockSepoliaClient);
+            // Create provider with chainId 11155111 (Sepolia)
+            const sepoliaProvider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                chainId: 11155111, // Sepolia chainId
+            });
+            const address = '0x9e4ebf23f713268b8e72cd162337f20c536357c9';
+            // Message has different chainId (1 = mainnet) in domain, but provider should use its own chainId (11155111)
+            const message = '{"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"chainId","type":"uint256"}],"Person":[{"name":"name","type":"string"}]},"primaryType":"Person","domain":{"name":"Test","chainId":1},"message":{"name":"Alice"}}';
+            const expectedSignature = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12';
+            mockSepoliaClient.signTypedData.mockResolvedValue({
+                data: { signature: expectedSignature },
+            });
+            mockSepoliaClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'sepolia-wallet-id' }] },
+            });
+            const result = await sepoliaProvider.request({ method: 'eth_signTypedData_v4', params: [address, message] });
+            expect(result).toBe(expectedSignature);
+            // Verify that signTypedData was called with walletId (converted from address/blockchain)
+            expect(mockSepoliaClient.signTypedData).toHaveBeenCalledWith({
+                walletId: 'sepolia-wallet-id',
+                data: message,
+            });
+            // Verify that listWallets was called with ETH-SEPOLIA blockchain (derived from provider's chainId 11155111)
+            // not ETH (which would be derived from message domain chainId 1)
+            expect(mockSepoliaClient.listWallets).toHaveBeenCalledWith({
+                address,
+                blockchain: 'ETH-SEPOLIA',
+            });
+        });
     });
     describe('circle_requestTestnetTokens', () => {
         it('should return successfully', async () => {
@@ -603,7 +796,7 @@ describe('Provider', () => {
                 usdc: false,
                 eurc: true,
             };
-            const result = await provider.circle_requestTestnetTokens(params);
+            const result = await provider.request({ method: 'circle_requestTestnetTokens', params: [params] });
             expect(result).toBe(undefined);
             expect(mockClient.requestTestnetTokens).toHaveBeenCalledWith(params);
         });
@@ -635,8 +828,15 @@ describe('Provider', () => {
                     },
                 };
                 mockClient.createTransaction.mockResolvedValue(mockResponse);
-                mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockResponse.data } });
-                await provider.circle_createTransaction(params);
+                mockClient.getTransaction.mockResolvedValue({
+                    data: {
+                        transaction: {
+                            ...mockResponse.data,
+                            txHash: '0xabc123',
+                        },
+                    },
+                });
+                await provider.request({ method: 'circle_createTransaction', params: [params] });
                 // Verify that SENTINEL_FEES are converted to level-based fee
                 expect(mockClient.createTransaction).toHaveBeenCalledWith({
                     walletId: 'test-wallet-id',
@@ -675,8 +875,15 @@ describe('Provider', () => {
                     },
                 };
                 mockClient.createTransaction.mockResolvedValue(mockResponse);
-                mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockResponse.data } });
-                await provider.circle_createTransaction(params);
+                mockClient.getTransaction.mockResolvedValue({
+                    data: {
+                        transaction: {
+                            ...mockResponse.data,
+                            txHash: '0xabc123',
+                        },
+                    },
+                });
+                await provider.request({ method: 'circle_createTransaction', params: [params] });
                 // Verify that only maxFee is converted to empty string
                 expect(mockClient.createTransaction).toHaveBeenCalledWith({
                     walletId: 'test-wallet-id',
@@ -717,8 +924,15 @@ describe('Provider', () => {
                     },
                 };
                 mockClient.createTransaction.mockResolvedValue(mockResponse);
-                mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockResponse.data } });
-                await provider.circle_createTransaction(params);
+                mockClient.getTransaction.mockResolvedValue({
+                    data: {
+                        transaction: {
+                            ...mockResponse.data,
+                            txHash: '0xabc123',
+                        },
+                    },
+                });
+                await provider.request({ method: 'circle_createTransaction', params: [params] });
                 // Verify that normal fees are not modified
                 expect(mockClient.createTransaction).toHaveBeenCalledWith({
                     walletId: 'test-wallet-id',
@@ -736,123 +950,1254 @@ describe('Provider', () => {
             });
         });
     });
-});
-describe('Provider 2', () => {
-    let provider;
-    const mockClient = {
-        estimateContractExecutionFee: vi.fn(),
-        createContractExecutionTransaction: vi.fn(),
-        createTransaction: vi.fn(),
-        getTransaction: vi.fn(),
-        listWallets: vi.fn(),
-    };
-    const mockScp = {
-        importContract: vi.fn(),
-    };
-    beforeEach(() => {
-        ;
-        initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
-        initiateSmartContractPlatformClient.mockReturnValue(mockScp);
-        provider = new Provider({
-            apiKey: 'test-api-key',
-            entitySecret: 'test-entity-secret',
-            baseUrl: 'base-url',
+    describe('defaultSignal getter', () => {
+        it('should return AbortSignal.timeout when timeout is set', () => {
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                timeout: 5000,
+            });
+            const signal = provider.defaultSignal;
+            expect(signal).toBeInstanceOf(AbortSignal);
         });
-    });
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    test('estimate contract execution fee', async () => {
-        const params = {
-            abiFunctionSignature: 'value',
-            source: {
-                sourceAddress: 'sourceAddress',
-                blockchain: 'ETH-SEPOLIA',
-            },
-            contractAddress: 'contractAddress',
-            abiParameters: [],
-        };
-        mockClient.estimateContractExecutionFee.mockResolvedValue({
-            data: {
-                high: { gasLimit: '3', maxFee: '6', priorityFee: '9', baseFee: '12', networkFee: '15' },
-                medium: { gasLimit: '2', maxFee: '4', priorityFee: '6', baseFee: '8', networkFee: '10' },
-                low: { gasLimit: '1', maxFee: '2', priorityFee: '3', baseFee: '4', networkFee: '5' },
-            },
+        it('should return undefined when timeout is not set', () => {
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                // timeout not provided
+            });
+            const signal = provider.defaultSignal;
+            expect(signal).toBeUndefined();
         });
-        const result = await provider.circle_estimateContractExecutionFee(params);
-        expect(result).toMatchObject({
-            high: {
-                gasLimit: '4',
-                maxFee: '6.300000000000001',
-                priorityFee: '9.450000000000001',
-                baseFee: '12',
-                networkFee: '15',
-            },
-            medium: { gasLimit: '3', maxFee: '4.2', priorityFee: '6.300000000000001', baseFee: '8', networkFee: '10' },
-            low: { gasLimit: '2', maxFee: '2.1', priorityFee: '3.1500000000000004', baseFee: '4', networkFee: '5' },
+        it('should return AbortSignal.timeout for zero timeout', () => {
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                timeout: 0,
+            });
+            const signal = provider.defaultSignal;
+            expect(signal).toBeInstanceOf(AbortSignal);
         });
-        expect(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith(params);
     });
-    test('estimate contract execution fee for SCA', async () => {
-        const params = {
-            abiFunctionSignature: 'value',
-            source: {
-                sourceAddress: 'sourceAddress',
-                blockchain: 'ETH-SEPOLIA',
-            },
-            contractAddress: 'contractAddress',
-            abiParameters: [],
-        };
-        mockClient.estimateContractExecutionFee.mockResolvedValue({
-            data: {
-                high: { gasLimit: '3', maxFee: '6', priorityFee: '9', baseFee: '12', networkFee: '15' },
-                medium: { gasLimit: '2', maxFee: '4', priorityFee: '6', baseFee: '8', networkFee: '10' },
-                low: { gasLimit: '1', maxFee: '2', priorityFee: '3', baseFee: '4', networkFee: '5' },
-                callGasLimit: '11111',
-                verificationGasLimit: '22222',
-                preVerificationGas: '33333',
-            },
+    describe('Provider constructor validation', () => {
+        it('should throw error when pollingInterval is negative', () => {
+            expect(() => new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                pollingInterval: -1000,
+            })).toThrow('Polling interval must be greater than 0');
         });
-        const result = await provider.circle_estimateContractExecutionFee(params);
-        expect(result).toMatchObject({
-            high: {
-                gasLimit: '4',
-                maxFee: '6.300000000000001',
-                priorityFee: '9.450000000000001',
-                baseFee: '12',
-                networkFee: '15',
-            },
-            medium: { gasLimit: '3', maxFee: '4.2', priorityFee: '6.300000000000001', baseFee: '8', networkFee: '10' },
-            low: { gasLimit: '2', maxFee: '2.1', priorityFee: '3.1500000000000004', baseFee: '4', networkFee: '5' },
-            callGasLimit: '11111',
-            verificationGasLimit: '22222',
-            preVerificationGas: '33333',
+        it('should throw error when pollingInterval is zero', () => {
+            expect(() => new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                pollingInterval: 0,
+            })).toThrow('Polling interval must be greater than 0');
+        });
+        it('should accept positive pollingInterval', () => {
+            expect(() => new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                pollingInterval: 2000,
+            })).not.toThrow();
         });
-        expect(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith(params);
     });
-    describe('create contract execution transaction', () => {
-        test.each([
-            {
-                name: 'with wallet id',
-                params: {
-                    walletId: 'test-wallet-id',
-                    contractAddress: '0xcontract-address',
-                    fee: {
-                        type: 'level',
-                        config: {
-                            feeLevel: 'LOW',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'without wallet id',
-                params: {
-                    contractAddress: '0xcontract-address',
-                    sourceAddress: '0xtest-address',
-                    blockchain: 'ETH-SEPOLIA',
-                    fee: {
-                        type: 'level',
+    describe('Request method with fallback support', () => {
+        it('should fallback to fallback provider for unsupported methods', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockResolvedValue('0x123abc'),
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            const result = await providerWithMockFallback.request({
+                method: 'eth_blockNumber',
+                params: [],
+            });
+            expect(result).toBe('0x123abc');
+            expect(mockFallback).toHaveBeenCalledTimes(1);
+            const mockProvider = mockFallback();
+            expect(mockProvider.request).toHaveBeenCalledWith({
+                method: 'eth_blockNumber',
+                params: [],
+            });
+        });
+        it('should throw error for unsupported chain in fallback methods', async () => {
+            const providerWithUnsupportedChain = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 999999, // Unsupported chain
+            });
+            await expect(providerWithUnsupportedChain.request({ method: 'eth_blockNumber', params: [] })).rejects.toThrow();
+        });
+        it('should handle fallback errors gracefully', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockRejectedValue(new Error('Network error')),
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            await expect(providerWithMockFallback.request({
+                method: 'eth_getTransactionByHash',
+                params: ['0x123'],
+            })).rejects.toThrow('Network error');
+        });
+        it('should call super.request first before falling back', async () => {
+            const mockRequest = vi.fn().mockResolvedValue('0x456def');
+            const mockFallback = vi.fn().mockReturnValue({
+                request: mockRequest,
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            // Mock a supported method to ensure it doesn't fallback
+            const result = await providerWithMockFallback.request({
+                method: 'eth_chainId',
+                params: [],
+            });
+            expect(result).toBe('0x1'); // Should return chainId from provider, not fallback
+            expect(mockFallback).toHaveBeenCalledTimes(1);
+            expect(mockRequest).not.toHaveBeenCalled();
+        });
+        it('should only fallback on MethodNotFoundRpcError', async () => {
+            const mockRequest = vi.fn().mockResolvedValue('fallback-result');
+            const mockFallback = vi.fn().mockReturnValue({
+                request: mockRequest,
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            // Test with an error that's not MethodNotFoundRpcError (should not fallback)
+            await expect(providerWithMockFallback.request({
+                method: 'eth_chainId',
+                params: [],
+            })).resolves.toBe('0x1'); // Should succeed without fallback
+            expect(mockFallback).toHaveBeenCalledTimes(1);
+            expect(mockRequest).not.toHaveBeenCalled();
+        });
+        it('should properly handle MethodNotFoundRpcError and fallback', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockResolvedValue('0xfallback123'),
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            // Test that unsupported methods trigger fallback
+            const result = await providerWithMockFallback.request({
+                method: 'eth_getTransactionByHash',
+                params: ['0x123'],
+            });
+            expect(result).toBe('0xfallback123');
+            expect(mockFallback).toHaveBeenCalledTimes(1);
+            const mockProvider = mockFallback();
+            expect(mockProvider.request).toHaveBeenCalledWith({
+                method: 'eth_getTransactionByHash',
+                params: ['0x123'],
+            });
+        });
+        it('should handle multiple fallback methods correctly', async () => {
+            const mockRequest = vi
+                .fn()
+                .mockResolvedValueOnce('0xblock123')
+                .mockResolvedValueOnce('0xtx456')
+                .mockResolvedValueOnce('0xreceipt789');
+            const mockFallback = vi.fn().mockReturnValue({
+                request: mockRequest,
+            });
+            const providerWithMockFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            // Test multiple different fallback methods
+            const blockResult = await providerWithMockFallback.request({
+                method: 'eth_blockNumber',
+                params: [],
+            });
+            const txResult = await providerWithMockFallback.request({
+                method: 'eth_getTransactionByHash',
+                params: ['0x123'],
+            });
+            const receiptResult = await providerWithMockFallback.request({
+                method: 'eth_getTransactionReceipt',
+                params: ['0x456'],
+            });
+            expect(blockResult).toBe('0xblock123');
+            expect(txResult).toBe('0xtx456');
+            expect(receiptResult).toBe('0xreceipt789');
+            expect(mockFallback).toHaveBeenCalledTimes(1);
+            expect(mockRequest).toHaveBeenCalledTimes(3);
+        });
+        it('should not fallback when fallback is null', async () => {
+            const providerWithNullFallback = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                chainId: 1,
+                fallbackTransport: null,
+            });
+            await expect(providerWithNullFallback.request({
+                method: 'eth_blockNumber',
+                params: [],
+            })).rejects.toThrow('The method "eth_blockNumber" does not exist / is not available');
+        });
+        it('should fallback to fallback provider for eth_call with UnsupportedChainError', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockResolvedValue('0x1'),
+            });
+            const providerWithFallback = new Provider({
+                apiKey: 'api-key',
+                entitySecret: 'entity-secret',
+                chainId: AVAX.id, // AVAX is supported in devC, but not supported in SCP query contract API.
+                fallbackTransport: mockFallback,
+            });
+            const params = { to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8' };
+            const result = await providerWithFallback.request({
+                method: 'eth_call',
+                params: [params],
+            });
+            expect(result).toBe('0x1');
+            const mockProvider = mockFallback();
+            expect(mockProvider.request).toHaveBeenCalledWith({
+                method: 'eth_call',
+                params: [params],
+            });
+        });
+        it('should not fallback for eth_call with non-UnsupportedChainError', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockResolvedValue('should-not-be-called'),
+            });
+            mockScp.queryContract = vi.fn();
+            initiateSmartContractPlatformClient.mockReturnValue(mockScp);
+            mockScp.queryContract.mockRejectedValue(new Error('Network timeout'));
+            const provider = new Provider({
+                apiKey: 'api-key',
+                entitySecret: 'entity-secret',
+                chainId: 1, // Supported chain
+                fallbackTransport: mockFallback,
+            });
+            const params = {
+                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
+                data: '0x70a08231',
+            };
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [params],
+            })).rejects.toThrow('Network timeout');
+            // Verify that fallback was not called.
+            const mockProvider = mockFallback();
+            expect(mockProvider.request).not.toHaveBeenCalled();
+        });
+        it('should not fallback for UnsupportedChainError with non-eth_call methods', async () => {
+            const mockFallback = vi.fn().mockReturnValue({
+                request: vi.fn().mockResolvedValue('should-not-be-called'),
+            });
+            const provider = new Provider({
+                apiKey: 'api-key',
+                entitySecret: 'entity-secret',
+                chainId: 1,
+                fallbackTransport: mockFallback,
+            });
+            // Simulate the throw of UnsupportedChainError.
+            const extractChainSpy = vi.spyOn(circleWalletsIndex, 'extractChain');
+            extractChainSpy.mockImplementation(() => {
+                throw new UnsupportedChainError();
+            });
+            await expect(provider.request({
+                method: 'eth_sendTransaction',
+                params: [{ from: '0x123', to: '0x456', value: '0x0' }],
+            })).rejects.toThrow(UnsupportedChainError);
+            expect(extractChainSpy).toHaveBeenCalled();
+            // Verify that fallback was not called.
+            const mockProvider = mockFallback();
+            expect(mockProvider.request).not.toHaveBeenCalled();
+            extractChainSpy.mockRestore();
+        });
+        it('should not fallback for eth_call with UnsupportedChainError when fallback is null', async () => {
+            const provider = new Provider({
+                apiKey: 'api-key',
+                entitySecret: 'entity-secret',
+                chainId: AVAX.id,
+                fallbackTransport: null,
+            });
+            const params = { to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8' };
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [params],
+            })).rejects.toThrow(MethodNotFoundRpcError);
+        });
+    });
+    describe('eth_sendTransaction', () => {
+        it('should create transaction and return hash', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xabc123');
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'wallet-1',
+                blockchain: 'ETH',
+                amount: ['0.01'],
+                destinationAddress: '0x456',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'HIGH',
+                    },
+                },
+            });
+        });
+        it('should throw error for unsupported chain', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x2386f26fc10000',
+            };
+            await expect(provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            })).rejects.toThrow();
+        });
+        it('should handle transaction failure states', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x2386f26fc10000',
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction.mockResolvedValue({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'FAILED',
+                        errorReason: '123',
+                        errorDetails: 'Transaction failed',
+                    },
+                },
+            });
+            await expect(provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            })).rejects.toThrow();
+        });
+        it('should handle contract execution', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+                data: '0x1234567890abcdef', // Contract call data
+            };
+            // Mock contract execution transaction flow
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.createContractExecutionTransaction.mockResolvedValue({
+                data: { id: 'contract-tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'contract-tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'contract-tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xcontract123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xcontract123');
+            expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
+                sourceAddress: '0x123',
+                blockchain: 'ETH',
+                contractAddress: '0x456',
+                callData: '0x1234567890abcdef',
+                amount: '0.01',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'HIGH',
+                    },
+                },
+                walletId: 'wallet-1',
+            });
+        });
+        it('should support legacy transaction with gas and gasPrice', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+                gas: '0x5208', // 21000
+                gasPrice: '0x4a817c800', // 20 gwei
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xabc123');
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'wallet-1',
+                blockchain: 'ETH',
+                amount: ['0.01'],
+                destinationAddress: '0x456',
+                fee: {
+                    type: 'gas',
+                    config: {
+                        gasLimit: '21000',
+                        gasPrice: '20', // 20 gwei
+                    },
+                },
+            });
+        });
+        it('should support EIP-1559 transaction with gas, maxFeePerGas, and maxPriorityFeePerGas', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+                gas: '0x5208', // 21000
+                maxFeePerGas: '0x9502f9000', // 40 gwei
+                maxPriorityFeePerGas: '0x4a817c800', // 20 gwei
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xabc123');
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'wallet-1',
+                blockchain: 'ETH',
+                amount: ['0.01'],
+                destinationAddress: '0x456',
+                fee: {
+                    type: 'absolute',
+                    config: {
+                        gasLimit: '21000',
+                        maxFee: '40', // 40 gwei
+                        priorityFee: '20', // 20 gwei
+                    },
+                },
+            });
+        });
+        it('should estimate gas when not provided in legacy transaction', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+                gasPrice: '0x4a817c800', // 20 gwei
+                // gas not provided - should be estimated
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.estimateTransferFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '25000', maxFee: '20000000000', priorityFee: '1000000000' },
+                },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xabc123');
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'wallet-1',
+                blockchain: 'ETH',
+                amount: ['0.01'],
+                destinationAddress: '0x456',
+                fee: {
+                    type: 'gas',
+                    config: {
+                        gasLimit: '26250', // 25000 * 1.05 buffer from estimate
+                        gasPrice: '20', // 20 gwei
+                    },
+                },
+            });
+        });
+        it('should estimate gas when not provided in EIP-1559 transaction', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: numberToHex(parseEther('0.01')),
+                maxFeePerGas: '0x9502f9000', // 40 gwei
+                maxPriorityFeePerGas: '0x4a817c800', // 20 gwei
+                // gas not provided - should be estimated
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1' }] },
+            });
+            mockClient.estimateTransferFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '25000', maxFee: '20000000000', priorityFee: '1000000000' },
+                },
+            });
+            mockClient.createTransaction.mockResolvedValue({
+                data: { id: 'tx-1' },
+            });
+            mockClient.getTransaction
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: { id: 'tx-1', state: 'PENDING' },
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    transaction: {
+                        id: 'tx-1',
+                        state: 'COMPLETE',
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_sendTransaction',
+                params: [params],
+            });
+            expect(result).toBe('0xabc123');
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'wallet-1',
+                blockchain: 'ETH',
+                amount: ['0.01'],
+                destinationAddress: '0x456',
+                fee: {
+                    type: 'absolute',
+                    config: {
+                        gasLimit: '26250', // 25000 * 1.05 buffer from estimate
+                        maxFee: '40', // 40 gwei
+                        priorityFee: '20', // 20 gwei
+                    },
+                },
+            });
+        });
+    });
+    describe('eth_signTransaction', () => {
+        it('should sign successfully on mainnet (EVM)', async () => {
+            const txParams = { from: '0x00000000000000000000000000000000000000Aa' };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1', address: '0x00000000000000000000000000000000000000aa' }] },
+            });
+            mockClient.signTransaction.mockResolvedValue({
+                data: { signedTransaction: '0xdeadbeef', signature: '0xsig', txHash: '0xhash' },
+            });
+            const result = await provider.request({ method: 'eth_signTransaction', params: [txParams] });
+            expect(result).toBe('0xdeadbeef');
+            expect(mockClient.listWallets).toHaveBeenCalledWith({
+                address: txParams.from,
+                blockchain: 'EVM',
+            });
+            const callArg = mockClient.signTransaction.mock.calls[0][0];
+            expect(callArg.walletId).toBe('wallet-1');
+            const signedPayload = JSON.parse(callArg.transaction);
+            expect(signedPayload.from).toBe(txParams.from);
+            expect(signedPayload.chainId).toBe(numberToHex(1));
+        });
+        it('should use EVM-TESTNET for testnet chains', async () => {
+            // Create new mock for this specific test instance
+            const testnetMockClient = {
+                listWallets: vi.fn(),
+                signTransaction: vi.fn(),
+            };
+            initiateDeveloperControlledWalletsClient.mockReturnValueOnce(testnetMockClient);
+            const testnetProvider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                chainId: 11155111, // This test requires a testnet chainId
+            });
+            const txParams = { from: '0x00000000000000000000000000000000000000bb' };
+            testnetMockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-sep', address: txParams.from }] },
+            });
+            testnetMockClient.signTransaction.mockResolvedValue({
+                data: { signedTransaction: '0xfeedface' },
+            });
+            const result = await testnetProvider.request({ method: 'eth_signTransaction', params: [txParams] });
+            expect(result).toBe('0xfeedface');
+            expect(testnetMockClient.listWallets).toHaveBeenCalledWith({
+                address: txParams.from,
+                blockchain: 'EVM-TESTNET',
+            });
+            const callArg = testnetMockClient.signTransaction.mock.calls[0][0];
+            expect(callArg.walletId).toBe('wallet-sep');
+            const signedPayload = JSON.parse(callArg.transaction);
+            expect(signedPayload.from).toBe(txParams.from);
+            expect(signedPayload.chainId).toBe(numberToHex(11155111));
+        });
+        it('uses provided chainId in transaction payload', async () => {
+            const txParams = {
+                from: '0x00000000000000000000000000000000000000CC',
+                chainId: numberToHex(137),
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-1', address: '0x00000000000000000000000000000000000000cc' }] },
+            });
+            mockClient.signTransaction.mockResolvedValue({
+                data: { signedTransaction: '0xbead', signature: '0xsig2', txHash: '0xhash2' },
+            });
+            const result = await provider.request({ method: 'eth_signTransaction', params: [txParams] });
+            expect(result).toBe('0xbead');
+            const callArg = mockClient.signTransaction.mock.calls[0][0];
+            const signedPayload = JSON.parse(callArg.transaction);
+            expect(signedPayload.chainId).toBe(numberToHex(137));
+        });
+        it('should throw when `from` is missing', async () => {
+            await expect(provider.request({ method: 'eth_signTransaction', params: [{}] })).rejects.toThrow();
+        });
+        it('should throw when wallet not found', async () => {
+            const txParams = { from: '0x000000000000000000000000000000000000000c' };
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+            await expect(provider.request({ method: 'eth_signTransaction', params: [txParams] })).rejects.toThrow();
+        });
+        it('throws when zero wallets found', async () => {
+            const txParams = { from: '0x0000000000000000000000000000000000000d00' };
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+            await expect(provider.request({ method: 'eth_signTransaction', params: [txParams] })).rejects.toThrow();
+        });
+        it('throws when multiple wallets found', async () => {
+            const txParams = { from: '0x0000000000000000000000000000000000000d01' };
+            mockClient.listWallets.mockResolvedValue({
+                data: {
+                    wallets: [
+                        { id: 'w1', address: txParams.from },
+                        { id: 'w2', address: txParams.from },
+                    ],
+                },
+            });
+            await expect(provider.request({ method: 'eth_signTransaction', params: [txParams] })).rejects.toThrow();
+        });
+    });
+    describe('eth_chainId', () => {
+        it('should throw error when chainId is not set', async () => {
+            // @ts-expect-error - Testing behavior without chainId
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                // chainId is undefined
+            });
+            await expect(provider.request({ method: 'eth_chainId', params: [] })).rejects.toThrowError();
+        });
+        it('should work with EIP-1193 interface', async () => {
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                chainId: 1337,
+            });
+            const result = (await provider.request({ method: 'eth_chainId' }));
+            expect(result).toBe(numberToHex(1337));
+        });
+    });
+    describe('eth_getBalance', () => {
+        it('should return native token balance for valid address', async () => {
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            const nativeTokenBalance = {
+                token: {
+                    id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                    blockchain: 'ETH',
+                    name: 'Ethereum',
+                    symbol: 'ETH',
+                    decimals: 18,
+                    isNative: true,
+                    updateDate: '2025-01-01T00:00:00.000Z',
+                    createDate: '2025-01-01T00:00:00.000Z',
+                },
+                amount: '1.5',
+                updateDate: '2025-02-19T03:17:30Z',
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-id', address, blockchain: 'ETH' }] },
+            });
+            mockClient.getWalletTokenBalance.mockResolvedValue({
+                data: { tokenBalances: [nativeTokenBalance] },
+            });
+            const result = await provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'latest'],
+            });
+            // 1.5 ETH = 1.5 * 10^18 wei = 1500000000000000000 wei = 0x14d1120d7b160000
+            expect(result).toBe('0x14d1120d7b160000');
+            expect(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({
+                id: 'wallet-id',
+                tokenAddresses: ['', ''],
+            });
+        });
+        it('should work with default block tag (latest)', async () => {
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            const nativeTokenBalance = {
+                token: {
+                    id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                    blockchain: 'ETH',
+                    name: 'Ethereum',
+                    symbol: 'ETH',
+                    decimals: 18,
+                    isNative: true,
+                    updateDate: '2025-01-01T00:00:00.000Z',
+                    createDate: '2025-01-01T00:00:00.000Z',
+                },
+                amount: '2.0',
+                updateDate: '2025-02-19T03:17:30Z',
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-id', address, blockchain: 'ETH' }] },
+            });
+            mockClient.getWalletTokenBalance.mockResolvedValue({
+                data: { tokenBalances: [nativeTokenBalance] },
+            });
+            const result = await provider.request({
+                method: 'eth_getBalance',
+                params: [address], // No block tag provided
+            });
+            // 2.0 ETH = 2 * 10^18 wei = 2000000000000000000 wei = 0x1bc16d674ec80000
+            expect(result).toBe('0x1bc16d674ec80000');
+        });
+        it('should throw error for unsupported block tags', async () => {
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            await expect(provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'earliest'],
+            })).rejects.toThrow('Only "latest" block tag is supported');
+            await expect(provider.request({
+                method: 'eth_getBalance',
+                params: [address, '0x1'],
+            })).rejects.toThrow('Only "latest" block tag is supported');
+        });
+        it('should throw error when chainId is not set', async () => {
+            // @ts-expect-error - Testing behavior without chainId
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+            });
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            await expect(provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'latest'],
+            })).rejects.toThrow();
+        });
+        it('should throw error for unsupported chainId', async () => {
+            const provider = new Provider({
+                apiKey: 'test-api-key',
+                entitySecret: 'test-entity-secret',
+                baseUrl: 'base-url',
+                chainId: 999999, // Unsupported chain
+            });
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            await expect(provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'latest'],
+            })).rejects.toThrow();
+        });
+        it('should return 0 when no native token balance found', async () => {
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-id', address, blockchain: 'ETH' }] },
+            });
+            // Mock getWalletTokenBalance to return empty balances
+            mockClient.getWalletTokenBalance.mockResolvedValue({
+                data: { tokenBalances: [] },
+            });
+            const result = await provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'latest'],
+            });
+            expect(result).toBe(numberToHex(0));
+        });
+        it('should handle zero balance correctly', async () => {
+            const address = '0x123456789abcdef123456789abcdef123456789a';
+            const nativeTokenBalance = {
+                token: {
+                    id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                    blockchain: 'ETH',
+                    name: 'Ethereum',
+                    symbol: 'ETH',
+                    decimals: 18,
+                    isNative: true,
+                    updateDate: '2025-01-01T00:00:00.000Z',
+                    createDate: '2025-01-01T00:00:00.000Z',
+                },
+                amount: '0',
+                updateDate: '2025-02-19T03:17:30Z',
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-id', address, blockchain: 'ETH' }] },
+            });
+            mockClient.getWalletTokenBalance.mockResolvedValue({
+                data: { tokenBalances: [nativeTokenBalance] },
+            });
+            const result = await provider.request({
+                method: 'eth_getBalance',
+                params: [address, 'latest'],
+            });
+            expect(result).toBe('0x0');
+        });
+    });
+    describe('eth_call', () => {
+        it('should perform contract query successfully', async () => {
+            const params = {
+                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
+                data: '0x70a08231000000000000000000000000742d35cc6634c0532925a3b8d0c8c0c8d8d8d8d8',
+                from: '0x123456789abcdef123456789abcdef123456789a',
+            };
+            mockScp.queryContract.mockResolvedValue({
+                data: {
+                    outputData: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_call',
+                params: [params],
+            });
+            expect(result).toBe('0x0000000000000000000000000000000000000000000000000de0b6b3a7640000');
+            expect(mockScp.queryContract).toHaveBeenCalledWith({
+                blockchain: 'ETH',
+                address: params.to,
+                callData: params.data,
+                fromAddress: params.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',
+            };
+            mockScp.queryContract.mockResolvedValue({
+                data: {
+                    outputData: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_call',
+                params: [params],
+            });
+            expect(result).toBe('0x0000000000000000000000000000000000000000000000000de0b6b3a7640000');
+            expect(mockScp.queryContract).toHaveBeenCalledWith({
+                blockchain: 'ETH',
+                address: params.to,
+                callData: params.data,
+                fromAddress: undefined,
+            });
+        });
+        it('should throw error when blockIdentifier is not "latest"', async () => {
+            const params = {
+                to: '0x742d35cc6634C0532925a3b8D0c8c0C8D8d8d8d8',
+                data: '0x70a08231',
+            };
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [params, 'earliest'],
+            })).rejects.toThrow('Only `latest` block identifier is supported');
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [params, '0x1234'],
+            })).rejects.toThrow('Only `latest` block identifier is supported');
+        });
+        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',
+            };
+            await expect(provider.request({
+                method: 'eth_call',
+                params: [multipleUnsupportedParams],
+            })).rejects.toThrow();
+        });
+    });
+    describe('eth_estimateGas', () => {
+        test('estimate gas for transfer transaction (no data field)', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x16345785d8a0000',
+            };
+            mockClient.estimateTransferFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '21000', maxFee: '20000000000', priorityFee: '1000000000' },
+                    medium: { gasLimit: '21000', maxFee: '15000000000', priorityFee: '800000000' },
+                    low: { gasLimit: '21000', maxFee: '10000000000', priorityFee: '500000000' },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_estimateGas',
+                params: [params],
+            });
+            expect(result).toBe('0x5622'); // 22050 in hex (21000 * 1.05 buffer)
+            expect(mockClient.estimateTransferFee).toHaveBeenCalledWith({
+                sourceAddress: '0x123',
+                blockchain: 'ETH',
+                amount: ['0.1'],
+                destinationAddress: '0x456',
+            });
+        });
+        test('estimate gas for contract execution transaction (with data field)', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                data: '0xa9059cbb',
+                value: '0x0',
+            };
+            mockClient.estimateContractExecutionFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '50000', maxFee: '20000000000', priorityFee: '1000000000' },
+                    medium: { gasLimit: '50000', maxFee: '15000000000', priorityFee: '800000000' },
+                    low: { gasLimit: '50000', maxFee: '10000000000', priorityFee: '500000000' },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_estimateGas',
+                params: [params],
+            });
+            expect(result).toBe('0xcd14'); // 52500 in hex (50000 * 1.05 buffer)
+            expect(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith({
+                source: {
+                    sourceAddress: '0x123',
+                    blockchain: 'ETH',
+                },
+                amount: '0',
+                contractAddress: '0x456',
+                callData: '0xa9059cbb',
+            });
+        });
+        test('estimate gas without value field', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+            };
+            mockClient.estimateTransferFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '21000', maxFee: '20000000000', priorityFee: '1000000000' },
+                    medium: { gasLimit: '21000', maxFee: '15000000000', priorityFee: '800000000' },
+                    low: { gasLimit: '21000', maxFee: '10000000000', priorityFee: '500000000' },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_estimateGas',
+                params: [params],
+            });
+            expect(result).toBe('0x5622');
+            expect(mockClient.estimateTransferFee).toHaveBeenCalledWith({
+                sourceAddress: '0x123',
+                blockchain: 'ETH',
+                amount: [undefined],
+                destinationAddress: '0x456',
+            });
+        });
+        test('throws error when chainId is not set', async () => {
+            // @ts-expect-error - Testing behavior without chainId
+            const providerWithoutChainId = new Provider({ apiKey: 'apiKey', entitySecret: 'entitySecret' });
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x16345785d8a0000',
+            };
+            await expect(providerWithoutChainId.request({ method: 'eth_estimateGas', params: [params] })).rejects.toThrow();
+        });
+        test('throws error when blockIdentifier is not latest', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x16345785d8a0000',
+            };
+            await expect(provider.request({
+                method: 'eth_estimateGas',
+                params: [params, '0x1000'], // specific block number
+            })).rejects.toThrow('Only `latest` block identifier is supported');
+        });
+        test('accepts latest blockIdentifier', async () => {
+            const params = {
+                from: '0x123',
+                to: '0x456',
+                value: '0x16345785d8a0000',
+            };
+            mockClient.estimateTransferFee.mockResolvedValue({
+                data: {
+                    high: { gasLimit: '21000', maxFee: '20000000000', priorityFee: '1000000000' },
+                    medium: { gasLimit: '21000', maxFee: '15000000000', priorityFee: '800000000' },
+                    low: { gasLimit: '21000', maxFee: '10000000000', priorityFee: '500000000' },
+                },
+            });
+            const result = await provider.request({
+                method: 'eth_estimateGas',
+                params: [params, 'latest'],
+            });
+            expect(result).toBe('0x5622'); // Should work normally (uses HIGH fee level with 1.05 buffer)
+        });
+    });
+});
+describe('Provider 2', () => {
+    let provider;
+    const mockClient = {
+        estimateContractExecutionFee: vi.fn(),
+        estimateTransferFee: vi.fn(),
+        createContractExecutionTransaction: vi.fn(),
+        createTransaction: vi.fn(),
+        getTransaction: vi.fn(),
+        listWallets: vi.fn(),
+    };
+    const mockScp = {
+        importContract: vi.fn(),
+    };
+    beforeEach(() => {
+        ;
+        initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
+        initiateSmartContractPlatformClient.mockReturnValue(mockScp);
+        provider = new Provider({
+            apiKey: 'test-api-key',
+            entitySecret: 'test-entity-secret',
+            baseUrl: 'base-url',
+            chainId: 1,
+        });
+    });
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    test('estimate contract execution fee', async () => {
+        const params = {
+            abiFunctionSignature: 'value',
+            source: {
+                sourceAddress: 'sourceAddress',
+                blockchain: 'ETH-SEPOLIA',
+            },
+            contractAddress: 'contractAddress',
+            abiParameters: [],
+        };
+        mockClient.estimateContractExecutionFee.mockResolvedValue({
+            data: {
+                high: { gasLimit: '3', maxFee: '6', priorityFee: '9', baseFee: '12', networkFee: '15' },
+                medium: { gasLimit: '2', maxFee: '4', priorityFee: '6', baseFee: '8', networkFee: '10' },
+                low: { gasLimit: '1', maxFee: '2', priorityFee: '3', baseFee: '4', networkFee: '5' },
+            },
+        });
+        const result = await provider.request({ method: 'circle_estimateContractExecutionFee', params: [params] });
+        expect(result).toMatchObject({
+            high: {
+                gasLimit: '4',
+                maxFee: '6.300000000000001',
+                priorityFee: '9.450000000000001',
+                baseFee: '12',
+                networkFee: '15',
+            },
+            medium: { gasLimit: '3', maxFee: '4.2', priorityFee: '6.300000000000001', baseFee: '8', networkFee: '10' },
+            low: { gasLimit: '2', maxFee: '2.1', priorityFee: '3.1500000000000004', baseFee: '4', networkFee: '5' },
+        });
+        expect(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith(params);
+    });
+    test('estimate contract execution fee for SCA', async () => {
+        const params = {
+            abiFunctionSignature: 'value',
+            source: {
+                sourceAddress: 'sourceAddress',
+                blockchain: 'ETH-SEPOLIA',
+            },
+            contractAddress: 'contractAddress',
+            abiParameters: [],
+        };
+        mockClient.estimateContractExecutionFee.mockResolvedValue({
+            data: {
+                high: { gasLimit: '3', maxFee: '6', priorityFee: '9', baseFee: '12', networkFee: '15' },
+                medium: { gasLimit: '2', maxFee: '4', priorityFee: '6', baseFee: '8', networkFee: '10' },
+                low: { gasLimit: '1', maxFee: '2', priorityFee: '3', baseFee: '4', networkFee: '5' },
+                callGasLimit: '11111',
+                verificationGasLimit: '22222',
+                preVerificationGas: '33333',
+            },
+        });
+        const result = await provider.request({ method: 'circle_estimateContractExecutionFee', params: [params] });
+        expect(result).toMatchObject({
+            high: {
+                gasLimit: '4',
+                maxFee: '6.300000000000001',
+                priorityFee: '9.450000000000001',
+                baseFee: '12',
+                networkFee: '15',
+            },
+            medium: { gasLimit: '3', maxFee: '4.2', priorityFee: '6.300000000000001', baseFee: '8', networkFee: '10' },
+            low: { gasLimit: '2', maxFee: '2.1', priorityFee: '3.1500000000000004', baseFee: '4', networkFee: '5' },
+            callGasLimit: '11111',
+            verificationGasLimit: '22222',
+            preVerificationGas: '33333',
+        });
+        expect(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith(params);
+    });
+    describe('create contract execution transaction', () => {
+        test.each([
+            {
+                name: 'with wallet id',
+                params: {
+                    walletId: 'test-wallet-id',
+                    contractAddress: '0xcontract-address',
+                    fee: {
+                        type: 'level',
+                        config: {
+                            feeLevel: 'LOW',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'without wallet id',
+                params: {
+                    contractAddress: '0xcontract-address',
+                    sourceAddress: '0xtest-address',
+                    blockchain: 'ETH-SEPOLIA',
+                    fee: {
+                        type: 'level',
                         config: {
                             feeLevel: 'LOW',
                         },
@@ -868,20 +2213,20 @@ describe('Provider 2', () => {
                 state: 'COMPLETE',
                 transactionType: 'OUTBOUND',
                 updateDate: '2024-01-01T00:00:00Z',
+                txHash: '0xabc123',
             };
             mockClient.createContractExecutionTransaction.mockResolvedValue(mockResponse);
             mockClient.listWallets.mockResolvedValue({
                 data: { wallets: [{ id: 'test-wallet-id' }] },
             });
-            vi.spyOn(provider, 'circle_getTransaction').mockResolvedValue(mockTransaction);
-            const result = await provider.circle_createContractExecutionTransaction(params);
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockTransaction } });
+            const result = await provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
             expect(result).toEqual(mockTransaction);
             expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
                 ...params,
                 walletId: 'test-wallet-id',
             });
-            // eslint-disable-next-line @typescript-eslint/unbound-method
-            expect(provider.circle_getTransaction).toHaveBeenCalledWith({
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({
                 id: 'transaction-id',
             });
         });
@@ -917,8 +2262,89 @@ describe('Provider 2', () => {
             mockClient.listWallets.mockResolvedValue({
                 data: { wallets: [undefined] },
             });
-            vi.spyOn(provider, 'circle_getTransaction').mockResolvedValue(mockTransaction);
-            await expect(provider.circle_createContractExecutionTransaction(params)).rejects.toThrowError('Wallet not found');
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockTransaction } });
+            await expect(provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] })).rejects.toThrowError('Wallet not found');
+        });
+        it('should wait for transaction hash when waitForTransactionHash is true', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                contractAddress: '0xcontract-address',
+                callData: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: true,
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'QUEUED' };
+            const getTransactionResult = {
+                id: 'transaction-id',
+                state: 'COMPLETE',
+                txHash: '0x123',
+                blockchain: 'ETH-SEPOLIA',
+                createDate: '2024-01-01T00:00:00Z',
+                transactionType: 'OUTBOUND',
+                updateDate: '2024-01-01T00:00:00Z',
+            };
+            mockClient.createContractExecutionTransaction.mockResolvedValue({ data: createTransactionResult });
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'test-wallet-id' }] },
+            });
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
+            const result = await provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
+            expect(result).toEqual(getTransactionResult);
+            expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                contractAddress: '0xcontract-address',
+                callData: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: true,
+            });
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({ id: 'transaction-id' });
+        });
+        it('should not wait for transaction hash when waitForTransactionHash is false', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                contractAddress: '0xcontract-address',
+                callData: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: false,
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'QUEUED' };
+            mockClient.createContractExecutionTransaction.mockResolvedValue({ data: createTransactionResult });
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'test-wallet-id' }] },
+            });
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: createTransactionResult } });
+            const result = await provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
+            expect(result).toEqual(createTransactionResult);
+            expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                contractAddress: '0xcontract-address',
+                callData: '0x123',
+                fee: {
+                    type: 'level',
+                    config: {
+                        feeLevel: 'LOW',
+                    },
+                },
+                waitForTransactionHash: false,
+            });
+            // Should call getTransaction once to get the transaction structure, but not wait for txHash
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({ id: 'transaction-id' });
+            expect(mockClient.getTransaction).toHaveBeenCalledTimes(1);
         });
     });
     describe('import contract', () => {
@@ -927,7 +2353,7 @@ describe('Provider 2', () => {
             const mockResponse = { data: { contract: 'contract-data' } };
             mockScp.importContract.mockResolvedValue(mockResponse);
             generateIdempotencyKeyMod.generateIdempotencyKey.mockReturnValue('test-idempotency-key');
-            const result = await provider.circle_importContract(params);
+            const result = await provider.request({ method: 'circle_importContract', params: [params] });
             expect(result).toBe('contract-data');
             expect(mockScp.importContract).toHaveBeenCalledWith({
                 ...params,
@@ -961,8 +2387,15 @@ describe('Provider 2', () => {
                 },
             };
             mockClient.createContractExecutionTransaction.mockResolvedValue(mockResponse);
-            mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockResponse.data } });
-            await provider.circle_createContractExecutionTransaction(params);
+            mockClient.getTransaction.mockResolvedValue({
+                data: {
+                    transaction: {
+                        ...mockResponse.data,
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            await provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
             // Verify that SENTINEL_FEES are converted to level-based fee
             expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
                 walletId: 'test-wallet-id',
@@ -999,8 +2432,15 @@ describe('Provider 2', () => {
                 },
             };
             mockClient.createContractExecutionTransaction.mockResolvedValue(mockResponse);
-            mockClient.getTransaction.mockResolvedValue({ data: { transaction: mockResponse.data } });
-            await provider.circle_createContractExecutionTransaction(params);
+            mockClient.getTransaction.mockResolvedValue({
+                data: {
+                    transaction: {
+                        ...mockResponse.data,
+                        txHash: '0xabc123',
+                    },
+                },
+            });
+            await provider.request({ method: 'circle_createContractExecutionTransaction', params: [params] });
             // Verify that only maxFee is converted to empty string
             expect(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
                 walletId: 'test-wallet-id',