@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,103 @@
+import { WalletClient as ViemWalletClient, TransactionRequest, ReadContractParameters, ReadContractReturnType, Abi, ContractFunctionName, ContractFunctionArgs } from "viem";
+import { EvmWalletProvider } from "./evmWalletProvider";
+import { Network } from "../network";
+/**
+ * Configuration for gas multipliers.
+ */
+export interface ViemWalletProviderGasConfig {
+    /**
+     * An internal multiplier on gas limit estimation.
+     */
+    gasLimitMultiplier?: number;
+    /**
+     * An internal multiplier on fee per gas estimation.
+     */
+    feePerGasMultiplier?: number;
+}
+/**
+ * A wallet provider that uses the Viem library.
+ */
+export declare class ViemWalletProvider extends EvmWalletProvider {
+    #private;
+    /**
+     * Constructs a new ViemWalletProvider.
+     *
+     * @param walletClient - The wallet client.
+     * @param gasConfig - Configuration for gas multipliers.
+     */
+    constructor(walletClient: ViemWalletClient, gasConfig?: ViemWalletProviderGasConfig);
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    signMessage(message: string): Promise<`0x${string}`>;
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    signTypedData(typedData: any): Promise<`0x${string}`>;
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    signTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    sendTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * 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 balance of the wallet.
+     *
+     * @returns The balance of the wallet.
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    waitForTransactionReceipt(txHash: `0x${string}`): 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 whole units (e.g. ETH)
+     * @returns The transaction hash.
+     */
+    nativeTransfer(to: `0x${string}`, value: string): Promise<`0x${string}`>;
+}

package/dist/wallet-providers/viemWalletProvider.js

@@ -0,0 +1,206 @@
+"use strict";
+// TODO: Improve type safety
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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 _ViemWalletProvider_walletClient, _ViemWalletProvider_publicClient, _ViemWalletProvider_gasLimitMultiplier, _ViemWalletProvider_feePerGasMultiplier;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViemWalletProvider = void 0;
+const viem_1 = require("viem");
+const evmWalletProvider_1 = require("./evmWalletProvider");
+const network_1 = require("../network/network");
+const utils_1 = require("../utils");
+/**
+ * A wallet provider that uses the Viem library.
+ */
+class ViemWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
+    /**
+     * Constructs a new ViemWalletProvider.
+     *
+     * @param walletClient - The wallet client.
+     * @param gasConfig - Configuration for gas multipliers.
+     */
+    constructor(walletClient, gasConfig) {
+        super();
+        _ViemWalletProvider_walletClient.set(this, void 0);
+        _ViemWalletProvider_publicClient.set(this, void 0);
+        _ViemWalletProvider_gasLimitMultiplier.set(this, void 0);
+        _ViemWalletProvider_feePerGasMultiplier.set(this, void 0);
+        __classPrivateFieldSet(this, _ViemWalletProvider_walletClient, walletClient, "f");
+        __classPrivateFieldSet(this, _ViemWalletProvider_publicClient, (0, viem_1.createPublicClient)({
+            chain: walletClient.chain,
+            transport: (0, viem_1.http)(),
+        }), "f");
+        __classPrivateFieldSet(this, _ViemWalletProvider_gasLimitMultiplier, Math.max(gasConfig?.gasLimitMultiplier ?? 1.2, 1), "f");
+        __classPrivateFieldSet(this, _ViemWalletProvider_feePerGasMultiplier, Math.max(gasConfig?.feePerGasMultiplier ?? 1, 1), "f");
+    }
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    async signMessage(message) {
+        const account = __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account;
+        if (!account) {
+            throw new Error("Account not found");
+        }
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").signMessage({ account, message });
+    }
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    async signTypedData(typedData) {
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").signTypedData({
+            account: __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account,
+            domain: typedData.domain,
+            types: typedData.types,
+            primaryType: typedData.primaryType,
+            message: typedData.message,
+        });
+    }
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    async signTransaction(transaction) {
+        const txParams = {
+            account: __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account,
+            to: transaction.to,
+            value: transaction.value,
+            data: transaction.data,
+            chain: __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").chain,
+        };
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").signTransaction(txParams);
+    }
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    async sendTransaction(transaction) {
+        const account = __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account;
+        if (!account) {
+            throw new Error("Account not found");
+        }
+        const chain = __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").chain;
+        if (!chain) {
+            throw new Error("Chain not found");
+        }
+        const feeData = await __classPrivateFieldGet(this, _ViemWalletProvider_publicClient, "f").estimateFeesPerGas();
+        const maxFeePerGas = (0, utils_1.applyGasMultiplier)(feeData.maxFeePerGas, __classPrivateFieldGet(this, _ViemWalletProvider_feePerGasMultiplier, "f"));
+        const maxPriorityFeePerGas = (0, utils_1.applyGasMultiplier)(feeData.maxPriorityFeePerGas, __classPrivateFieldGet(this, _ViemWalletProvider_feePerGasMultiplier, "f"));
+        const gasLimit = await __classPrivateFieldGet(this, _ViemWalletProvider_publicClient, "f").estimateGas({
+            account,
+            to: transaction.to,
+            value: transaction.value,
+            data: transaction.data,
+        });
+        const gas = BigInt(Math.round(Number(gasLimit) * __classPrivateFieldGet(this, _ViemWalletProvider_gasLimitMultiplier, "f")));
+        const txParams = {
+            account: account,
+            chain: chain,
+            data: transaction.data,
+            to: transaction.to,
+            value: transaction.value,
+            gas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+        };
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").sendTransaction(txParams);
+    }
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress() {
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account?.address ?? "";
+    }
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork() {
+        return {
+            protocolFamily: "evm",
+            chainId: String(__classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").chain.id),
+            networkId: network_1.CHAIN_ID_TO_NETWORK_ID[__classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").chain.id],
+        };
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName() {
+        return "viem_wallet_provider";
+    }
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet.
+     */
+    async getBalance() {
+        const account = __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").account;
+        if (!account) {
+            throw new Error("Account not found");
+        }
+        return __classPrivateFieldGet(this, _ViemWalletProvider_publicClient, "f").getBalance({ address: account.address });
+    }
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    async waitForTransactionReceipt(txHash) {
+        return await __classPrivateFieldGet(this, _ViemWalletProvider_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, _ViemWalletProvider_publicClient, "f").readContract(params);
+    }
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in whole units (e.g. ETH)
+     * @returns The transaction hash.
+     */
+    async nativeTransfer(to, value) {
+        const atomicAmount = (0, viem_1.parseEther)(value);
+        const tx = await this.sendTransaction({
+            to: to,
+            value: atomicAmount,
+        });
+        const receipt = await this.waitForTransactionReceipt(tx);
+        if (!receipt) {
+            throw new Error("Transaction failed");
+        }
+        return receipt.transactionHash;
+    }
+}
+exports.ViemWalletProvider = ViemWalletProvider;
+_ViemWalletProvider_walletClient = new WeakMap(), _ViemWalletProvider_publicClient = new WeakMap(), _ViemWalletProvider_gasLimitMultiplier = new WeakMap(), _ViemWalletProvider_feePerGasMultiplier = new WeakMap();

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

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

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

@@ -0,0 +1,338 @@
+"use strict";
+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 viemWalletProvider_1 = require("./viemWalletProvider");
+const viem = __importStar(require("viem"));
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+// =========================================================
+// consts
+// =========================================================
+const MOCK_CHAIN_ID = 84532;
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_ADDRESS_TO = "0x1234567890123456789012345678901234567890";
+const MOCK_TRANSACTION_HASH = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+const MOCK_SIGNATURE = "0x123456789abcdef";
+const MOCK_BALANCE = 10000000000000000000n;
+const MOCK_BLOCK_NUMBER = 12345n;
+const MOCK_MESSAGE = "Hello, World!";
+const MOCK_MAX_FEE_PER_GAS = BigInt(1000000000);
+const MOCK_MAX_PRIORITY_FEE_PER_GAS = BigInt(100000000);
+const MOCK_CHAIN = {
+    id: MOCK_CHAIN_ID,
+    name: "Base Sepolia",
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+        default: {
+            http: ["https://sepolia.base.org"],
+        },
+    },
+};
+const MOCK_DATA = {
+    domain: {
+        name: "Example",
+        version: "1",
+        chainId: 1,
+        verifyingContract: "0x0000000000000000000000000000000000000000",
+    },
+    types: {
+        Person: [
+            { name: "name", type: "string" },
+            { name: "wallet", type: "address" },
+        ],
+    },
+    primaryType: "Person",
+    message: {
+        name: "John Doe",
+        wallet: "0x0000000000000000000000000000000000000000",
+    },
+};
+// =========================================================
+// mocks
+// =========================================================
+jest.mock("../network/network", () => ({
+    CHAIN_ID_TO_NETWORK_ID: {
+        1: "mainnet",
+        5: "goerli",
+        11155111: "sepolia",
+    },
+}));
+jest.mock("viem", () => {
+    return {
+        createPublicClient: jest.fn(),
+        createWalletClient: jest.fn(),
+        http: jest.fn(() => jest.fn()),
+        parseEther: jest.fn(() => BigInt(1000000000000000000)),
+        hexToString: jest.fn(),
+        fromHex: jest.fn(),
+        formatEther: jest.fn(),
+        privateKeyToAccount: jest.fn(),
+    };
+});
+jest.mock("viem/accounts", () => {
+    return {
+        privateKeyToAccount: jest.fn(),
+    };
+});
+describe("ViemWalletProvider", () => {
+    let provider;
+    let mockPublicClient;
+    let mockWalletClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        const mockAccount = {
+            address: MOCK_ADDRESS,
+        };
+        mockPublicClient = {
+            chain: MOCK_CHAIN,
+            getBalance: jest.fn(),
+            getChainId: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            readContract: jest.fn(),
+            estimateFeesPerGas: jest.fn(),
+            estimateGas: jest.fn(),
+        };
+        mockPublicClient.getBalance.mockResolvedValue(MOCK_BALANCE);
+        mockPublicClient.getChainId.mockResolvedValue(MOCK_CHAIN_ID);
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue({
+            transactionHash: MOCK_TRANSACTION_HASH,
+            blockNumber: MOCK_BLOCK_NUMBER,
+            status: "success",
+        });
+        mockPublicClient.readContract.mockResolvedValue("mock_result");
+        mockPublicClient.estimateFeesPerGas.mockResolvedValue({
+            maxFeePerGas: MOCK_MAX_FEE_PER_GAS,
+            maxPriorityFeePerGas: MOCK_MAX_PRIORITY_FEE_PER_GAS,
+        });
+        mockPublicClient.estimateGas.mockResolvedValue(BigInt(21000));
+        mockWalletClient = {
+            chain: MOCK_CHAIN,
+            transport: {
+                name: "HTTP JSON-RPC",
+                request: jest.fn(),
+                value: { url: "https://ethereum.example.com" },
+            },
+            account: mockAccount,
+            signMessage: jest.fn(),
+            signTypedData: jest.fn(),
+            signTransaction: jest.fn(),
+            sendTransaction: jest.fn(),
+        };
+        mockWalletClient.signMessage.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.signTypedData.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.signTransaction.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.sendTransaction.mockResolvedValue(MOCK_TRANSACTION_HASH);
+        viem.createPublicClient.mockReturnValue(mockPublicClient);
+        viem.createWalletClient.mockReturnValue(mockWalletClient);
+        viem.http.mockReturnValue(jest.fn());
+        provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient);
+    });
+    describe("configuration and initialization", () => {
+        it("should create a provider with default gas multipliers", () => {
+            const provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient);
+            expect(provider).toBeInstanceOf(viemWalletProvider_1.ViemWalletProvider);
+            expect(viem.createPublicClient).toHaveBeenCalledWith({
+                chain: MOCK_CHAIN,
+                transport: expect.any(Function),
+            });
+        });
+        it("should create a provider with custom gas multipliers", () => {
+            const gasConfig = {
+                gasLimitMultiplier: 1.5,
+                feePerGasMultiplier: 1.2,
+            };
+            const provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient, gasConfig);
+            expect(provider).toBeInstanceOf(viemWalletProvider_1.ViemWalletProvider);
+        });
+    });
+    describe("basic wallet methods", () => {
+        it("should get wallet address", () => {
+            const address = provider.getAddress();
+            expect(address).toBe(MOCK_ADDRESS);
+        });
+        it("should get network", () => {
+            const network = provider.getNetwork();
+            expect(network.chainId).toBe(String(MOCK_CHAIN_ID));
+            expect(network.protocolFamily).toBe("evm");
+        });
+        it("should get wallet name", () => {
+            const name = provider.getName();
+            expect(name).toBe("viem_wallet_provider");
+        });
+        it("should get 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");
+        });
+    });
+    describe("signing operations", () => {
+        it("should sign a message", async () => {
+            const signature = await provider.signMessage(MOCK_MESSAGE);
+            expect(mockWalletClient.signMessage).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                message: MOCK_MESSAGE,
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign typed data", async () => {
+            const signature = await provider.signTypedData(MOCK_DATA);
+            expect(mockWalletClient.signTypedData).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                ...MOCK_DATA,
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign a transaction", async () => {
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            await provider.signTransaction(transaction);
+            expect(mockWalletClient.signTransaction).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                chain: mockWalletClient.chain,
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data,
+            });
+        });
+        it("should handle signing errors", async () => {
+            mockWalletClient.signMessage.mockRejectedValueOnce(new Error("Signing failed"));
+            await expect(provider.signMessage("test message")).rejects.toThrow("Signing failed");
+        });
+        it("should handle typed data signing errors", async () => {
+            mockWalletClient.signTypedData.mockRejectedValueOnce(new Error("Signing failed"));
+            await expect(provider.signTypedData(MOCK_DATA)).rejects.toThrow("Signing failed");
+        });
+    });
+    describe("transaction operations", () => {
+        it("should send a transaction", async () => {
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            const hash = await provider.sendTransaction(transaction);
+            expect(mockWalletClient.sendTransaction).toHaveBeenCalled();
+            expect(hash).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should wait for a transaction receipt", async () => {
+            const receipt = await provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH);
+            expect(mockPublicClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+                hash: MOCK_TRANSACTION_HASH,
+            });
+            expect(receipt).toEqual({
+                transactionHash: MOCK_TRANSACTION_HASH,
+                blockNumber: MOCK_BLOCK_NUMBER,
+                status: "success",
+            });
+        });
+        it("should handle transaction send errors", async () => {
+            mockWalletClient.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            await expect(provider.sendTransaction(transaction)).rejects.toThrow("Transaction failed");
+        });
+        it("should handle transaction receipt wait errors", async () => {
+            mockPublicClient.waitForTransactionReceipt.mockRejectedValueOnce(new Error("Receipt retrieval failed"));
+            await expect(provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH)).rejects.toThrow("Receipt retrieval failed");
+        });
+    });
+    describe("native token operations", () => {
+        it("should transfer native tokens", async () => {
+            viem.parseEther.mockReturnValueOnce(BigInt(1000000000000000000));
+            const hash = await provider.nativeTransfer(MOCK_ADDRESS_TO, "1.0");
+            expect(viem.parseEther).toHaveBeenCalledWith("1.0");
+            expect(mockWalletClient.sendTransaction).toHaveBeenCalled();
+            expect(hash).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should handle native transfer errors", async () => {
+            mockWalletClient.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            await expect(provider.nativeTransfer(MOCK_ADDRESS_TO, "1.0")).rejects.toThrow("Transaction failed");
+        });
+        it("should handle invalid address in native transfer", async () => {
+            const invalidAddress = "not_a_valid_address";
+            mockWalletClient.sendTransaction.mockImplementationOnce(() => {
+                throw new Error("Invalid address");
+            });
+            await expect(provider.nativeTransfer(invalidAddress, "1.0")).rejects.toThrow();
+        });
+    });
+    describe("contract interactions", () => {
+        it("should read contract data", async () => {
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: [],
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            const result = await provider.readContract(contractParams);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(contractParams);
+            expect(result).toBe("mock_result");
+        });
+        it("should handle contract read errors", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new Error("Contract read failed"));
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: [],
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            await expect(provider.readContract(contractParams)).rejects.toThrow("Contract read failed");
+        });
+        it("should handle invalid ABI in contract read", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new TypeError("Invalid ABI format"));
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: "invalid abi",
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            await expect(provider.readContract(contractParams)).rejects.toThrow("Invalid ABI format");
+        });
+    });
+});