@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,51 @@
+import { WalletProvider } from "./walletProvider";
+import { TransactionRequest, ReadContractParameters, ReadContractReturnType, ContractFunctionName, Abi, ContractFunctionArgs } from "viem";
+/**
+ * EvmWalletProvider is the abstract base class for all EVM wallet providers.
+ *
+ * @abstract
+ */
+export declare abstract class EvmWalletProvider extends WalletProvider {
+    /**
+     * Sign a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    abstract signMessage(message: string | Uint8Array): Promise<`0x${string}`>;
+    /**
+     * Sign a typed data.
+     *
+     * @param typedData - The typed data to sign.
+     * @returns The signed typed data.
+     */
+    abstract signTypedData(typedData: any): Promise<`0x${string}`>;
+    /**
+     * Sign a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    abstract signTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * Send a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The transaction hash.
+     */
+    abstract sendTransaction(transaction: TransactionRequest): Promise<`0x${string}`>;
+    /**
+     * Wait for a transaction receipt.
+     *
+     * @param txHash - The transaction hash.
+     * @returns The transaction receipt.
+     */
+    abstract waitForTransactionReceipt(txHash: `0x${string}`): Promise<any>;
+    /**
+     * Read a contract.
+     *
+     * @param params - The parameters to read the contract.
+     * @returns The response from the contract.
+     */
+    abstract 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>>;
+}

package/dist/wallet-providers/evmWalletProvider.js

@@ -0,0 +1,14 @@
+"use strict";
+// TODO: Improve type safety
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWalletProvider = void 0;
+const walletProvider_1 = require("./walletProvider");
+/**
+ * EvmWalletProvider is the abstract base class for all EVM wallet providers.
+ *
+ * @abstract
+ */
+class EvmWalletProvider extends walletProvider_1.WalletProvider {
+}
+exports.EvmWalletProvider = EvmWalletProvider;

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const evmWalletProvider_1 = require("./evmWalletProvider");
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+const EXPECTED_EVM_METHODS = [
+    "signMessage",
+    "signTypedData",
+    "signTransaction",
+    "sendTransaction",
+    "waitForTransactionReceipt",
+    "readContract",
+];
+const EXPECTED_BASE_METHODS = [
+    "getAddress",
+    "getNetwork",
+    "getName",
+    "getBalance",
+    "nativeTransfer",
+];
+describe("EvmWalletProvider", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        evmWalletProvider_1.EvmWalletProvider.prototype.signMessage = jest.fn();
+        evmWalletProvider_1.EvmWalletProvider.prototype.signTypedData = jest.fn();
+        evmWalletProvider_1.EvmWalletProvider.prototype.signTransaction = jest.fn();
+        evmWalletProvider_1.EvmWalletProvider.prototype.sendTransaction = jest.fn();
+        evmWalletProvider_1.EvmWalletProvider.prototype.waitForTransactionReceipt = jest.fn();
+        evmWalletProvider_1.EvmWalletProvider.prototype.readContract = jest.fn();
+    });
+    it("should define abstract methods (TypeScript only - not a runtime check)", () => {
+        const allExpectedMethods = [...EXPECTED_EVM_METHODS, ...EXPECTED_BASE_METHODS];
+        expect(Array.isArray(allExpectedMethods)).toBe(true);
+    });
+    it("should extend WalletProvider", () => {
+        const proto = Object.getPrototypeOf(evmWalletProvider_1.EvmWalletProvider);
+        const protoName = proto.name;
+        expect(protoName).toBe("WalletProvider");
+    });
+    it("should have consistent method signatures", () => {
+        const signMessageDescriptor = Object.getOwnPropertyDescriptor(evmWalletProvider_1.EvmWalletProvider.prototype, "signMessage");
+        expect(signMessageDescriptor).toBeDefined();
+        expect(typeof signMessageDescriptor.value).toBe("function");
+        const signTypedDataDescriptor = Object.getOwnPropertyDescriptor(evmWalletProvider_1.EvmWalletProvider.prototype, "signTypedData");
+        expect(signTypedDataDescriptor).toBeDefined();
+        expect(typeof signTypedDataDescriptor.value).toBe("function");
+        const readContractDescriptor = Object.getOwnPropertyDescriptor(evmWalletProvider_1.EvmWalletProvider.prototype, "readContract");
+        expect(readContractDescriptor).toBeDefined();
+        expect(typeof readContractDescriptor.value).toBe("function");
+    });
+});

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

@@ -0,0 +1,10 @@
+export * from "./walletProvider";
+export * from "./evmWalletProvider";
+export * from "./viemWalletProvider";
+export * from "./cdpWalletProvider";
+export * from "./svmWalletProvider";
+export * from "./smartWalletProvider";
+export * from "./solanaKeypairWalletProvider";
+export * from "./privyWalletProvider";
+export * from "./privyEvmWalletProvider";
+export * from "./privySvmWalletProvider";

package/dist/wallet-providers/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./walletProvider"), exports);
+__exportStar(require("./evmWalletProvider"), exports);
+__exportStar(require("./viemWalletProvider"), exports);
+__exportStar(require("./cdpWalletProvider"), exports);
+__exportStar(require("./svmWalletProvider"), exports);
+__exportStar(require("./smartWalletProvider"), exports);
+__exportStar(require("./solanaKeypairWalletProvider"), exports);
+__exportStar(require("./privyWalletProvider"), exports);
+__exportStar(require("./privyEvmWalletProvider"), exports);
+__exportStar(require("./privySvmWalletProvider"), exports);

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

@@ -0,0 +1,55 @@
+import { ViemWalletProvider } from "./viemWalletProvider";
+import { PrivyWalletConfig, PrivyWalletExport } from "./privyShared";
+/**
+ * Configuration options for the Privy wallet provider.
+ *
+ * @interface
+ */
+export interface PrivyEvmWalletConfig extends PrivyWalletConfig {
+    /** Optional chain ID to connect to */
+    chainId?: string;
+}
+/**
+ * A wallet provider that uses Privy's server wallet API.
+ * This provider extends the ViemWalletProvider to provide Privy-specific wallet functionality
+ * while maintaining compatibility with the base wallet provider interface.
+ */
+export declare class PrivyEvmWalletProvider extends ViemWalletProvider {
+    #private;
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param walletClient - The Viem wallet client instance
+     * @param config - The configuration options for the Privy wallet
+     */
+    private constructor();
+    /**
+     * Creates and configures a new PrivyWalletProvider instance.
+     *
+     * @param config - The configuration options for the Privy wallet
+     * @returns A configured PrivyWalletProvider instance
+     *
+     * @example
+     * ```typescript
+     * const provider = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   walletId: "wallet-id",
+     *   chainId: "84532"
+     * });
+     * ```
+     */
+    static configureWithWallet(config: PrivyEvmWalletConfig): Promise<PrivyEvmWalletProvider>;
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The string identifier for this wallet provider
+     */
+    getName(): string;
+    /**
+     * Exports the wallet data.
+     *
+     * @returns The wallet data
+     */
+    exportWallet(): PrivyWalletExport;
+}

package/dist/wallet-providers/privyEvmWalletProvider.js

@@ -0,0 +1,140 @@
+"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 _PrivyEvmWalletProvider_walletId, _PrivyEvmWalletProvider_authorizationPrivateKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivyEvmWalletProvider = void 0;
+const server_auth_1 = require("@privy-io/server-auth");
+const viem_1 = require("@privy-io/server-auth/viem");
+const viemWalletProvider_1 = require("./viemWalletProvider");
+const viem_2 = require("viem");
+const network_1 = require("../network/network");
+/**
+ * A wallet provider that uses Privy's server wallet API.
+ * This provider extends the ViemWalletProvider to provide Privy-specific wallet functionality
+ * while maintaining compatibility with the base wallet provider interface.
+ */
+class PrivyEvmWalletProvider extends viemWalletProvider_1.ViemWalletProvider {
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param walletClient - The Viem wallet client instance
+     * @param config - The configuration options for the Privy wallet
+     */
+    constructor(walletClient, config) {
+        super(walletClient);
+        _PrivyEvmWalletProvider_walletId.set(this, void 0);
+        _PrivyEvmWalletProvider_authorizationPrivateKey.set(this, void 0);
+        __classPrivateFieldSet(this, _PrivyEvmWalletProvider_walletId, config.walletId, "f"); // Now guaranteed to exist
+        __classPrivateFieldSet(this, _PrivyEvmWalletProvider_authorizationPrivateKey, config.authorizationPrivateKey, "f");
+    }
+    /**
+     * Creates and configures a new PrivyWalletProvider instance.
+     *
+     * @param config - The configuration options for the Privy wallet
+     * @returns A configured PrivyWalletProvider instance
+     *
+     * @example
+     * ```typescript
+     * const provider = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   walletId: "wallet-id",
+     *   chainId: "84532"
+     * });
+     * ```
+     */
+    static async configureWithWallet(config) {
+        const privy = new server_auth_1.PrivyClient(config.appId, config.appSecret, {
+            walletApi: config.authorizationPrivateKey
+                ? {
+                    authorizationPrivateKey: config.authorizationPrivateKey,
+                }
+                : undefined,
+        });
+        let walletId;
+        let address;
+        if (!config.walletId) {
+            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: "ethereum",
+                    authorizationKeyIds: config.authorizationKeyId ? [config.authorizationKeyId] : undefined,
+                });
+                walletId = wallet.id;
+                address = wallet.address;
+            }
+            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");
+            }
+        }
+        else {
+            walletId = config.walletId;
+            const wallet = await privy.walletApi.getWallet({ id: walletId });
+            if (!wallet) {
+                throw new Error(`Wallet with ID ${walletId} not found`);
+            }
+            address = wallet.address;
+        }
+        const account = await (0, viem_1.createViemAccount)({
+            walletId,
+            address,
+            privy,
+        });
+        const chainId = config.chainId || "84532";
+        const chain = (0, network_1.getChain)(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        const walletClient = (0, viem_2.createWalletClient)({
+            account,
+            chain,
+            transport: (0, viem_2.http)(),
+        });
+        return new PrivyEvmWalletProvider(walletClient, { ...config, walletId });
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The string identifier for this wallet provider
+     */
+    getName() {
+        return "privy_evm_wallet_provider";
+    }
+    /**
+     * Exports the wallet data.
+     *
+     * @returns The wallet data
+     */
+    exportWallet() {
+        return {
+            walletId: __classPrivateFieldGet(this, _PrivyEvmWalletProvider_walletId, "f"),
+            authorizationPrivateKey: __classPrivateFieldGet(this, _PrivyEvmWalletProvider_authorizationPrivateKey, "f"),
+            chainId: this.getNetwork().chainId,
+            networkId: this.getNetwork().networkId,
+        };
+    }
+}
+exports.PrivyEvmWalletProvider = PrivyEvmWalletProvider;
+_PrivyEvmWalletProvider_walletId = new WeakMap(), _PrivyEvmWalletProvider_authorizationPrivateKey = new WeakMap();

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

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