@coinbase/agentkit 0.0.0-nightly-20250424210504 → 0.0.0-nightly-20250429210433

package/dist/wallet-providers/cdpV2EvmWalletProvider.d.ts

@@ -0,0 +1,105 @@
+import { CdpClient } from "@coinbase/cdp-sdk";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
+import { Network } from "../network";
+import { EvmWalletProvider } from "./evmWalletProvider";
+import { WalletProviderWithClient, CdpV2WalletProviderConfig } from "./cdpV2Shared";
+/**
+ * A wallet provider that uses the Coinbase SDK.
+ */
+export declare class CdpV2EvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
+    #private;
+    /**
+     * Constructs a new CdpWalletProvider.
+     *
+     * @param config - The configuration options for the CdpWalletProvider.
+     */
+    private constructor();
+    /**
+     * Configures a new CdpWalletProvider with a wallet.
+     *
+     * @param config - Optional configuration parameters
+     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @throws Error if required environment variables are missing or wallet initialization fails
+     */
+    static configureWithWallet(config?: CdpV2WalletProviderConfig): Promise<CdpV2EvmWalletProvider>;
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    signMessage(message: string): Promise<Hex>;
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    signTypedData(typedData: any): Promise<Hex>;
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    signTransaction(transaction: TransactionRequest): Promise<Hex>;
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    sendTransaction(transaction: TransactionRequest): Promise<Hex>;
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress(): string;
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork(): Network;
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName(): string;
+    /**
+     * Gets the CDP client.
+     *
+     * @returns The CDP client.
+     */
+    getClient(): CdpClient;
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    waitForTransactionReceipt(txHash: Hex): Promise<any>;
+    /**
+     * Reads a contract.
+     *
+     * @param params - The parameters to read the contract.
+     * @returns The response from the contract.
+     */
+    readContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, "pure" | "view">, const args extends ContractFunctionArgs<abi, "pure" | "view", functionName>>(params: ReadContractParameters<abi, functionName, args>): Promise<ReadContractReturnType<abi, functionName, args>>;
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in Wei.
+     * @returns The transaction hash.
+     */
+    nativeTransfer(to: Address, value: string): Promise<Hex>;
+}

package/dist/wallet-providers/cdpV2EvmWalletProvider.js

@@ -0,0 +1,212 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CdpV2EvmWalletProvider_instances, _CdpV2EvmWalletProvider_publicClient, _CdpV2EvmWalletProvider_serverAccount, _CdpV2EvmWalletProvider_cdp, _CdpV2EvmWalletProvider_network, _CdpV2EvmWalletProvider_getCdpSdkNetwork;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpV2EvmWalletProvider = void 0;
+const cdp_sdk_1 = require("@coinbase/cdp-sdk");
+const viem_1 = require("viem");
+const network_1 = require("../network");
+const evmWalletProvider_1 = require("./evmWalletProvider");
+/**
+ * A wallet provider that uses the Coinbase SDK.
+ */
+class CdpV2EvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
+    /**
+     * Constructs a new CdpWalletProvider.
+     *
+     * @param config - The configuration options for the CdpWalletProvider.
+     */
+    constructor(config) {
+        super();
+        _CdpV2EvmWalletProvider_instances.add(this);
+        _CdpV2EvmWalletProvider_publicClient.set(this, void 0);
+        _CdpV2EvmWalletProvider_serverAccount.set(this, void 0);
+        _CdpV2EvmWalletProvider_cdp.set(this, void 0);
+        _CdpV2EvmWalletProvider_network.set(this, void 0);
+        __classPrivateFieldSet(this, _CdpV2EvmWalletProvider_serverAccount, config.serverAccount, "f");
+        __classPrivateFieldSet(this, _CdpV2EvmWalletProvider_cdp, config.cdp, "f");
+        __classPrivateFieldSet(this, _CdpV2EvmWalletProvider_publicClient, config.publicClient, "f");
+        __classPrivateFieldSet(this, _CdpV2EvmWalletProvider_network, config.network, "f");
+    }
+    /**
+     * Configures a new CdpWalletProvider with a wallet.
+     *
+     * @param config - Optional configuration parameters
+     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @throws Error if required environment variables are missing or wallet initialization fails
+     */
+    static async configureWithWallet(config = {}) {
+        const apiKeyId = config.apiKeyId || process.env.CDP_API_KEY_ID;
+        const apiKeySecret = config.apiKeySecret || process.env.CDP_API_KEY_SECRET;
+        const walletSecret = config.walletSecret || process.env.CDP_WALLET_SECRET;
+        const idempotencyKey = config.idempotencyKey || process.env.IDEMPOTENCY_KEY;
+        if (!apiKeyId || !apiKeySecret || !walletSecret) {
+            throw new Error("Missing required environment variables. CDP_API_KEY_ID, CDP_API_KEY_SECRET, CDP_WALLET_SECRET are required.");
+        }
+        const networkId = config.networkId || process.env.NETWORK_ID || "base-sepolia";
+        const network = {
+            protocolFamily: "evm",
+            chainId: network_1.NETWORK_ID_TO_CHAIN_ID[networkId],
+            networkId: networkId,
+        };
+        const cdpClient = new cdp_sdk_1.CdpClient({
+            apiKeyId,
+            apiKeySecret,
+            walletSecret,
+        });
+        const serverAccount = await (config.address
+            ? cdpClient.evm.getAccount({ address: config.address })
+            : cdpClient.evm.createAccount({ idempotencyKey }));
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId],
+            transport: (0, viem_1.http)(),
+        });
+        return new CdpV2EvmWalletProvider({
+            publicClient,
+            cdp: cdpClient,
+            serverAccount,
+            network,
+        });
+    }
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    async signMessage(message) {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").signMessage({ message });
+    }
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async signTypedData(typedData) {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").signTypedData(typedData);
+    }
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    async signTransaction(transaction) {
+        const serializedTx = (0, viem_1.serializeTransaction)(transaction);
+        const signedTx = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_cdp, "f").evm.signTransaction({
+            address: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
+            transaction: serializedTx,
+        });
+        return signedTx.signature;
+    }
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    async sendTransaction(transaction) {
+        const result = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_cdp, "f").evm.sendTransaction({
+            address: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
+            transaction: (0, viem_1.serializeTransaction)(transaction),
+            network: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_instances, "m", _CdpV2EvmWalletProvider_getCdpSdkNetwork).call(this),
+        });
+        return result.transactionHash;
+    }
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress() {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address;
+    }
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork() {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_network, "f");
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName() {
+        return "cdp_v2_wallet_provider";
+    }
+    /**
+     * Gets the CDP client.
+     *
+     * @returns The CDP client.
+     */
+    getClient() {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_cdp, "f");
+    }
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    async getBalance() {
+        return await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").getBalance({ address: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address });
+    }
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async waitForTransactionReceipt(txHash) {
+        return await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").waitForTransactionReceipt({ hash: txHash });
+    }
+    /**
+     * Reads a contract.
+     *
+     * @param params - The parameters to read the contract.
+     * @returns The response from the contract.
+     */
+    async readContract(params) {
+        return __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").readContract(params);
+    }
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in Wei.
+     * @returns The transaction hash.
+     */
+    async nativeTransfer(to, value) {
+        return this.sendTransaction({
+            to: to,
+            value: BigInt(value),
+            data: "0x",
+        });
+    }
+}
+exports.CdpV2EvmWalletProvider = CdpV2EvmWalletProvider;
+_CdpV2EvmWalletProvider_publicClient = new WeakMap(), _CdpV2EvmWalletProvider_serverAccount = new WeakMap(), _CdpV2EvmWalletProvider_cdp = new WeakMap(), _CdpV2EvmWalletProvider_network = new WeakMap(), _CdpV2EvmWalletProvider_instances = new WeakSet(), _CdpV2EvmWalletProvider_getCdpSdkNetwork = function _CdpV2EvmWalletProvider_getCdpSdkNetwork() {
+    switch (__classPrivateFieldGet(this, _CdpV2EvmWalletProvider_network, "f").networkId) {
+        case "base-sepolia":
+            return "base-sepolia";
+        case "base-mainnet":
+            return "base";
+        default:
+            throw new Error(`Unsupported network: ${__classPrivateFieldGet(this, _CdpV2EvmWalletProvider_network, "f").networkId}`);
+    }
+};

package/dist/wallet-providers/cdpV2EvmWalletProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wallet-providers/cdpV2EvmWalletProvider.test.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdp_sdk_1 = require("@coinbase/cdp-sdk");
+const cdpV2EvmWalletProvider_1 = require("./cdpV2EvmWalletProvider");
+// =========================================================
+// consts
+// =========================================================
+const mockPublicClient = {
+    waitForTransactionReceipt: jest.fn(),
+    readContract: jest.fn(),
+    getTransactionCount: jest.fn(),
+    estimateFeesPerGas: jest.fn(),
+    estimateGas: jest.fn(),
+    getBalance: jest.fn(),
+};
+const mockWalletClient = {
+    sendTransaction: jest.fn(),
+};
+// =========================================================
+// mocks
+// =========================================================
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+jest.mock("../../package.json", () => ({
+    version: "1.0.0",
+}));
+jest.mock("viem", () => {
+    return {
+        createPublicClient: jest.fn(() => mockPublicClient),
+        createWalletClient: jest.fn(() => mockWalletClient),
+        http: jest.fn(),
+        serializeTransaction: jest.fn((_tx) => "0xserialized"),
+    };
+});
+jest.mock("../network", () => {
+    return {
+        NETWORK_ID_TO_CHAIN_ID: {
+            "base-mainnet": "8453",
+            "base-sepolia": "84532",
+        },
+        NETWORK_ID_TO_VIEM_CHAIN: {
+            "base-mainnet": { id: 8453 },
+            "base-sepolia": { id: 84532 },
+        },
+    };
+});
+// Mock CdpClient
+jest.mock("@coinbase/cdp-sdk", () => {
+    const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+    const MOCK_SIGNATURE = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b01";
+    const mockCreateAccount = jest.fn().mockImplementation(() => Promise.resolve({
+        address: MOCK_ADDRESS,
+        signMessage: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+        signTypedData: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+        signTransaction: jest.fn().mockResolvedValue({ signature: MOCK_SIGNATURE }),
+    }));
+    const mockSignTransaction = jest
+        .fn()
+        .mockImplementation(async () => ({ signature: MOCK_SIGNATURE }));
+    const mockSendTransaction = jest
+        .fn()
+        .mockImplementation(async () => ({ transactionHash: MOCK_TRANSACTION_HASH }));
+    const mockEvmClient = {
+        createAccount: mockCreateAccount,
+        getAccount: jest.fn(),
+        signTransaction: mockSignTransaction,
+        sendTransaction: mockSendTransaction,
+    };
+    return {
+        CdpClient: jest.fn().mockImplementation(() => ({
+            evm: mockEvmClient,
+        })),
+        EvmServerAccount: jest.fn().mockImplementation(() => ({
+            address: MOCK_ADDRESS,
+            signMessage: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+            signTypedData: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+            signTransaction: jest.fn().mockResolvedValue({ signature: MOCK_SIGNATURE }),
+        })),
+    };
+});
+// =========================================================
+// test constants
+// =========================================================
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_NETWORK_ID = "base-mainnet";
+const MOCK_TRANSACTION_HASH = "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba";
+const MOCK_SIGNATURE = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b01";
+const MOCK_BALANCE = 1000000000000000000n;
+const MOCK_NETWORK = {
+    protocolFamily: "evm",
+    networkId: MOCK_NETWORK_ID,
+    chainId: "8453",
+};
+const MOCK_TRANSACTION_RECEIPT = {
+    transactionHash: MOCK_TRANSACTION_HASH,
+};
+describe("CdpV2EvmWalletProvider", () => {
+    let provider;
+    let mockCdpClient;
+    let mockServerAccount;
+    let mockSignTransaction;
+    let mockSendTransaction;
+    beforeEach(async () => {
+        jest.clearAllMocks();
+        mockSignTransaction = jest.fn().mockImplementation(async () => ({ signature: MOCK_SIGNATURE }));
+        mockSendTransaction = jest
+            .fn()
+            .mockImplementation(async () => ({ transactionHash: MOCK_TRANSACTION_HASH }));
+        mockCdpClient = new cdp_sdk_1.CdpClient({
+            apiKeyId: "test-key-id",
+            apiKeySecret: "test-key-secret",
+            walletSecret: "test-wallet-secret",
+        });
+        mockServerAccount = {
+            address: MOCK_ADDRESS,
+            signMessage: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+            signTypedData: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+        };
+        // Set up the mock server account for the provider
+        mockCdpClient.evm.createAccount.mockResolvedValue(mockServerAccount);
+        mockCdpClient.evm.signTransaction = mockSignTransaction;
+        mockCdpClient.evm.sendTransaction = mockSendTransaction;
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue(MOCK_TRANSACTION_RECEIPT);
+        mockPublicClient.readContract.mockResolvedValue("mock_result");
+        mockPublicClient.getTransactionCount.mockResolvedValue(1);
+        mockPublicClient.estimateFeesPerGas.mockResolvedValue({
+            maxFeePerGas: BigInt(100000000),
+            maxPriorityFeePerGas: BigInt(10000000),
+        });
+        mockPublicClient.estimateGas.mockResolvedValue(BigInt(21000));
+        mockPublicClient.getBalance.mockResolvedValue(MOCK_BALANCE);
+        mockWalletClient.sendTransaction.mockResolvedValue(MOCK_TRANSACTION_HASH);
+        provider = await cdpV2EvmWalletProvider_1.CdpV2EvmWalletProvider.configureWithWallet({
+            apiKeyId: "test-key-id",
+            apiKeySecret: "test-key-secret",
+            walletSecret: "test-wallet-secret",
+            networkId: MOCK_NETWORK_ID,
+        });
+    });
+    // =========================================================
+    // initialization tests
+    // =========================================================
+    describe("initialization", () => {
+        it("should initialize with API keys", async () => {
+            const provider = await cdpV2EvmWalletProvider_1.CdpV2EvmWalletProvider.configureWithWallet({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+                networkId: MOCK_NETWORK_ID,
+            });
+            expect(provider.getAddress()).toBe(MOCK_ADDRESS);
+            expect(provider.getNetwork()).toEqual(MOCK_NETWORK);
+        });
+        it("should default to base-sepolia if network not provided", async () => {
+            const provider = await cdpV2EvmWalletProvider_1.CdpV2EvmWalletProvider.configureWithWallet({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+            });
+            expect(provider.getNetwork().networkId).toBe("base-sepolia");
+        });
+        it("should handle initialization failures gracefully", async () => {
+            // Create a new mock client for this test
+            const mockCreateAccount = jest.fn().mockRejectedValue(new Error("Failed to create account"));
+            const mockEvmClient = {
+                createAccount: mockCreateAccount,
+                getAccount: jest.fn(),
+                signTransaction: jest.fn(),
+            };
+            // Override the mock for this test
+            const mockCdpClient = new cdp_sdk_1.CdpClient({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+            });
+            mockCdpClient.evm = mockEvmClient;
+            // Override the CdpClient constructor mock
+            cdp_sdk_1.CdpClient.mockImplementation(() => mockCdpClient);
+            await expect(cdpV2EvmWalletProvider_1.CdpV2EvmWalletProvider.configureWithWallet({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+                networkId: MOCK_NETWORK_ID,
+            })).rejects.toThrow("Failed to create account");
+        });
+    });
+    // =========================================================
+    // basic wallet method tests
+    // =========================================================
+    describe("basic wallet methods", () => {
+        it("should get the address", () => {
+            expect(provider.getAddress()).toBe(MOCK_ADDRESS);
+        });
+        it("should get the network", () => {
+            expect(provider.getNetwork()).toEqual(MOCK_NETWORK);
+        });
+        it("should get the name", () => {
+            expect(provider.getName()).toBe("cdp_v2_wallet_provider");
+        });
+        it("should get the balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(MOCK_BALANCE);
+            expect(mockPublicClient.getBalance).toHaveBeenCalledWith({
+                address: MOCK_ADDRESS,
+            });
+        });
+        it("should handle connection errors during balance check", async () => {
+            mockPublicClient.getBalance.mockRejectedValueOnce(new Error("Network connection error"));
+            await expect(provider.getBalance()).rejects.toThrow("Network connection error");
+        });
+    });
+    // =========================================================
+    // signing operation tests
+    // =========================================================
+    describe("signing operations", () => {
+        it("should sign messages", async () => {
+            const signature = await provider.signMessage("Hello, world!");
+            expect(mockServerAccount.signMessage).toHaveBeenCalledWith({ message: "Hello, world!" });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign typed data", async () => {
+            const typedData = {
+                domain: { name: "Example" },
+                types: { Test: [{ name: "test", type: "string" }] },
+                message: { test: "example" },
+                primaryType: "Test",
+            };
+            const signature = await provider.signTypedData(typedData);
+            expect(mockServerAccount.signTypedData).toHaveBeenCalledWith(typedData);
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign transactions", async () => {
+            const tx = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            const signature = await provider.signTransaction(tx);
+            expect(mockCdpClient.evm.signTransaction).toHaveBeenCalledWith({
+                address: MOCK_ADDRESS,
+                transaction: expect.any(String),
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should handle signing failures", async () => {
+            // Create a failing mock for this test
+            const mockFailingSignTransaction = jest.fn().mockRejectedValue(new Error("Signing failed"));
+            mockCdpClient.evm.signTransaction = mockFailingSignTransaction;
+            const tx = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            await expect(provider.signTransaction(tx)).rejects.toThrow("Signing failed");
+            // Restore the original mock
+            mockCdpClient.evm.signTransaction = mockSignTransaction;
+        });
+    });
+    // =========================================================
+    // transaction operation tests
+    // =========================================================
+    describe("transaction operations", () => {
+        it("should send transactions", async () => {
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            const txHash = await provider.sendTransaction(transaction);
+            expect(mockSendTransaction).toHaveBeenCalled();
+            expect(txHash).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should handle transaction failures during send", async () => {
+            mockSendTransaction.mockRejectedValueOnce(new Error("Transaction signing failed"));
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            await expect(provider.sendTransaction(transaction)).rejects.toThrow("Transaction signing failed");
+        });
+        it("should handle receipt timeout errors", async () => {
+            mockPublicClient.waitForTransactionReceipt.mockRejectedValueOnce(new Error("Timed out"));
+            const hash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+            await expect(provider.waitForTransactionReceipt(hash)).rejects.toThrow("Timed out");
+        });
+        it("should handle transaction with invalid address", async () => {
+            mockSendTransaction.mockRejectedValueOnce(new Error("Invalid address format"));
+            const invalidAddress = "not_a_valid_address";
+            const value = "1000000000000000000"; // 1 ETH in wei
+            await expect(provider.nativeTransfer(invalidAddress, value)).rejects.toThrow("Invalid address format");
+        });
+    });
+    // =========================================================
+    // contract interaction tests
+    // =========================================================
+    describe("contract interactions", () => {
+        it("should read contract data", async () => {
+            const abi = [
+                {
+                    name: "balanceOf",
+                    type: "function",
+                    inputs: [{ name: "account", type: "address" }],
+                    outputs: [{ name: "balance", type: "uint256" }],
+                    stateMutability: "view",
+                },
+            ];
+            const result = await provider.readContract({
+                address: "0x1234567890123456789012345678901234567890",
+                abi,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            });
+            expect(result).toBe("mock_result");
+            expect(mockPublicClient.readContract).toHaveBeenCalled();
+        });
+        it("should handle network errors during contract reads", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new Error("Contract read error"));
+            const abi = [
+                {
+                    name: "balanceOf",
+                    type: "function",
+                    inputs: [{ name: "account", type: "address" }],
+                    outputs: [{ name: "balance", type: "uint256" }],
+                    stateMutability: "view",
+                },
+            ];
+            await expect(provider.readContract({
+                address: "0x1234567890123456789012345678901234567890",
+                abi,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            })).rejects.toThrow("Contract read error");
+        });
+        it("should handle invalid ABI format in contract reads", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new TypeError("Invalid ABI format"));
+            const invalidAbi = "not_a_valid_abi";
+            await expect(provider.readContract({
+                address: "0x1234567890123456789012345678901234567890",
+                abi: invalidAbi,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            })).rejects.toThrow("Invalid ABI format");
+        });
+    });
+});