@circle-fin/usdckit 0.18.0 → 0.19.1

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

@@ -0,0 +1,710 @@
+// Copyright (c) 2025, Circle Internet Group, Inc.
+// All rights reserved.
+//
+// Circle Internet Group, Inc. CONFIDENTIAL
+//
+// This file includes unpublished proprietary source code of Circle Internet
+// Group, Inc. The copyright notice above does not
+// evidence any actual or intended publication of such source code. Disclosure
+// of this source code or any related proprietary information is strictly
+// 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 { describe, test, expect, vi, beforeEach, afterEach, it } from 'vitest';
+import * as generateIdempotencyKeyMod from '../../../utils/generateIdempotencyKey.js';
+import { Provider } from './index.js';
+vi.mock('@circle-fin/smart-contract-platform');
+vi.mock('@circle-fin/developer-controlled-wallets');
+vi.mock('../../../utils/generateIdempotencyKey.js');
+vi.mock('@circle-fin/developer-controlled-wallets', () => ({
+    initiateDeveloperControlledWalletsClient: vi.fn(),
+}));
+describe('Provider', () => {
+    let provider;
+    let mockClient;
+    beforeEach(() => {
+        mockClient = {
+            createWalletSet: vi.fn(),
+            createWallets: vi.fn(),
+            listWallets: vi.fn(),
+            getWallet: vi.fn(),
+            estimateTransferFee: vi.fn(),
+            createTransaction: 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(),
+        };
+        initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
+        provider = new Provider({
+            apiKey: 'test-api-key',
+            entitySecret: 'test-entity-secret',
+            baseUrl: 'base-url',
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    test('create a wallet set', async () => {
+        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);
+        expect(result).toBe('test-wallet-set-id');
+        expect(mockClient.createWalletSet).toHaveBeenCalledWith(params);
+    });
+    test('create wallets', async () => {
+        const params = {
+            walletSetId: 'test-wallet-set-id',
+            count: 1,
+            blockchains: ['ETH-SEPOLIA'],
+        };
+        const response = { data: { wallets: ['wallet1'] } };
+        mockClient.createWallets.mockResolvedValue(response);
+        const result = await provider.circle_createWallets(params);
+        expect(result).toEqual(['wallet1']);
+        expect(mockClient.createWallets).toHaveBeenCalledWith(params);
+    });
+    test('list wallets', async () => {
+        const params = { walletSetId: 'test-wallet-set-id' };
+        const response = { data: { wallets: ['wallet1', 'wallet2'] } };
+        mockClient.listWallets.mockResolvedValue(response);
+        const result = await provider.circle_listWallets(params);
+        expect(result).toEqual(['wallet1', 'wallet2']);
+        expect(mockClient.listWallets).toHaveBeenCalledWith(params);
+    });
+    test('estimate transfer fee', async () => {
+        const params = {
+            amounts: ['100'],
+            blockchain: 'MATIC-AMOY',
+            destinationAddress: '0x456',
+            tokenAddress: '0x789',
+        };
+        const response = {
+            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' },
+            },
+        };
+        mockClient.estimateTransferFee.mockResolvedValue(response);
+        const result = await provider.circle_estimateTransferFee(params);
+        expect(result).toEqual({
+            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.estimateTransferFee).toHaveBeenCalledWith({
+            ...params,
+            amount: ['100'],
+            amounts: undefined,
+        });
+    });
+    describe('circle_createTransaction', () => {
+        it('should return a transaction when called with walletId, amount, fee', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'INITIATED' };
+            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);
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            });
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: createTransactionResult.id,
+            });
+            expect(result).toMatchObject(getTransactionResult);
+        });
+        it('should return a transaction when called with walletId, amounts, fee', async () => {
+            const params = {
+                walletId: 'test-wallet-id',
+                amounts: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'INITIATED' };
+            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);
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            });
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: createTransactionResult.id,
+            });
+            expect(result).toMatchObject(getTransactionResult);
+        });
+        it('should return a transaction when called with sourceAddress, blockchain, amounts, fee', async () => {
+            const params = {
+                sourceAddress: '0x123',
+                destinationAddress: '0x456',
+                blockchain: 'MATIC-AMOY',
+                tokenAddress: '0x789',
+                amounts: ['100'],
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            };
+            const createTransactionResult = { id: 'transaction-id', state: 'INITIATED' };
+            const getTransactionResult = {
+                ...createTransactionResult,
+                state: 'COMPLETE',
+                txHash: '0x1234',
+                walletId: 'wallet-id',
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [{ id: 'wallet-id' }] },
+            });
+            mockClient.createTransaction.mockResolvedValue({ data: createTransactionResult });
+            mockClient.getTransaction.mockResolvedValue({ data: { transaction: getTransactionResult } });
+            const result = await provider.circle_createTransaction(params);
+            expect(mockClient.createTransaction).toHaveBeenCalledWith({
+                destinationAddress: '0x456',
+                blockchain: 'MATIC-AMOY',
+                tokenAddress: '0x789',
+                amount: ['100'],
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+                walletId: 'wallet-id',
+                sourceAddress: undefined,
+            });
+            expect(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: getTransactionResult.id,
+            });
+            expect(result).toBe(getTransactionResult);
+        });
+        it('should throw an error if called with sourceAddress, blockchain that does not exist', async () => {
+            const params = {
+                sourceAddress: '0xNotFound',
+                destinationAddress: '0x456',
+                blockchain: 'MATIC-AMOY',
+                amount: ['100'],
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            };
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [] },
+            });
+            await expect(provider.circle_createTransaction(params)).rejects.toThrowError('156001');
+        });
+    });
+    describe('circle_getTransaction', () => {
+        it('should return a transaction', async () => {
+            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);
+            expect(mockClient.getTransaction).toHaveBeenCalledWith(params);
+            expect(result).toMatchObject(getTransactionResult);
+        });
+    });
+    test('circle_getWalletTokenBalance with { id }', async () => {
+        const tokenBalances = [
+            {
+                token: {
+                    id: '5797fbd6-3795-519d-84ca-ec4c5f80c3b1',
+                    blockchain: 'ETH-SEPOLIA',
+                    tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+                    standard: 'ERC20',
+                    name: 'USDC',
+                    symbol: 'USDC',
+                    decimals: 6,
+                    isNative: false,
+                    updateDate: '2024-01-19T09:14:43Z',
+                    createDate: '2024-01-19T09:14:43Z',
+                },
+                amount: '618.999962',
+                updateDate: '2024-12-20T11:17:39Z',
+            },
+        ];
+        mockClient.getWalletTokenBalance.mockResolvedValue({ data: { tokenBalances } });
+        const params = { id: 'wallet-id' };
+        const result = await provider.request({ method: 'circle_getWalletTokenBalance', params: [params] });
+        expect(mockClient.getWalletTokenBalance).toHaveBeenCalledWith(params);
+        expect(result).toBe(tokenBalances);
+    });
+    test('circle_getWalletTokenBalance with valid { address, blockchain }', async () => {
+        const tokenBalances = [
+            {
+                token: {
+                    id: '5797fbd6-3795-519d-84ca-ec4c5f80c3b1',
+                    blockchain: 'ETH-SEPOLIA',
+                    tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+                    standard: 'ERC20',
+                    name: 'USDC',
+                    symbol: 'USDC',
+                    decimals: 6,
+                    isNative: false,
+                    updateDate: '2024-01-19T09:14:43Z',
+                    createDate: '2024-01-19T09:14:43Z',
+                },
+                amount: '618.999962',
+                updateDate: '2024-12-20T11:17:39Z',
+            },
+        ];
+        const wallet = {
+            id: 'wallet-id',
+            address: '0x123',
+            blockchain: 'blockchain',
+        };
+        mockClient.getWalletTokenBalance.mockResolvedValue({ data: { tokenBalances } });
+        mockClient.listWallets.mockResolvedValue({ data: { wallets: [wallet] } });
+        const result = await provider.request({
+            method: 'circle_getWalletTokenBalance',
+            params: [{ address: '0x123', blockchain: 'blockchain' }],
+        });
+        expect(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({ id: wallet.id });
+        expect(result).toBe(tokenBalances);
+    });
+    test('circle_getWalletTokenBalance with { tokenAddress }', async () => {
+        const tokenBalances = [
+            {
+                token: {
+                    id: '5797fbd6-3795-519d-84ca-ec4c5f80c3b1',
+                    blockchain: 'ETH-SEPOLIA',
+                    tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+                    standard: 'ERC20',
+                    name: 'USDC',
+                    symbol: 'USDC',
+                    decimals: 6,
+                    isNative: false,
+                    updateDate: '2024-01-19T09:14:43Z',
+                    createDate: '2024-01-19T09:14:43Z',
+                },
+                amount: '618.999962',
+                updateDate: '2024-12-20T11:17:39Z',
+            },
+        ];
+        mockClient.getWalletTokenBalance.mockResolvedValue({ data: { tokenBalances } });
+        const result = await provider.request({
+            method: 'circle_getWalletTokenBalance',
+            params: [{ id: 'wallet-id', tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238' }],
+        });
+        expect(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({
+            id: 'wallet-id',
+            tokenAddresses: ['0x1c7d4b196cb0c7b01d743fbc6116a902379c7238'],
+        });
+        expect(result).toBe(tokenBalances);
+    });
+    test('circle_getWalletTokenBalance with { tokenAddress } native token', async () => {
+        const tokenBalances = [
+            {
+                token: {
+                    id: '5797fbd6-3795-519d-84ca-ec4c5f80c3b1',
+                    blockchain: 'ETH-SEPOLIA',
+                    name: 'ETH',
+                    symbol: 'ETH',
+                    decimals: 18,
+                    isNative: true,
+                    updateDate: '2024-01-19T09:14:43Z',
+                    createDate: '2024-01-19T09:14:43Z',
+                },
+                amount: '618.999962',
+                updateDate: '2024-12-20T11:17:39Z',
+            },
+        ];
+        mockClient.getWalletTokenBalance.mockResolvedValue({ data: { tokenBalances } });
+        const result = await provider.request({
+            method: 'circle_getWalletTokenBalance',
+            params: [{ id: 'wallet-id', tokenAddress: null }],
+        });
+        expect(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({
+            id: 'wallet-id',
+            tokenAddresses: ['', ''],
+        });
+        expect(result).toBe(tokenBalances);
+    });
+    test('circle_getWalletTokenBalance with invalid { address, blockchain }', async () => {
+        mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+        await expect(provider.request({
+            method: 'circle_getWalletTokenBalance',
+            params: [{ address: '0x123', blockchain: 'blockchain' }],
+        })).rejects.toThrowError('156001');
+    });
+    describe('circle_getNotificationSignature', () => {
+        it('should return a NotificationSignature', async () => {
+            const expectedResult = {
+                id: '879dc113-5ca4-4ff7-a6b7-54652083fcf8',
+                algorithm: 'ECDSA_SHA_256',
+                publicKey: 'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAESl76SZPBJemW0mJNN4KTvYkLT8bOT4UGhFhzNk3fJqf6iuPlLQLq533FelXwczJbjg2U1PHTvQTK7qOQnDL2Tg==',
+                createDate: '2023-06-28T21:47:35.107250Z',
+            };
+            mockClient.getNotificationSignature.mockResolvedValue({
+                data: expectedResult,
+            });
+            const result = await provider.request({
+                method: 'circle_getNotificationSignature',
+                params: [{ kid: '879dc113-5ca4-4ff7-a6b7-54652083fcf8' }],
+            });
+            expect(mockClient.getNotificationSignature).toHaveBeenCalledWith('879dc113-5ca4-4ff7-a6b7-54652083fcf8');
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('circle_deriveWallet()', () => {
+        it('should return the upserted Wallet', async () => {
+            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);
+            expect(mockClient.deriveWallet).toHaveBeenCalledWith(params);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('circle_getWallet()', () => {
+        it('should return the requested Wallet', async () => {
+            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);
+            expect(mockClient.getWallet).toHaveBeenCalledWith(params);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('circle_getWalletsWithBalances()', () => {
+        it('should return the requested Wallets', async () => {
+            const params = { blockchain: 'ETH-SEPOLIA' };
+            const expectedResult = [
+                {
+                    id: '00000000-0000-0000-0000-000000000001',
+                    blockchain: 'ETH-SEPOLIA',
+                    address: '0x0000000000000000000000000000000000000001',
+                    accountType: 'EOA',
+                    walletSetId: '10000000-0000-0000-0000-000000000000',
+                    tokenBalances: [
+                        {
+                            token: {
+                                id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                                blockchain: 'ETH-SEPOLIA',
+                                tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+                                standard: 'ERC20',
+                                name: 'USDC',
+                                symbol: 'USDC',
+                                decimals: 6,
+                                isNative: false,
+                                updateDate: '2025-01-01T00:00:00.000Z',
+                                createDate: '2025-01-01T00:00:00.000Z',
+                            },
+                            amount: '1.1',
+                            updateDate: '2025-02-19T03:17:30Z',
+                        },
+                    ],
+                },
+                {
+                    id: '00000000-0000-0000-0000-000000000002',
+                    blockchain: 'ETH-SEPOLIA',
+                    address: '0x0000000000000000000000000000000000000002',
+                    accountType: 'EOA',
+                    walletSetId: '10000000-0000-0000-0000-000000000000',
+                    tokenBalances: [
+                        {
+                            token: {
+                                id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                                blockchain: 'ETH-SEPOLIA',
+                                name: 'Ethereum-Sepolia',
+                                symbol: 'ETH-SEPOLIA',
+                                decimals: 18,
+                                isNative: true,
+                                updateDate: '2025-01-01T00:00:00.000Z',
+                                createDate: '2025-01-01T00:00:00.000Z',
+                            },
+                            amount: '400',
+                            updateDate: '2025-02-19T03:17:30Z',
+                        },
+                        {
+                            token: {
+                                id: '979869da-9115-5f7d-917d-12d434e56ae7',
+                                blockchain: 'ETH-SEPOLIA',
+                                tokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+                                standard: 'ERC20',
+                                name: 'USDC',
+                                symbol: 'USDC',
+                                decimals: 6,
+                                isNative: false,
+                                updateDate: '2025-01-01T00:00:00.000Z',
+                                createDate: '2025-01-01T00:00:00.000Z',
+                            },
+                            amount: '1.1',
+                            updateDate: '2025-02-19T03:17:30Z',
+                        },
+                    ],
+                },
+            ];
+            mockClient.getWalletsWithBalances.mockResolvedValue({ data: { wallets: expectedResult } });
+            const result = await provider.circle_getWalletsWithBalances(params);
+            expect(mockClient.getWalletsWithBalances).toHaveBeenCalledWith(params);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('circle_signTypedData', () => {
+        it('should return signed typed data', 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" }}',
+            };
+            const expectedResult = {
+                signature: '3W6r38STvZuBSmk2bbbct132SjEsYSARo3CJi3JQvNUaFoYu',
+            };
+            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
+            const result = await provider.circle_signTypedData(params);
+            expect(mockClient.signTypedData).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" }}',
+            };
+            const expectedResult = {
+                signature: '3W6r38STvZuBSmk2bbbct132SjEsYSARo3CJi3JQvNUaFoYu',
+            };
+            mockClient.signTypedData.mockResolvedValue({ data: expectedResult });
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [{ id: 'my-wallet-id' }] } });
+            await provider.circle_signTypedData(params);
+            expect(mockClient.signTypedData).toHaveBeenCalledWith({
+                ...params,
+                address: undefined,
+                blockchain: undefined,
+                walletId: 'my-wallet-id',
+            });
+        });
+    });
+    describe('circle_signTransaction', () => {
+        it('should return signed transaction', 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',
+            };
+            const expectedResult = {
+                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
+                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
+                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
+            };
+            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
+            const result = await provider.circle_signTransaction(params);
+            expect(mockClient.signTransaction).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',
+            };
+            const expectedResult = {
+                signature: '0xe35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef1010707fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e0900',
+                signedTransaction: '0x02f87683013882018505d21dba008509c7652400825208949e4ebf23f713268b8e72cd162337f20c536357c9872386f26fc1000080c080a0e35aff124b45a36fd438ddfc0c61306e1001fdac65d87131591e7e12ef101070a07fcc4194739acd0eec173fa31dda4d3c3381967f06933adc57d5ef08176a8e09',
+                txHash: '0xc37b57369e8c25cc5484829d23e288dd8416107a92b5d6e2d0a9753703fc4fed',
+            };
+            mockClient.signTransaction.mockResolvedValue({ data: expectedResult });
+            mockClient.listWallets.mockResolvedValue({ data: { wallets: [{ id: 'my-wallet-id' }] } });
+            await provider.circle_signTransaction(params);
+            expect(mockClient.signTransaction).toHaveBeenCalledWith({
+                ...params,
+                address: undefined,
+                blockchain: undefined,
+                walletId: 'my-wallet-id',
+            });
+        });
+    });
+    describe('circle_requestTestnetTokens', () => {
+        it('should return successfully', async () => {
+            const params = {
+                address: '0x0000000000000000000000000000000000000000',
+                blockchain: 'ETH-SEPOLIA',
+                native: true,
+                usdc: false,
+                eurc: true,
+            };
+            const result = await provider.circle_requestTestnetTokens(params);
+            expect(result).toBe(undefined);
+            expect(mockClient.requestTestnetTokens).toHaveBeenCalledWith(params);
+        });
+    });
+});
+describe('Provider 2', () => {
+    let provider;
+    const mockClient = {
+        estimateContractExecutionFee: vi.fn(),
+        createContractExecutionTransaction: 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',
+        });
+    });
+    afterEach(() => {
+        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.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' },
+        });
+        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',
+                        },
+                    },
+                },
+            },
+        ])('ok $name', async ({ params }) => {
+            const mockResponse = { data: { id: 'transaction-id' } };
+            const mockTransaction = {
+                id: 'transaction-id',
+                blockchain: 'ETH-SEPOLIA',
+                createDate: '2024-01-01T00:00:00Z',
+                state: 'COMPLETE',
+                transactionType: 'OUTBOUND',
+                updateDate: '2024-01-01T00:00:00Z',
+            };
+            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);
+            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({
+                id: 'transaction-id',
+            });
+        });
+        test('wallet not found', async () => {
+            const params = {
+                sourceAddress: '0xtest-address',
+                blockchain: 'ETH-SEPOLIA',
+                contractAddress: 'test-contract-address',
+                abiFunctionSignature: 'test-abi-function-signature',
+                abiParameters: [],
+                fee: {
+                    type: 'level',
+                    config: {
+                        /**
+                         * A dynamic fee level setting (LOW, MEDIUM, HIGH) determining the gas price for the transaction,
+                         * based on network conditions. Incompatible with gasLimit, gasPrice, priorityFee, or maxFee.
+                         * Use the Estimate Fee methods for fee level estimates.
+                         */
+                        feeLevel: 'LOW',
+                    },
+                },
+            };
+            const mockResponse = { data: { id: 'transaction-id' } };
+            const mockTransaction = {
+                id: 'transaction-id',
+                blockchain: 'ETH-SEPOLIA',
+                createDate: '2024-01-01T00:00:00Z',
+                state: 'COMPLETE',
+                transactionType: 'OUTBOUND',
+                updateDate: '2024-01-01T00:00:00Z',
+            };
+            mockClient.createContractExecutionTransaction.mockResolvedValue(mockResponse);
+            mockClient.listWallets.mockResolvedValue({
+                data: { wallets: [undefined] },
+            });
+            vi.spyOn(provider, 'circle_getTransaction').mockResolvedValue(mockTransaction);
+            await expect(provider.circle_createContractExecutionTransaction(params)).rejects.toThrowError('Wallet not found');
+        });
+    });
+    describe('import contract', () => {
+        test('ok', async () => {
+            const params = { blockchain: 'ETH-SEPOLIA', address: '0xtest-address', name: 'test-name' };
+            const mockResponse = { data: { contract: 'contract-data' } };
+            mockScp.importContract.mockResolvedValue(mockResponse);
+            generateIdempotencyKeyMod.generateIdempotencyKey.mockReturnValue('test-idempotency-key');
+            const result = await provider.circle_importContract(params);
+            expect(result).toBe('contract-data');
+            expect(mockScp.importContract).toHaveBeenCalledWith({
+                ...params,
+                idempotencyKey: 'test-idempotency-key',
+            });
+        });
+    });
+});
+//# sourceMappingURL=index.test.js.map