@circle-fin/usdckit 0.17.1 → 0.19.0

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

@@ -0,0 +1,745 @@
+"use strict";
+// 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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const developer_controlled_wallets_1 = require("@circle-fin/developer-controlled-wallets");
+const smart_contract_platform_1 = require("@circle-fin/smart-contract-platform");
+const vitest_1 = require("vitest");
+const generateIdempotencyKeyMod = __importStar(require("../../../utils/generateIdempotencyKey.js"));
+const index_js_1 = require("./index.js");
+vitest_1.vi.mock('@circle-fin/smart-contract-platform');
+vitest_1.vi.mock('@circle-fin/developer-controlled-wallets');
+vitest_1.vi.mock('../../../utils/generateIdempotencyKey.js');
+vitest_1.vi.mock('@circle-fin/developer-controlled-wallets', () => ({
+    initiateDeveloperControlledWalletsClient: vitest_1.vi.fn(),
+}));
+(0, vitest_1.describe)('Provider', () => {
+    let provider;
+    let mockClient;
+    (0, vitest_1.beforeEach)(() => {
+        mockClient = {
+            createWalletSet: vitest_1.vi.fn(),
+            createWallets: vitest_1.vi.fn(),
+            listWallets: vitest_1.vi.fn(),
+            getWallet: vitest_1.vi.fn(),
+            estimateTransferFee: vitest_1.vi.fn(),
+            createTransaction: vitest_1.vi.fn(),
+            getTransaction: vitest_1.vi.fn(),
+            getWalletTokenBalance: vitest_1.vi.fn(),
+            deriveWallet: vitest_1.vi.fn(),
+            getNotificationSignature: vitest_1.vi.fn(),
+            getWalletsWithBalances: vitest_1.vi.fn(),
+            requestTestnetTokens: vitest_1.vi.fn(() => ''),
+            signTypedData: vitest_1.vi.fn(),
+            signTransaction: vitest_1.vi.fn(),
+        };
+        developer_controlled_wallets_1.initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
+        provider = new index_js_1.Provider({
+            apiKey: 'test-api-key',
+            entitySecret: 'test-entity-secret',
+            baseUrl: 'base-url',
+        });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.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);
+        (0, vitest_1.expect)(result).toBe('test-wallet-set-id');
+        (0, vitest_1.expect)(mockClient.createWalletSet).toHaveBeenCalledWith(params);
+    });
+    (0, vitest_1.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);
+        (0, vitest_1.expect)(result).toEqual(['wallet1']);
+        (0, vitest_1.expect)(mockClient.createWallets).toHaveBeenCalledWith(params);
+    });
+    (0, vitest_1.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);
+        (0, vitest_1.expect)(result).toEqual(['wallet1', 'wallet2']);
+        (0, vitest_1.expect)(mockClient.listWallets).toHaveBeenCalledWith(params);
+    });
+    (0, vitest_1.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);
+        (0, vitest_1.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' },
+        });
+        (0, vitest_1.expect)(mockClient.estimateTransferFee).toHaveBeenCalledWith({
+            ...params,
+            amount: ['100'],
+            amounts: undefined,
+        });
+    });
+    (0, vitest_1.describe)('circle_createTransaction', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            });
+            (0, vitest_1.expect)(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: createTransactionResult.id,
+            });
+            (0, vitest_1.expect)(result).toMatchObject(getTransactionResult);
+        });
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.createTransaction).toHaveBeenCalledWith({
+                walletId: 'test-wallet-id',
+                amount: ['100'],
+                tokenId: '0x123',
+                destinationAddress: '0x456',
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+            });
+            (0, vitest_1.expect)(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: createTransactionResult.id,
+            });
+            (0, vitest_1.expect)(result).toMatchObject(getTransactionResult);
+        });
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.createTransaction).toHaveBeenCalledWith({
+                destinationAddress: '0x456',
+                blockchain: 'MATIC-AMOY',
+                tokenAddress: '0x789',
+                amount: ['100'],
+                fee: { type: 'level', config: { feeLevel: 'LOW' } },
+                walletId: 'wallet-id',
+                sourceAddress: undefined,
+            });
+            (0, vitest_1.expect)(mockClient.getTransaction).toHaveBeenCalledWith({
+                id: getTransactionResult.id,
+            });
+            (0, vitest_1.expect)(result).toBe(getTransactionResult);
+        });
+        (0, vitest_1.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 (0, vitest_1.expect)(provider.circle_createTransaction(params)).rejects.toThrowError('156001');
+        });
+    });
+    (0, vitest_1.describe)('circle_getTransaction', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.getTransaction).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toMatchObject(getTransactionResult);
+        });
+    });
+    (0, vitest_1.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] });
+        (0, vitest_1.expect)(mockClient.getWalletTokenBalance).toHaveBeenCalledWith(params);
+        (0, vitest_1.expect)(result).toBe(tokenBalances);
+    });
+    (0, vitest_1.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' }],
+        });
+        (0, vitest_1.expect)(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({ id: wallet.id });
+        (0, vitest_1.expect)(result).toBe(tokenBalances);
+    });
+    (0, vitest_1.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' }],
+        });
+        (0, vitest_1.expect)(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({
+            id: 'wallet-id',
+            tokenAddresses: ['0x1c7d4b196cb0c7b01d743fbc6116a902379c7238'],
+        });
+        (0, vitest_1.expect)(result).toBe(tokenBalances);
+    });
+    (0, vitest_1.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 }],
+        });
+        (0, vitest_1.expect)(mockClient.getWalletTokenBalance).toHaveBeenCalledWith({
+            id: 'wallet-id',
+            tokenAddresses: ['', ''],
+        });
+        (0, vitest_1.expect)(result).toBe(tokenBalances);
+    });
+    (0, vitest_1.test)('circle_getWalletTokenBalance with invalid { address, blockchain }', async () => {
+        mockClient.listWallets.mockResolvedValue({ data: { wallets: [] } });
+        await (0, vitest_1.expect)(provider.request({
+            method: 'circle_getWalletTokenBalance',
+            params: [{ address: '0x123', blockchain: 'blockchain' }],
+        })).rejects.toThrowError('156001');
+    });
+    (0, vitest_1.describe)('circle_getNotificationSignature', () => {
+        (0, vitest_1.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' }],
+            });
+            (0, vitest_1.expect)(mockClient.getNotificationSignature).toHaveBeenCalledWith('879dc113-5ca4-4ff7-a6b7-54652083fcf8');
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+    });
+    (0, vitest_1.describe)('circle_deriveWallet()', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.deriveWallet).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+    });
+    (0, vitest_1.describe)('circle_getWallet()', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.getWallet).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+    });
+    (0, vitest_1.describe)('circle_getWalletsWithBalances()', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.getWalletsWithBalances).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+    });
+    (0, vitest_1.describe)('circle_signTypedData', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.signTypedData).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.signTypedData).toHaveBeenCalledWith({
+                ...params,
+                address: undefined,
+                blockchain: undefined,
+                walletId: 'my-wallet-id',
+            });
+        });
+    });
+    (0, vitest_1.describe)('circle_signTransaction', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.signTransaction).toHaveBeenCalledWith(params);
+            (0, vitest_1.expect)(result).toEqual(expectedResult);
+        });
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(mockClient.signTransaction).toHaveBeenCalledWith({
+                ...params,
+                address: undefined,
+                blockchain: undefined,
+                walletId: 'my-wallet-id',
+            });
+        });
+    });
+    (0, vitest_1.describe)('circle_requestTestnetTokens', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(result).toBe(undefined);
+            (0, vitest_1.expect)(mockClient.requestTestnetTokens).toHaveBeenCalledWith(params);
+        });
+    });
+});
+(0, vitest_1.describe)('Provider 2', () => {
+    let provider;
+    const mockClient = {
+        estimateContractExecutionFee: vitest_1.vi.fn(),
+        createContractExecutionTransaction: vitest_1.vi.fn(),
+        listWallets: vitest_1.vi.fn(),
+    };
+    const mockScp = {
+        importContract: vitest_1.vi.fn(),
+    };
+    (0, vitest_1.beforeEach)(() => {
+        ;
+        developer_controlled_wallets_1.initiateDeveloperControlledWalletsClient.mockReturnValue(mockClient);
+        smart_contract_platform_1.initiateSmartContractPlatformClient.mockReturnValue(mockScp);
+        provider = new index_js_1.Provider({
+            apiKey: 'test-api-key',
+            entitySecret: 'test-entity-secret',
+            baseUrl: 'base-url',
+        });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.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);
+        (0, vitest_1.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' },
+        });
+        (0, vitest_1.expect)(mockClient.estimateContractExecutionFee).toHaveBeenCalledWith(params);
+    });
+    (0, vitest_1.describe)('create contract execution transaction', () => {
+        vitest_1.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' }] },
+            });
+            vitest_1.vi.spyOn(provider, 'circle_getTransaction').mockResolvedValue(mockTransaction);
+            const result = await provider.circle_createContractExecutionTransaction(params);
+            (0, vitest_1.expect)(result).toEqual(mockTransaction);
+            (0, vitest_1.expect)(mockClient.createContractExecutionTransaction).toHaveBeenCalledWith({
+                ...params,
+                walletId: 'test-wallet-id',
+            });
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            (0, vitest_1.expect)(provider.circle_getTransaction).toHaveBeenCalledWith({
+                id: 'transaction-id',
+            });
+        });
+        (0, vitest_1.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] },
+            });
+            vitest_1.vi.spyOn(provider, 'circle_getTransaction').mockResolvedValue(mockTransaction);
+            await (0, vitest_1.expect)(provider.circle_createContractExecutionTransaction(params)).rejects.toThrowError('Wallet not found');
+        });
+    });
+    (0, vitest_1.describe)('import contract', () => {
+        (0, vitest_1.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);
+            (0, vitest_1.expect)(result).toBe('contract-data');
+            (0, vitest_1.expect)(mockScp.importContract).toHaveBeenCalledWith({
+                ...params,
+                idempotencyKey: 'test-idempotency-key',
+            });
+        });
+    });
+});
+//# sourceMappingURL=index.test.js.map