@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const privyEvmWalletProvider_1 = require("./privyEvmWalletProvider");
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_WALLET_ID = "test-wallet-id";
+const MOCK_TRANSACTION_HASH = "0xef01";
+const MOCK_SIGNATURE_HASH_1 = "0x1234";
+const MOCK_SIGNATURE_HASH_2 = "0x5678";
+const MOCK_SIGNATURE_HASH_3 = "0xabcd";
+jest.mock("@privy-io/server-auth", () => ({
+    PrivyClient: jest.fn().mockImplementation(() => ({
+        appId: "mock-app-id",
+        walletApi: {
+            create: jest.fn().mockResolvedValue({
+                id: "test-wallet-id",
+                address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+            }),
+            getWallet: jest.fn().mockResolvedValue({
+                id: "test-wallet-id",
+                address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+            }),
+        },
+    })),
+}));
+jest.mock("@privy-io/server-auth/viem", () => ({
+    getWalletClient: jest.fn().mockReturnValue({
+        account: {
+            address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+        },
+        chain: {
+            id: 1,
+            name: "Ethereum",
+            rpcUrls: {
+                default: { http: ["https://eth.llamarpc.com"] },
+            },
+            nativeCurrency: {
+                name: "Ether",
+                symbol: "ETH",
+                decimals: 18,
+            },
+        },
+        signMessage: jest.fn().mockResolvedValue("0x1234"),
+        signTypedData: jest.fn().mockResolvedValue("0x5678"),
+        signTransaction: jest.fn().mockResolvedValue("0xabcd"),
+        sendTransaction: jest.fn().mockResolvedValue("0xef01"),
+    }),
+    getPublicClient: jest.fn().mockReturnValue({
+        getChainId: jest.fn().mockResolvedValue(1),
+        getBalance: jest.fn().mockResolvedValue(BigInt(1000000000000000000)),
+        waitForTransactionReceipt: jest.fn().mockResolvedValue({ transactionHash: "0xef01" }),
+        readContract: jest.fn().mockResolvedValue("mock_result"),
+        estimateFeesPerGas: jest.fn().mockResolvedValue({
+            maxFeePerGas: BigInt(100000000),
+            maxPriorityFeePerGas: BigInt(10000000),
+        }),
+        estimateGas: jest.fn().mockResolvedValue(BigInt(21000)),
+    }),
+    createViemAccount: jest.fn().mockResolvedValue({
+        address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+        type: "local",
+        signMessage: jest.fn().mockResolvedValue("0x1234"),
+        signTypedData: jest.fn().mockResolvedValue("0x5678"),
+        signTransaction: jest.fn().mockResolvedValue("0xabcd"),
+    }),
+}));
+jest.mock("../network", () => {
+    const chain = {
+        id: 1,
+        name: "Ethereum",
+        rpcUrls: {
+            default: { http: ["https://eth.llamarpc.com"] },
+        },
+        nativeCurrency: {
+            name: "Ether",
+            symbol: "ETH",
+            decimals: 18,
+        },
+    };
+    return {
+        getNetwork: jest.fn().mockReturnValue({
+            protocolFamily: "evm",
+            chainId: "1",
+            networkId: "ethereum-mainnet",
+        }),
+        getChain: jest.fn().mockReturnValue(chain),
+        CHAIN_ID_TO_NETWORK_ID: {
+            "1": "ethereum-mainnet",
+            "5": "ethereum-goerli",
+            "11155111": "ethereum-sepolia",
+        },
+        NETWORK_ID_TO_CHAIN_ID: {
+            "ethereum-mainnet": "1",
+            "ethereum-goerli": "5",
+            "ethereum-sepolia": "11155111",
+        },
+    };
+});
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        createPublicClient: jest.fn().mockReturnValue({
+            getChainId: jest.fn().mockResolvedValue(1),
+            getBalance: jest.fn().mockResolvedValue(BigInt(1000000000000000000)),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({ transactionHash: "0xef01" }),
+            readContract: jest.fn().mockResolvedValue("mock_result"),
+            estimateFeesPerGas: jest.fn().mockResolvedValue({
+                maxFeePerGas: BigInt(100000000),
+                maxPriorityFeePerGas: BigInt(10000000),
+            }),
+            estimateGas: jest.fn().mockResolvedValue(BigInt(21000)),
+        }),
+        createWalletClient: jest.fn().mockReturnValue({
+            account: {
+                address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+            },
+            chain: {
+                id: 1,
+                name: "Ethereum",
+                rpcUrls: {
+                    default: { http: ["https://eth.llamarpc.com"] },
+                },
+                nativeCurrency: {
+                    name: "Ether",
+                    symbol: "ETH",
+                    decimals: 18,
+                },
+            },
+            signMessage: jest.fn().mockResolvedValue("0x1234"),
+            signTypedData: jest.fn().mockResolvedValue("0x5678"),
+            signTransaction: jest.fn().mockResolvedValue("0xabcd"),
+            sendTransaction: jest.fn().mockResolvedValue("0xef01"),
+        }),
+        parseEther: jest.fn().mockReturnValue(BigInt(1000000000000000000)),
+    };
+});
+jest.mock("./privyShared", () => ({
+    createPrivyWallet: jest.fn().mockResolvedValue({
+        wallet: {
+            id: "test-wallet-id",
+            address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+        },
+        privy: {
+            appId: "mock-app-id",
+            walletApi: {
+                create: jest.fn(),
+                getWallet: jest.fn(),
+            },
+        },
+    }),
+}));
+describe("PrivyEvmWalletProvider", () => {
+    const MOCK_CONFIG = {
+        appId: "mock-app-id",
+        apiKey: "mock-api-key",
+        appSecret: "mock-app-secret",
+        networkId: "ethereum-mainnet",
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("configureWithWallet", () => {
+        it("should configure a wallet with required configuration", async () => {
+            const provider = await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(MOCK_CONFIG);
+            expect(provider).toBeInstanceOf(privyEvmWalletProvider_1.PrivyEvmWalletProvider);
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "evm",
+                chainId: "1",
+                networkId: "ethereum-mainnet",
+            });
+        });
+        it("should configure a wallet with chain ID", async () => {
+            const provider = await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet({
+                ...MOCK_CONFIG,
+                chainId: "5",
+            });
+            expect(provider).toBeInstanceOf(privyEvmWalletProvider_1.PrivyEvmWalletProvider);
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "evm",
+                chainId: "1",
+                networkId: "ethereum-mainnet",
+            });
+        });
+        it("should configure a wallet with existing wallet ID", async () => {
+            const provider = await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet({
+                ...MOCK_CONFIG,
+                walletId: "existing-wallet-id",
+            });
+            expect(provider).toBeInstanceOf(privyEvmWalletProvider_1.PrivyEvmWalletProvider);
+        });
+    });
+    describe("wallet methods", () => {
+        let provider;
+        beforeEach(async () => {
+            provider = await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(MOCK_CONFIG);
+        });
+        it("should get the wallet address", () => {
+            expect(provider.getAddress()).toBe(MOCK_ADDRESS);
+        });
+        it("should get the network information", () => {
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "evm",
+                chainId: "1",
+                networkId: "ethereum-mainnet",
+            });
+        });
+        it("should get the provider name", () => {
+            expect(provider.getName()).toBe("privy_evm_wallet_provider");
+        });
+        it("should sign a message", async () => {
+            const result = await provider.signMessage("Hello, world!");
+            expect(result).toBe(MOCK_SIGNATURE_HASH_1);
+        });
+        it("should sign typed data", async () => {
+            const typedData = {
+                domain: { name: "Test" },
+                types: { Test: [{ name: "test", type: "string" }] },
+                primaryType: "Test",
+                message: { test: "test" },
+            };
+            const result = await provider.signTypedData(typedData);
+            expect(result).toBe(MOCK_SIGNATURE_HASH_2);
+        });
+        it("should sign a transaction", async () => {
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: 1000000000000000000n,
+            };
+            const result = await provider.signTransaction(transaction);
+            expect(result).toBe(MOCK_SIGNATURE_HASH_3);
+        });
+        it("should send a transaction", async () => {
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: 1000000000000000000n,
+            };
+            const result = await provider.sendTransaction(transaction);
+            expect(result).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should get the wallet balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(BigInt(1000000000000000000));
+        });
+        it("should wait for transaction receipt", async () => {
+            const receipt = await provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH);
+            expect(receipt).toEqual({ transactionHash: MOCK_TRANSACTION_HASH });
+        });
+        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 params = {
+                address: "0x1234567890123456789012345678901234567890",
+                abi,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            const result = await provider.readContract(params);
+            expect(result).toBe("mock_result");
+        });
+        it("should transfer native tokens", async () => {
+            const result = await provider.nativeTransfer("0x1234567890123456789012345678901234567890", "1.0");
+            expect(result).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should export wallet data", () => {
+            const exportData = provider.exportWallet();
+            expect(exportData).toEqual({
+                walletId: MOCK_WALLET_ID,
+                authorizationPrivateKey: undefined,
+                chainId: "1",
+                networkId: "ethereum-mainnet",
+            });
+        });
+        it("should handle authorization key requirements properly", async () => {
+            const authorizationKeyId = "test-auth-key-id";
+            const mockPrivyClient = {
+                walletApi: {
+                    create: jest.fn().mockImplementation(({ authorizationKeyIds }) => {
+                        if (authorizationKeyIds && authorizationKeyIds.length > 0) {
+                            throw new Error("Missing `privy-authorization-signature` header");
+                        }
+                        return Promise.resolve({
+                            id: "test-wallet-id",
+                            address: MOCK_ADDRESS,
+                        });
+                    }),
+                },
+            };
+            const privyServerAuth = jest.requireMock("@privy-io/server-auth");
+            const originalMockImplementation = privyServerAuth.PrivyClient.getMockImplementation();
+            privyServerAuth.PrivyClient.mockImplementation(() => mockPrivyClient);
+            await expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet({
+                appId: "test-app-id",
+                appSecret: "test-app-secret",
+                authorizationKeyId,
+            })).rejects.toThrow("authorizationPrivateKey is required when creating a new wallet with an authorizationKeyId");
+            privyServerAuth.PrivyClient.mockImplementation(originalMockImplementation);
+        });
+        it("should handle wallet creation errors", async () => {
+            const mockPrivyClient = {
+                walletApi: {
+                    create: jest.fn().mockRejectedValue(new Error("API rate limit exceeded")),
+                },
+            };
+            const privyServerAuth = jest.requireMock("@privy-io/server-auth");
+            const originalMockImplementation = privyServerAuth.PrivyClient.getMockImplementation();
+            privyServerAuth.PrivyClient.mockImplementation(() => mockPrivyClient);
+            const originalConsoleError = console.error;
+            console.error = jest.fn();
+            await expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet({
+                appId: "test-app-id",
+                appSecret: "test-app-secret",
+            })).rejects.toThrow("Failed to create wallet");
+            console.error = originalConsoleError;
+            privyServerAuth.PrivyClient.mockImplementation(originalMockImplementation);
+        });
+    });
+});

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

@@ -0,0 +1,40 @@
+import { PrivyClient, Wallet } from "@privy-io/server-auth";
+/**
+ * Configuration options for the Privy wallet provider.
+ *
+ * @interface
+ */
+export interface PrivyWalletConfig {
+    /** The Privy application ID */
+    appId: string;
+    /** The Privy application secret */
+    appSecret: string;
+    /** The ID of the wallet to use, if not provided a new wallet will be created */
+    walletId?: string;
+    /** Optional authorization key for the wallet API */
+    authorizationPrivateKey?: string;
+    /** Optional authorization key ID for creating new wallets */
+    authorizationKeyId?: string;
+    /** The chain type to create the wallet on */
+    chainType?: "ethereum" | "solana";
+}
+export type PrivyWalletExport = {
+    walletId: string;
+    authorizationPrivateKey: string | undefined;
+    chainId: string | undefined;
+    networkId: string | undefined;
+};
+type CreatePrivyWalletReturnType = {
+    wallet: Wallet & {
+        id: string;
+    };
+    privy: PrivyClient;
+};
+/**
+ * Create a Privy wallet
+ *
+ * @param config - The configuration options for the Privy wallet
+ * @returns The created Privy wallet
+ */
+export declare function createPrivyWallet(config: PrivyWalletConfig): Promise<CreatePrivyWalletReturnType>;
+export {};

package/dist/wallet-providers/privyShared.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrivyWallet = createPrivyWallet;
+const server_auth_1 = require("@privy-io/server-auth");
+/**
+ * Create a Privy wallet
+ *
+ * @param config - The configuration options for the Privy wallet
+ * @returns The created Privy wallet
+ */
+async function createPrivyWallet(config) {
+    const privy = new server_auth_1.PrivyClient(config.appId, config.appSecret, {
+        walletApi: config.authorizationPrivateKey
+            ? {
+                authorizationPrivateKey: config.authorizationPrivateKey,
+            }
+            : undefined,
+    });
+    if (config.walletId) {
+        const wallet = await privy.walletApi.getWallet({ id: config.walletId });
+        if (!wallet) {
+            throw new Error(`Wallet with ID ${config.walletId} not found`);
+        }
+        return { wallet, privy };
+    }
+    if (config.authorizationPrivateKey && !config.authorizationKeyId) {
+        throw new Error("authorizationKeyId is required when creating a new wallet with an authorization key, this can be found in your Privy Dashboard");
+    }
+    if (config.authorizationKeyId && !config.authorizationPrivateKey) {
+        throw new Error("authorizationPrivateKey is required when creating a new wallet with an authorizationKeyId. " +
+            "If you don't have it, you can create a new one in your Privy Dashboard, or delete the authorization key.");
+    }
+    try {
+        const wallet = await privy.walletApi.create({
+            chainType: config.chainType,
+            authorizationKeyIds: config.authorizationKeyId ? [config.authorizationKeyId] : undefined,
+        });
+        return { wallet, privy };
+    }
+    catch (error) {
+        console.error(error);
+        if (error instanceof Error &&
+            error.message.includes("Missing `privy-authorization-signature` header")) {
+            // Providing a more informative error message, see context: https://github.com/coinbase/agentkit/pull/242#discussion_r1956428617
+            throw new Error("Privy error: you have an authorization key on your account which can create and modify wallets, please delete this key or pass it to the PrivyWalletProvider to create a new wallet");
+        }
+        throw new Error("Failed to create wallet");
+    }
+}

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

@@ -0,0 +1,128 @@
+import { SvmWalletProvider } from "./svmWalletProvider";
+import { RpcResponseAndContext, SignatureStatus, VersionedTransaction, Connection, PublicKey, SignatureResult } from "@solana/web3.js";
+import { Network } from "../network/types";
+import { PrivyWalletConfig, PrivyWalletExport } from "./privyShared";
+/**
+ * Configuration options for the Privy Svm wallet provider.
+ */
+export interface PrivySvmWalletConfig extends PrivyWalletConfig {
+    /** The network ID to use for the wallet */
+    networkId?: string;
+    /** The connection to use for the wallet */
+    connection?: Connection;
+}
+/**
+ * A wallet provider that uses Privy's server wallet API.
+ * This provider extends the SvmWalletProvider to provide Privy-specific wallet functionality
+ * while maintaining compatibility with the base wallet provider interface.
+ */
+export declare class PrivySvmWalletProvider extends SvmWalletProvider {
+    #private;
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param config - The configuration options for the Privy wallet
+     */
+    private constructor();
+    /**
+     * Creates and configures a new PrivySolanaWalletProvider instance.
+     *
+     * @param config - The configuration options for the Privy wallet
+     * @returns A configured PrivySolanaWalletProvider instance
+     *
+     * @example
+     * ```typescript
+     * const provider = await PrivySolanaWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   walletId: "wallet-id",
+     * });
+     * ```
+     */
+    static configureWithWallet<T extends PrivySvmWalletProvider>(config: PrivySvmWalletConfig): Promise<T>;
+    /**
+     * Sign a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    signTransaction(transaction: VersionedTransaction): Promise<VersionedTransaction>;
+    /**
+     * Sign and send a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The transaction hash.
+     */
+    signAndSendTransaction(transaction: VersionedTransaction): Promise<string>;
+    /**
+     * Send a transaction.
+     *
+     * @param _ - The transaction to send.
+     * @returns The transaction hash.
+     */
+    sendTransaction(_: VersionedTransaction): Promise<string>;
+    /**
+     * Exports the wallet data.
+     *
+     * @returns The wallet data
+     */
+    exportWallet(): PrivyWalletExport;
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The string identifier for this wallet provider
+     */
+    getName(): string;
+    /**
+     * Get the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress(): string;
+    /**
+     * Get the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork(): Network;
+    /**
+     * Get the balance of the wallet.
+     *
+     * @returns The balance of the wallet.
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Transfer a native token.
+     *
+     * @param _ - The address to transfer the token to.
+     * @param arg2 - The value to transfer.
+     * @returns The transaction hash.
+     */
+    nativeTransfer(_: string, arg2: string): Promise<string>;
+    /**
+     * Get the status of a transaction.
+     *
+     * @param signature - The transaction signature.
+     * @returns The transaction status.
+     */
+    getSignatureStatus(signature: string): Promise<RpcResponseAndContext<SignatureStatus | null>>;
+    /**
+     * Wait for a signature result.
+     *
+     * @param signature - The signature to wait for.
+     * @returns The signature result.
+     */
+    waitForSignatureResult(signature: string): Promise<RpcResponseAndContext<SignatureResult>>;
+    /**
+     * Get the connection.
+     *
+     * @returns The connection.
+     */
+    getConnection(): Connection;
+    /**
+     * Get the public key.
+     *
+     * @returns The public key.
+     */
+    getPublicKey(): PublicKey;
+}