@coinbase/agentkit 0.6.1 → 0.7.0

package/dist/wallet-providers/cdpV2SolanaWalletProvider.js

@@ -0,0 +1,247 @@
+"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 _CdpV2SolanaWalletProvider_connection, _CdpV2SolanaWalletProvider_serverAccount, _CdpV2SolanaWalletProvider_cdp, _CdpV2SolanaWalletProvider_network;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpV2SolanaWalletProvider = void 0;
+const cdp_sdk_1 = require("@coinbase/cdp-sdk");
+const web3_js_1 = require("@solana/web3.js");
+const svm_1 = require("../network/svm");
+const svmWalletProvider_1 = require("./svmWalletProvider");
+/**
+ * A wallet provider that uses the Coinbase SDK.
+ */
+class CdpV2SolanaWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
+    /**
+     * Constructs a new CdpWalletProvider.
+     *
+     * @param config - The configuration options for the CdpWalletProvider.
+     */
+    constructor(config) {
+        super();
+        _CdpV2SolanaWalletProvider_connection.set(this, void 0);
+        _CdpV2SolanaWalletProvider_serverAccount.set(this, void 0);
+        _CdpV2SolanaWalletProvider_cdp.set(this, void 0);
+        _CdpV2SolanaWalletProvider_network.set(this, void 0);
+        __classPrivateFieldSet(this, _CdpV2SolanaWalletProvider_serverAccount, config.serverAccount, "f");
+        __classPrivateFieldSet(this, _CdpV2SolanaWalletProvider_cdp, config.cdp, "f");
+        __classPrivateFieldSet(this, _CdpV2SolanaWalletProvider_connection, config.connection, "f");
+        __classPrivateFieldSet(this, _CdpV2SolanaWalletProvider_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 || "solana-devnet";
+        let network;
+        let rpcUrl;
+        switch (networkId) {
+            case svm_1.SOLANA_MAINNET_NETWORK_ID:
+                network = svm_1.SOLANA_MAINNET_NETWORK;
+                rpcUrl = (0, web3_js_1.clusterApiUrl)("mainnet-beta");
+                break;
+            case svm_1.SOLANA_DEVNET_NETWORK_ID:
+                network = svm_1.SOLANA_DEVNET_NETWORK;
+                rpcUrl = (0, web3_js_1.clusterApiUrl)("devnet");
+                break;
+            case svm_1.SOLANA_TESTNET_NETWORK_ID:
+                network = svm_1.SOLANA_TESTNET_NETWORK;
+                rpcUrl = (0, web3_js_1.clusterApiUrl)("testnet");
+                break;
+            default:
+                throw new Error(`${networkId} is not a valid SVM networkId`);
+        }
+        const cdpClient = new cdp_sdk_1.CdpClient({
+            apiKeyId,
+            apiKeySecret,
+            walletSecret,
+        });
+        const connection = new web3_js_1.Connection(rpcUrl);
+        const serverAccount = await (config.address
+            ? cdpClient.solana.getAccount({ address: config.address })
+            : cdpClient.solana.createAccount({ idempotencyKey }));
+        return new CdpV2SolanaWalletProvider({
+            connection,
+            cdp: cdpClient,
+            serverAccount,
+            network,
+        });
+    }
+    /**
+     * Get the connection instance
+     *
+     * @returns The Solana connection instance
+     */
+    getConnection() {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f");
+    }
+    /**
+     * Get the public key of the wallet
+     *
+     * @returns The wallet's public key
+     */
+    getPublicKey() {
+        return new web3_js_1.PublicKey(__classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_serverAccount, "f").address);
+    }
+    /**
+     * Get the address of the wallet
+     *
+     * @returns The base58 encoded address of the wallet
+     */
+    getAddress() {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_serverAccount, "f").address;
+    }
+    /**
+     * Get the network
+     *
+     * @returns The network
+     */
+    getNetwork() {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_network, "f");
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName() {
+        return "cdp_v2_solana_wallet_provider";
+    }
+    /**
+     * Sign a transaction
+     *
+     * @param transaction - The transaction to sign
+     * @returns The signed transaction
+     */
+    async signTransaction(transaction) {
+        const serializedTransaction = transaction.serialize();
+        const encodedSerializedTransaction = Buffer.from(serializedTransaction).toString("base64");
+        const signedTransaction = await __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_cdp, "f").solana.signTransaction({
+            transaction: encodedSerializedTransaction,
+            address: __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_serverAccount, "f").address,
+        });
+        transaction.addSignature(this.getPublicKey(), Buffer.from(signedTransaction.signature, "base64"));
+        return transaction;
+    }
+    /**
+     * Send a transaction
+     *
+     * @param transaction - The transaction to send
+     * @returns The signature
+     */
+    async sendTransaction(transaction) {
+        const signature = await __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").sendTransaction(transaction);
+        await this.waitForSignatureResult(signature);
+        return signature;
+    }
+    /**
+     * Sign and send a transaction
+     *
+     * @param transaction - The transaction to sign and send
+     * @returns The signature
+     */
+    async signAndSendTransaction(transaction) {
+        const signedTransaction = await this.signTransaction(transaction);
+        return this.sendTransaction(signedTransaction);
+    }
+    /**
+     * Get the status of a transaction
+     *
+     * @param signature - The signature
+     * @param options - The options for the status
+     * @returns The status
+     */
+    async getSignatureStatus(signature, options) {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").getSignatureStatus(signature, options);
+    }
+    /**
+     * Wait for signature receipt
+     *
+     * @param signature - The signature
+     * @returns The confirmation response
+     */
+    async waitForSignatureResult(signature) {
+        const { blockhash, lastValidBlockHeight } = await __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").getLatestBlockhash();
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").confirmTransaction({
+            signature: signature,
+            lastValidBlockHeight,
+            blockhash,
+        });
+    }
+    /**
+     * Get the balance of the wallet
+     *
+     * @returns The balance of the wallet
+     */
+    getBalance() {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").getBalance(this.getPublicKey()).then(balance => BigInt(balance));
+    }
+    /**
+     * Gets the CDP client.
+     *
+     * @returns The CDP client.
+     */
+    getClient() {
+        return __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_cdp, "f");
+    }
+    /**
+     * Transfer SOL from the wallet to another address
+     *
+     * @param to - The base58 encoded address to transfer the SOL to
+     * @param value - The amount of SOL to transfer (as a decimal string, e.g. "0.0001")
+     * @returns The signature
+     */
+    async nativeTransfer(to, value) {
+        const initialBalance = await this.getBalance();
+        const solAmount = parseFloat(value);
+        const lamports = BigInt(Math.floor(solAmount * web3_js_1.LAMPORTS_PER_SOL));
+        // Check if we have enough balance (including estimated fees)
+        if (initialBalance < lamports + BigInt(5000)) {
+            throw new Error(`Insufficient balance. Have ${Number(initialBalance) / web3_js_1.LAMPORTS_PER_SOL} SOL, need ${solAmount + 0.000005} SOL (including fees)`);
+        }
+        const toPubkey = new web3_js_1.PublicKey(to);
+        const instructions = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 10000,
+            }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: 2000,
+            }),
+            web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.getPublicKey(),
+                toPubkey: toPubkey,
+                lamports: lamports,
+            }),
+        ];
+        const tx = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+            payerKey: this.getPublicKey(),
+            instructions: instructions,
+            recentBlockhash: (await __classPrivateFieldGet(this, _CdpV2SolanaWalletProvider_connection, "f").getLatestBlockhash()).blockhash,
+        }));
+        const signature = await this.signAndSendTransaction(tx);
+        await this.waitForSignatureResult(signature);
+        return signature;
+    }
+}
+exports.CdpV2SolanaWalletProvider = CdpV2SolanaWalletProvider;
+_CdpV2SolanaWalletProvider_connection = new WeakMap(), _CdpV2SolanaWalletProvider_serverAccount = new WeakMap(), _CdpV2SolanaWalletProvider_cdp = new WeakMap(), _CdpV2SolanaWalletProvider_network = new WeakMap();

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

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

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdp_sdk_1 = require("@coinbase/cdp-sdk");
+const web3_js_1 = require("@solana/web3.js");
+const cdpV2SolanaWalletProvider_1 = require("./cdpV2SolanaWalletProvider");
+// =========================================================
+// consts
+// =========================================================
+const mockConnection = {
+    sendTransaction: jest.fn(),
+    getBalance: jest.fn(),
+    getLatestBlockhash: jest.fn(),
+    getSignatureStatus: jest.fn(),
+    confirmTransaction: jest.fn(),
+};
+// =========================================================
+// mocks
+// =========================================================
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+jest.mock("../../package.json", () => ({
+    version: "1.0.0",
+}));
+jest.mock("@solana/web3.js", () => {
+    const mockPublicKey = {
+        toBase58: () => MOCK_ADDRESS,
+        equals: () => true,
+    };
+    const MockPublicKey = jest.fn(() => mockPublicKey);
+    MockPublicKey.prototype = mockPublicKey;
+    return {
+        Connection: jest.fn(() => mockConnection),
+        PublicKey: MockPublicKey,
+        VersionedTransaction: jest.fn().mockImplementation(() => ({
+            serialize: jest.fn(() => Buffer.from("mock-serialized-tx")),
+            addSignature: jest.fn(),
+        })),
+        MessageV0: {
+            compile: jest.fn(),
+        },
+        SystemProgram: {
+            transfer: jest.fn(),
+        },
+        ComputeBudgetProgram: {
+            setComputeUnitPrice: jest.fn(),
+            setComputeUnitLimit: jest.fn(),
+        },
+        clusterApiUrl: jest.fn((cluster) => {
+            switch (cluster) {
+                case "mainnet-beta":
+                    return "https://api.mainnet-beta.solana.com";
+                case "devnet":
+                    return "https://api.devnet.solana.com";
+                case "testnet":
+                    return "https://api.testnet.solana.com";
+                default:
+                    return "https://api.devnet.solana.com";
+            }
+        }),
+        LAMPORTS_PER_SOL: 1000000000,
+    };
+});
+// Mock CdpClient
+jest.mock("@coinbase/cdp-sdk", () => {
+    const MOCK_ADDRESS = "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin";
+    const MOCK_SIGNATURE = "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjrrVHx6";
+    const mockCreateAccount = jest.fn().mockImplementation(() => Promise.resolve({
+        address: MOCK_ADDRESS,
+        signTransaction: jest.fn().mockResolvedValue({ signature: MOCK_SIGNATURE }),
+    }));
+    const mockSignTransaction = jest
+        .fn()
+        .mockImplementation(async () => ({ signature: MOCK_SIGNATURE }));
+    const mockSolanaClient = {
+        createAccount: mockCreateAccount,
+        getAccount: jest.fn(),
+        signTransaction: mockSignTransaction,
+    };
+    return {
+        CdpClient: jest.fn().mockImplementation(() => ({
+            solana: mockSolanaClient,
+        })),
+    };
+});
+// =========================================================
+// test constants
+// =========================================================
+const MOCK_ADDRESS = "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin";
+const MOCK_NETWORK_ID = "solana-mainnet";
+const MOCK_SIGNATURE = "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjrrVHx6";
+const MOCK_BALANCE = 1000000000n; // 1 SOL in lamports
+const MOCK_NETWORK = {
+    protocolFamily: "svm",
+    networkId: MOCK_NETWORK_ID,
+    chainId: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d", // Solana mainnet chain ID
+};
+const MOCK_SIGNATURE_RESULT = {
+    value: {
+        err: null,
+        slot: 123456,
+        confirmations: 32,
+    },
+    context: {
+        slot: 123456,
+    },
+};
+describe("CdpV2SolanaWalletProvider", () => {
+    let provider;
+    let mockCdpClient;
+    let mockServerAccount;
+    beforeEach(async () => {
+        jest.clearAllMocks();
+        mockCdpClient = new cdp_sdk_1.CdpClient({
+            apiKeyId: "test-key-id",
+            apiKeySecret: "test-key-secret",
+            walletSecret: "test-wallet-secret",
+        });
+        mockServerAccount = {
+            address: MOCK_ADDRESS,
+            signTransaction: jest.fn().mockResolvedValue({ signature: MOCK_SIGNATURE }),
+        };
+        // Set up the mock server account for the provider
+        mockCdpClient.solana.createAccount.mockResolvedValue(mockServerAccount);
+        mockCdpClient.solana.signTransaction = jest
+            .fn()
+            .mockResolvedValue({ signature: MOCK_SIGNATURE });
+        mockConnection.getBalance.mockResolvedValue(Number(MOCK_BALANCE));
+        mockConnection.getLatestBlockhash.mockResolvedValue({
+            blockhash: "test-blockhash",
+            lastValidBlockHeight: 123456,
+        });
+        mockConnection.confirmTransaction.mockResolvedValue(MOCK_SIGNATURE_RESULT);
+        mockConnection.sendTransaction.mockResolvedValue(MOCK_SIGNATURE);
+        provider = await cdpV2SolanaWalletProvider_1.CdpV2SolanaWalletProvider.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 cdpV2SolanaWalletProvider_1.CdpV2SolanaWalletProvider.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 solana-devnet if network not provided", async () => {
+            const provider = await cdpV2SolanaWalletProvider_1.CdpV2SolanaWalletProvider.configureWithWallet({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+            });
+            expect(provider.getNetwork().networkId).toBe("solana-devnet");
+        });
+        it("should handle initialization failures gracefully", async () => {
+            const mockCreateAccount = jest.fn().mockRejectedValue(new Error("Failed to create account"));
+            const mockSolanaClient = {
+                createAccount: mockCreateAccount,
+                getAccount: jest.fn(),
+                signTransaction: jest.fn(),
+            };
+            const mockCdpClient = new cdp_sdk_1.CdpClient({
+                apiKeyId: "test-key-id",
+                apiKeySecret: "test-key-secret",
+                walletSecret: "test-wallet-secret",
+            });
+            mockCdpClient.solana = mockSolanaClient;
+            cdp_sdk_1.CdpClient.mockImplementation(() => mockCdpClient);
+            await expect(cdpV2SolanaWalletProvider_1.CdpV2SolanaWalletProvider.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_solana_wallet_provider");
+        });
+        it("should get the balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(MOCK_BALANCE);
+            expect(mockConnection.getBalance).toHaveBeenCalledWith(expect.any(Object));
+        });
+        it("should handle connection errors during balance check", async () => {
+            mockConnection.getBalance.mockRejectedValueOnce(new Error("Network connection error"));
+            await expect(provider.getBalance()).rejects.toThrow("Network connection error");
+        });
+    });
+    // =========================================================
+    // transaction operation tests
+    // =========================================================
+    describe("transaction operations", () => {
+        it("should sign transactions", async () => {
+            const mockTransaction = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+                payerKey: new web3_js_1.PublicKey(MOCK_ADDRESS),
+                instructions: [],
+                recentBlockhash: "test-blockhash",
+            }));
+            const signedTx = await provider.signTransaction(mockTransaction);
+            expect(mockCdpClient.solana.signTransaction).toHaveBeenCalledWith({
+                transaction: expect.any(String),
+                address: MOCK_ADDRESS,
+            });
+            expect(signedTx).toBe(mockTransaction);
+        });
+        it("should send transactions", async () => {
+            const mockTransaction = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+                payerKey: new web3_js_1.PublicKey(MOCK_ADDRESS),
+                instructions: [],
+                recentBlockhash: "test-blockhash",
+            }));
+            const signature = await provider.sendTransaction(mockTransaction);
+            expect(mockConnection.sendTransaction).toHaveBeenCalledWith(mockTransaction);
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign and send transactions", async () => {
+            const mockTransaction = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+                payerKey: new web3_js_1.PublicKey(MOCK_ADDRESS),
+                instructions: [],
+                recentBlockhash: "test-blockhash",
+            }));
+            const signature = await provider.signAndSendTransaction(mockTransaction);
+            expect(mockCdpClient.solana.signTransaction).toHaveBeenCalled();
+            expect(mockConnection.sendTransaction).toHaveBeenCalled();
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should handle transaction failures during send", async () => {
+            mockConnection.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const mockTransaction = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+                payerKey: new web3_js_1.PublicKey(MOCK_ADDRESS),
+                instructions: [],
+                recentBlockhash: "test-blockhash",
+            }));
+            await expect(provider.sendTransaction(mockTransaction)).rejects.toThrow("Transaction failed");
+        });
+        it("should get signature status", async () => {
+            const mockStatus = {
+                value: {
+                    slot: 123456,
+                    confirmations: 32,
+                    err: null,
+                },
+                context: {
+                    slot: 123456,
+                },
+            };
+            mockConnection.getSignatureStatus.mockResolvedValue(mockStatus);
+            const status = await provider.getSignatureStatus(MOCK_SIGNATURE);
+            expect(status).toBe(mockStatus);
+            expect(mockConnection.getSignatureStatus).toHaveBeenCalledWith(MOCK_SIGNATURE, undefined);
+        });
+        it("should wait for signature result", async () => {
+            const result = await provider.waitForSignatureResult(MOCK_SIGNATURE);
+            expect(result).toBe(MOCK_SIGNATURE_RESULT);
+            expect(mockConnection.confirmTransaction).toHaveBeenCalledWith({
+                signature: MOCK_SIGNATURE,
+                lastValidBlockHeight: 123456,
+                blockhash: "test-blockhash",
+            });
+        });
+    });
+    // =========================================================
+    // native transfer tests
+    // =========================================================
+    describe("native transfer", () => {
+        it("should transfer SOL", async () => {
+            const toAddress = "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin";
+            const amount = "1.0";
+            // Set a balance that's high enough to cover the transfer + fees
+            mockConnection.getBalance.mockResolvedValueOnce(Number(2000000000n)); // 2 SOL
+            const signature = await provider.nativeTransfer(toAddress, amount);
+            expect(signature).toBe(MOCK_SIGNATURE);
+            expect(mockConnection.sendTransaction).toHaveBeenCalled();
+        });
+        it("should handle insufficient balance", async () => {
+            mockConnection.getBalance.mockResolvedValueOnce(Number(1000000n)); // 0.001 SOL
+            const toAddress = "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin";
+            const amount = "1.0";
+            await expect(provider.nativeTransfer(toAddress, amount)).rejects.toThrow("Insufficient balance");
+        });
+        it("should handle invalid address", async () => {
+            const invalidAddress = "invalid-address";
+            const amount = "1.0";
+            await expect(provider.nativeTransfer(invalidAddress, amount)).rejects.toThrow();
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { CdpV2EvmWalletProvider } from "./cdpV2EvmWalletProvider";
+import { CdpV2SolanaWalletProvider } from "./cdpV2SolanaWalletProvider";
+import { CdpV2WalletProviderConfig } from "./cdpV2Shared";
+export type CdpV2WalletProviderVariant = CdpV2SolanaWalletProvider | CdpV2EvmWalletProvider;
+/**
+ * Factory class for creating chain-specific CDP V2 wallet providers
+ */
+export declare class CdpV2WalletProvider {
+    /**
+     * Creates and configures a new wallet provider instance based on the chain type.
+     *
+     * @param config - The configuration options for the CdpV2 wallet
+     * @returns A configured WalletProvider instance for the specified chain
+     *
+     * @example
+     * ```typescript
+     * // For EVM server wallets (default)
+     * const evmWallet = await CdpV2WalletProvider.configureWithWallet({
+     *   apiKeyId: "your-api-key-id",
+     *   apiKeySecret: "your-api-key-secret",
+     *   walletSecret: "your-wallet-secret",
+     *   networkId: "base-sepolia" // or any EVM network. Defaults to "base-sepolia"
+     * });
+     *
+     * // For Solana server wallets
+     * const solanaWallet = await CdpV2WalletProvider.configureWithWallet({
+     *   apiKeyId: "your-api-key-id",
+     *   apiKeySecret: "your-api-key-secret",
+     *   walletSecret: "your-wallet-secret",
+     *   networkId: "solana-devnet" // or "solana-mainnet"
+     * });
+     * ```
+     */
+    static configureWithWallet<T extends CdpV2WalletProviderConfig>(config: T): Promise<CdpV2WalletProviderVariant>;
+}

package/dist/wallet-providers/cdpV2WalletProvider.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpV2WalletProvider = void 0;
+const cdpV2EvmWalletProvider_1 = require("./cdpV2EvmWalletProvider");
+const cdpV2SolanaWalletProvider_1 = require("./cdpV2SolanaWalletProvider");
+const network_1 = require("../network");
+/**
+ * Factory class for creating chain-specific CDP V2 wallet providers
+ */
+class CdpV2WalletProvider {
+    /**
+     * Creates and configures a new wallet provider instance based on the chain type.
+     *
+     * @param config - The configuration options for the CdpV2 wallet
+     * @returns A configured WalletProvider instance for the specified chain
+     *
+     * @example
+     * ```typescript
+     * // For EVM server wallets (default)
+     * const evmWallet = await CdpV2WalletProvider.configureWithWallet({
+     *   apiKeyId: "your-api-key-id",
+     *   apiKeySecret: "your-api-key-secret",
+     *   walletSecret: "your-wallet-secret",
+     *   networkId: "base-sepolia" // or any EVM network. Defaults to "base-sepolia"
+     * });
+     *
+     * // For Solana server wallets
+     * const solanaWallet = await CdpV2WalletProvider.configureWithWallet({
+     *   apiKeyId: "your-api-key-id",
+     *   apiKeySecret: "your-api-key-secret",
+     *   walletSecret: "your-wallet-secret",
+     *   networkId: "solana-devnet" // or "solana-mainnet"
+     * });
+     * ```
+     */
+    static async configureWithWallet(config) {
+        const useSolana = config.networkId && network_1.SOLANA_NETWORK_IDS.includes(config.networkId);
+        const walletProviderClass = useSolana ? cdpV2SolanaWalletProvider_1.CdpV2SolanaWalletProvider : cdpV2EvmWalletProvider_1.CdpV2EvmWalletProvider;
+        return await walletProviderClass.configureWithWallet(config);
+    }
+}
+exports.CdpV2WalletProvider = CdpV2WalletProvider;

package/dist/wallet-providers/cdpWalletProvider.js

@@ -113,7 +113,7 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         if (!__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f")) {
             throw new Error("Wallet not initialized");
         }
-        const messageHash = (0, coinbase_sdk_1.hashMessage)(message);
+        const messageHash = (0, viem_1.hashMessage)(message);
         const payload = await __classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f").createPayloadSignature(messageHash);
         if (payload.getStatus() === "pending" && payload?.wait) {
             await payload.wait(); // needed for Server-Signers

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

@@ -35,6 +35,7 @@ jest.mock("viem", () => {
         parseEther: jest.fn((_value) => BigInt(1000000000000000000)),
         keccak256: jest.fn((_value) => "0xmockhash"),
         serializeTransaction: jest.fn((_tx) => "0xserialized"),
+        hashMessage: jest.fn((_message) => "0xmockhashmessage"),
     };
 });
 jest.mock("../network", () => {

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

@@ -1,11 +1,17 @@
 import { WalletProvider } from "./walletProvider";
-import { TransactionRequest, ReadContractParameters, ReadContractReturnType, ContractFunctionName, Abi, ContractFunctionArgs } from "viem";
+import { TransactionRequest, ReadContractParameters, ReadContractReturnType, ContractFunctionName, Abi, ContractFunctionArgs, Account } from "viem";
 /**
  * EvmWalletProvider is the abstract base class for all EVM wallet providers.
  *
  * @abstract
  */
 export declare abstract class EvmWalletProvider extends WalletProvider {
+    /**
+     * Convert the wallet provider to a Signer.
+     *
+     * @returns The signer.
+     */
+    toSigner(): Account;
     /**
      * Sign a message.
      *