@coinbase/agentkit 0.2.0 → 0.2.1

package/README.md

@@ -34,6 +34,9 @@ AgentKit is a framework for easily enabling AI agents to take actions onchain. I
   - [SolanaKeypairWalletProvider](#solanakeypairwalletprovider)
     - [Network Configuration](#solana-network-configuration)
     - [RPC URL Configuration](#rpc-url-configuration)
+  - [PrivyWalletProvider](#privywalletprovider-solana)
+    - [Authorization Keys](#authorization-keys)
+    - [Exporting Privy Wallet information](#exporting-privy-wallet-information)
 - [Contributing](#contributing)
 
 ## Getting Started
@@ -634,6 +637,72 @@ const rpcUrl = process.env.SOLANA_RPC_URL;
 const walletProvider = await SolanaKeypairWalletProvider.fromRpcUrl(network, privateKey);
 ```
 
+### PrivyWalletProvider (Solana)
+
+The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/).
+
+```typescript
+import { PrivyWalletProvider } from "@coinbase/agentkit";
+
+// Configure Wallet Provider
+const config = {
+    appId: "PRIVY_APP_ID",
+    appSecret: "PRIVY_APP_SECRET",
+    chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
+    networkId: "solana-devnet", // optional, defaults to "solana-devnet"
+    walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
+    authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
+    authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
+};
+
+const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
+```
+
+Optionally, you can configure your own `@solana/web3.js` connection by passing the `connection` parameter to the `configureWithWallet` method.
+
+```typescript
+import { PrivyWalletProvider } from "@coinbase/agentkit";
+
+const connection = new Connection("YOUR_RPC_URL");
+
+// Configure Wallet Provider
+const config = {
+    appId: "PRIVY_APP_ID",
+    appSecret: "PRIVY_APP_SECRET",
+    connection,
+    chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
+    networkId: "solana-devnet", // optional, defaults to "solana-devnet"
+    walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
+    authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
+    authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
+};
+
+const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
+```
+
+#### Authorization Keys
+
+Privy offers the option to use authorization keys to secure your server wallets.
+
+You can manage authorization keys from your [Privy dashboard](https://dashboard.privy.io/account) or programmatically [using the API](https://docs.privy.io/guide/server-wallets/authorization/signatures).
+
+When using authorization keys, you must provide the `authorizationPrivateKey` and `authorizationKeyId` parameters to the `configureWithWallet` method if you are creating a new wallet. Please note that when creating a key, if you enable "Create and modify wallets", you will be required to use that key when creating new wallets via the PrivyWalletProvider.
+
+#### Exporting Privy Wallet information
+
+The `PrivyWalletProvider` can export wallet information by calling the `exportWallet` method.
+
+```typescript
+const walletData = await walletProvider.exportWallet();
+
+// walletData will be in the following format:
+{
+    walletId: string;
+    authorizationKey: string | undefined;
+    networkId: string | undefined;
+}
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](../../CONTRIBUTING.md) for more information.

package/dist/action-providers/spl/schemas.d.ts

@@ -15,3 +15,16 @@ export declare const TransferTokenSchema: z.ZodObject<{
     recipient: string;
     mintAddress: string;
 }>;
+/**
+ * Schema for getting SPL token balance.
+ */
+export declare const GetBalanceSchema: z.ZodObject<{
+    mintAddress: z.ZodString;
+    address: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mintAddress: string;
+    address?: string | undefined;
+}, {
+    mintAddress: string;
+    address?: string | undefined;
+}>;

package/dist/action-providers/spl/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransferTokenSchema = void 0;
+exports.GetBalanceSchema = exports.TransferTokenSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Schema for transferring SPL tokens to another address.
@@ -12,3 +12,15 @@ exports.TransferTokenSchema = zod_1.z
     amount: zod_1.z.number().positive().describe("Amount of tokens to transfer"),
 })
     .describe("Transfer SPL tokens to another Solana address");
+/**
+ * Schema for getting SPL token balance.
+ */
+exports.GetBalanceSchema = zod_1.z
+    .object({
+    mintAddress: zod_1.z.string().describe("The SPL token's mint address"),
+    address: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional address to check balance for. If not provided, uses the wallet's address"),
+})
+    .describe("Get SPL token balance for an address");

package/dist/action-providers/spl/splActionProvider.d.ts

@@ -2,7 +2,7 @@ import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
 import { SvmWalletProvider } from "../../wallet-providers/svmWalletProvider";
 import { z } from "zod";
-import { TransferTokenSchema } from "./schemas";
+import { TransferTokenSchema, GetBalanceSchema } from "./schemas";
 /**
  * SplActionProvider serves as a provider for SPL token actions.
  * It provides SPL token transfer functionality.
@@ -12,6 +12,14 @@ export declare class SplActionProvider extends ActionProvider<SvmWalletProvider>
      * Creates a new SplActionProvider instance.
      */
     constructor();
+    /**
+     * Get the balance of SPL tokens for an address.
+     *
+     * @param walletProvider - The wallet provider to use
+     * @param args - Parameters including mint address and optional target address
+     * @returns A message indicating the token balance
+     */
+    getBalance(walletProvider: SvmWalletProvider, args: z.infer<typeof GetBalanceSchema>): Promise<string>;
     /**
      * Transfer SPL tokens to another address.
      *

package/dist/action-providers/spl/splActionProvider.js

@@ -27,6 +27,39 @@ class SplActionProvider extends actionProvider_1.ActionProvider {
     constructor() {
         super("spl", []);
     }
+    /**
+     * Get the balance of SPL tokens for an address.
+     *
+     * @param walletProvider - The wallet provider to use
+     * @param args - Parameters including mint address and optional target address
+     * @returns A message indicating the token balance
+     */
+    async getBalance(walletProvider, args) {
+        try {
+            const connection = walletProvider.getConnection();
+            const mintPubkey = new web3_js_1.PublicKey(args.mintAddress);
+            const ownerPubkey = args.address
+                ? new web3_js_1.PublicKey(args.address)
+                : walletProvider.getPublicKey();
+            const { getMint, getAssociatedTokenAddress, getAccount } = await import("@solana/spl-token");
+            const mintInfo = await getMint(connection, mintPubkey);
+            const ata = await getAssociatedTokenAddress(mintPubkey, ownerPubkey);
+            try {
+                const account = await getAccount(connection, ata);
+                const balance = Number(account.amount) / Math.pow(10, mintInfo.decimals);
+                return `Balance for ${args.address || "connected wallet"} is ${balance} tokens`;
+            }
+            catch (error) {
+                if (error.message.includes("could not find account")) {
+                    return `Balance for ${args.address || "connected wallet"} is 0 tokens`;
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            return `Error getting SPL token balance: ${error}`;
+        }
+    }
     /**
      * Transfer SPL tokens to another address.
      *
@@ -86,6 +119,21 @@ class SplActionProvider extends actionProvider_1.ActionProvider {
     }
 }
 exports.SplActionProvider = SplActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_balance",
+        description: `
+    This tool will get the balance of SPL tokens for an address.
+    - Mint address must be a valid SPL token mint
+    - If no address is provided, uses the connected wallet's address
+    - Returns the token balance in token units (not raw)
+    `,
+        schema: schemas_1.GetBalanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [svmWalletProvider_1.SvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SplActionProvider.prototype, "getBalance", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "transfer",

package/dist/action-providers/spl/splActionProvider.test.js

@@ -203,4 +203,61 @@ describe("SplActionProvider", () => {
             expect(result).toContain(`Successfully transferred ${transferArgs.amount} tokens`);
         });
     });
+    describe("getBalance", () => {
+        const MINT_ADDRESS = "So11111111111111111111111111111111111111112";
+        const TARGET_ADDRESS = "DjXsn34uz8yCBQ8bevLrEPYYC1RvhHvjzuVF8opNc4K2";
+        const SENDER_ADDRESS = "11111111111111111111111111111111";
+        const balanceArgs = {
+            mintAddress: MINT_ADDRESS,
+        };
+        const balanceWithAddressArgs = {
+            mintAddress: MINT_ADDRESS,
+            address: TARGET_ADDRESS,
+        };
+        const mockTokenAccount = {
+            amount: BigInt(1000000000),
+            address: new web3_js_1.PublicKey(MINT_ADDRESS),
+            mint: new web3_js_1.PublicKey(MINT_ADDRESS),
+            owner: new web3_js_1.PublicKey(TARGET_ADDRESS),
+            delegate: null,
+            delegatedAmount: BigInt(0),
+            closeAuthority: null,
+            isFrozen: false,
+            isNative: false,
+            rentExemptReserve: null,
+            isInitialized: true,
+            tlvData: new Map(),
+        };
+        beforeEach(() => {
+            mockWallet.getPublicKey.mockReturnValue(new web3_js_1.PublicKey(SENDER_ADDRESS));
+            mockWallet.getAddress.mockReturnValue(SENDER_ADDRESS);
+        });
+        it("should get balance for connected wallet", async () => {
+            mockGetAccount.mockResolvedValue(mockTokenAccount);
+            const result = await actionProvider.getBalance(mockWallet, balanceArgs);
+            expect(mockGetAssociatedTokenAddress).toHaveBeenCalledWith(new web3_js_1.PublicKey(balanceArgs.mintAddress), new web3_js_1.PublicKey(SENDER_ADDRESS));
+            expect(mockGetMint).toHaveBeenCalledWith(mockConnection, new web3_js_1.PublicKey(balanceArgs.mintAddress));
+            expect(mockGetAccount).toHaveBeenCalled();
+            expect(result).toBe("Balance for connected wallet is 1000 tokens");
+        });
+        it("should get balance for specified address", async () => {
+            mockGetAccount.mockResolvedValue(mockTokenAccount);
+            const result = await actionProvider.getBalance(mockWallet, balanceWithAddressArgs);
+            expect(mockGetAssociatedTokenAddress).toHaveBeenCalledWith(new web3_js_1.PublicKey(balanceWithAddressArgs.mintAddress), new web3_js_1.PublicKey(balanceWithAddressArgs.address));
+            expect(mockGetMint).toHaveBeenCalledWith(mockConnection, new web3_js_1.PublicKey(balanceWithAddressArgs.mintAddress));
+            expect(mockGetAccount).toHaveBeenCalled();
+            expect(result).toBe(`Balance for ${TARGET_ADDRESS} is 1000 tokens`);
+        });
+        it("should handle non-existent token account", async () => {
+            mockGetAccount.mockRejectedValue(new Error("could not find account"));
+            const result = await actionProvider.getBalance(mockWallet, balanceArgs);
+            expect(result).toBe("Balance for connected wallet is 0 tokens");
+        });
+        it("should handle errors", async () => {
+            const error = new Error("Test error");
+            mockGetAccount.mockRejectedValue(error);
+            const result = await actionProvider.getBalance(mockWallet, balanceArgs);
+            expect(result).toBe("Error getting SPL token balance: Error: Test error");
+        });
+    });
 });

package/dist/network/svm.d.ts

@@ -12,3 +12,4 @@ export declare const SOLANA_MAINNET_NETWORK: Network;
 export declare const SOLANA_TESTNET_NETWORK: Network;
 export declare const SOLANA_DEVNET_NETWORK: Network;
 export declare const SOLANA_NETWORKS: Record<SOLANA_CLUSTER, Network>;
+export declare const SOLANA_CLUSTER_ID_BY_NETWORK_ID: Record<SOLANA_NETWORK_ID, string>;

package/dist/network/svm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOLANA_NETWORKS = exports.SOLANA_DEVNET_NETWORK = exports.SOLANA_TESTNET_NETWORK = exports.SOLANA_MAINNET_NETWORK = exports.SOLANA_DEVNET_GENESIS_BLOCK_HASH = exports.SOLANA_TESTNET_GENESIS_BLOCK_HASH = exports.SOLANA_MAINNET_GENESIS_BLOCK_HASH = exports.SOLANA_PROTOCOL_FAMILY = exports.SOLANA_DEVNET_NETWORK_ID = exports.SOLANA_TESTNET_NETWORK_ID = exports.SOLANA_MAINNET_NETWORK_ID = void 0;
+exports.SOLANA_CLUSTER_ID_BY_NETWORK_ID = exports.SOLANA_NETWORKS = exports.SOLANA_DEVNET_NETWORK = exports.SOLANA_TESTNET_NETWORK = exports.SOLANA_MAINNET_NETWORK = exports.SOLANA_DEVNET_GENESIS_BLOCK_HASH = exports.SOLANA_TESTNET_GENESIS_BLOCK_HASH = exports.SOLANA_MAINNET_GENESIS_BLOCK_HASH = exports.SOLANA_PROTOCOL_FAMILY = exports.SOLANA_DEVNET_NETWORK_ID = exports.SOLANA_TESTNET_NETWORK_ID = exports.SOLANA_MAINNET_NETWORK_ID = void 0;
 // CDP Network IDs
 exports.SOLANA_MAINNET_NETWORK_ID = "solana-mainnet";
 exports.SOLANA_TESTNET_NETWORK_ID = "solana-testnet";
@@ -31,3 +31,8 @@ exports.SOLANA_NETWORKS = {
     [exports.SOLANA_TESTNET_GENESIS_BLOCK_HASH]: exports.SOLANA_TESTNET_NETWORK,
     [exports.SOLANA_DEVNET_GENESIS_BLOCK_HASH]: exports.SOLANA_DEVNET_NETWORK,
 };
+exports.SOLANA_CLUSTER_ID_BY_NETWORK_ID = {
+    [exports.SOLANA_MAINNET_NETWORK_ID]: "mainnet-beta",
+    [exports.SOLANA_TESTNET_NETWORK_ID]: "testnet",
+    [exports.SOLANA_DEVNET_NETWORK_ID]: "devnet",
+};

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

@@ -5,3 +5,5 @@ export * from "./cdpWalletProvider";
 export * from "./svmWalletProvider";
 export * from "./solanaKeypairWalletProvider";
 export * from "./privyWalletProvider";
+export * from "./privyEvmWalletProvider";
+export * from "./privySvmWalletProvider";

package/dist/wallet-providers/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./cdpWalletProvider"), exports);
 __exportStar(require("./svmWalletProvider"), 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/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;
+}

package/dist/wallet-providers/privySvmWalletProvider.js

@@ -0,0 +1,212 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PrivySvmWalletProvider_walletId, _PrivySvmWalletProvider_address, _PrivySvmWalletProvider_authorizationPrivateKey, _PrivySvmWalletProvider_privyClient, _PrivySvmWalletProvider_connection, _PrivySvmWalletProvider_genesisHash;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivySvmWalletProvider = void 0;
+const svmWalletProvider_1 = require("./svmWalletProvider");
+const web3_js_1 = require("@solana/web3.js");
+const svm_1 = require("../network/svm");
+const privyShared_1 = require("./privyShared");
+/**
+ * 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.
+ */
+class PrivySvmWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param config - The configuration options for the Privy wallet
+     */
+    constructor(config) {
+        super();
+        _PrivySvmWalletProvider_walletId.set(this, void 0);
+        _PrivySvmWalletProvider_address.set(this, void 0);
+        _PrivySvmWalletProvider_authorizationPrivateKey.set(this, void 0);
+        _PrivySvmWalletProvider_privyClient.set(this, void 0);
+        _PrivySvmWalletProvider_connection.set(this, void 0);
+        _PrivySvmWalletProvider_genesisHash.set(this, void 0);
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_walletId, config.walletId, "f");
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_address, config.address, "f");
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_authorizationPrivateKey, config.authorizationPrivateKey, "f");
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_privyClient, config.privyClient, "f");
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_connection, config.connection, "f");
+        __classPrivateFieldSet(this, _PrivySvmWalletProvider_genesisHash, config.genesisHash, "f");
+    }
+    /**
+     * 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 async configureWithWallet(config) {
+        const { wallet, privy } = await (0, privyShared_1.createPrivyWallet)(config);
+        const connection = config.connection ??
+            new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)(svm_1.SOLANA_CLUSTER_ID_BY_NETWORK_ID[config.networkId ?? ""]));
+        return new PrivySvmWalletProvider({
+            ...config,
+            walletId: wallet.id,
+            address: wallet.address,
+            privyClient: privy,
+            connection,
+            genesisHash: await connection.getGenesisHash(),
+        });
+    }
+    /**
+     * Sign a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    async signTransaction(transaction) {
+        const { signedTransaction } = await __classPrivateFieldGet(this, _PrivySvmWalletProvider_privyClient, "f").walletApi.solana.signTransaction({
+            walletId: __classPrivateFieldGet(this, _PrivySvmWalletProvider_walletId, "f"),
+            transaction,
+        });
+        return signedTransaction;
+    }
+    /**
+     * Sign and send a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The transaction hash.
+     */
+    async signAndSendTransaction(transaction) {
+        try {
+            const { hash } = await __classPrivateFieldGet(this, _PrivySvmWalletProvider_privyClient, "f").walletApi.solana.signAndSendTransaction({
+                walletId: __classPrivateFieldGet(this, _PrivySvmWalletProvider_walletId, "f"),
+                caip2: `solana:${__classPrivateFieldGet(this, _PrivySvmWalletProvider_genesisHash, "f").substring(0, 32)}`,
+                transaction,
+            });
+            return hash;
+        }
+        catch (error) {
+            console.error("Failed to send transaction", error);
+            throw new Error("Failed to send transaction");
+        }
+    }
+    /**
+     * Send a transaction.
+     *
+     * @param _ - The transaction to send.
+     * @returns The transaction hash.
+     */
+    async sendTransaction(_) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Exports the wallet data.
+     *
+     * @returns The wallet data
+     */
+    exportWallet() {
+        return {
+            walletId: __classPrivateFieldGet(this, _PrivySvmWalletProvider_walletId, "f"),
+            authorizationPrivateKey: __classPrivateFieldGet(this, _PrivySvmWalletProvider_authorizationPrivateKey, "f"),
+            chainId: this.getNetwork().chainId,
+            networkId: this.getNetwork().networkId,
+        };
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The string identifier for this wallet provider
+     */
+    getName() {
+        return "privy_svm_wallet_provider";
+    }
+    /**
+     * Get the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress() {
+        return __classPrivateFieldGet(this, _PrivySvmWalletProvider_address, "f");
+    }
+    /**
+     * Get the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork() {
+        return svm_1.SOLANA_NETWORKS[__classPrivateFieldGet(this, _PrivySvmWalletProvider_genesisHash, "f")];
+    }
+    /**
+     * Get the balance of the wallet.
+     *
+     * @returns The balance of the wallet.
+     */
+    async getBalance() {
+        const balance = await __classPrivateFieldGet(this, _PrivySvmWalletProvider_connection, "f").getBalance(new web3_js_1.PublicKey(__classPrivateFieldGet(this, _PrivySvmWalletProvider_address, "f")));
+        return BigInt(balance);
+    }
+    /**
+     * Transfer a native token.
+     *
+     * @param _ - The address to transfer the token to.
+     * @param arg2 - The value to transfer.
+     * @returns The transaction hash.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async nativeTransfer(_, arg2) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Get the status of a transaction.
+     *
+     * @param signature - The transaction signature.
+     * @returns The transaction status.
+     */
+    async getSignatureStatus(signature) {
+        return __classPrivateFieldGet(this, _PrivySvmWalletProvider_connection, "f").getSignatureStatus(signature);
+    }
+    /**
+     * Wait for a signature result.
+     *
+     * @param signature - The signature to wait for.
+     * @returns The signature result.
+     */
+    waitForSignatureResult(signature) {
+        return __classPrivateFieldGet(this, _PrivySvmWalletProvider_connection, "f").confirmTransaction({
+            signature,
+            ...svm_1.SOLANA_NETWORKS[__classPrivateFieldGet(this, _PrivySvmWalletProvider_genesisHash, "f")],
+        });
+    }
+    /**
+     * Get the connection.
+     *
+     * @returns The connection.
+     */
+    getConnection() {
+        return __classPrivateFieldGet(this, _PrivySvmWalletProvider_connection, "f");
+    }
+    /**
+     * Get the public key.
+     *
+     * @returns The public key.
+     */
+    getPublicKey() {
+        return new web3_js_1.PublicKey(__classPrivateFieldGet(this, _PrivySvmWalletProvider_address, "f"));
+    }
+}
+exports.PrivySvmWalletProvider = PrivySvmWalletProvider;
+_PrivySvmWalletProvider_walletId = new WeakMap(), _PrivySvmWalletProvider_address = new WeakMap(), _PrivySvmWalletProvider_authorizationPrivateKey = new WeakMap(), _PrivySvmWalletProvider_privyClient = new WeakMap(), _PrivySvmWalletProvider_connection = new WeakMap(), _PrivySvmWalletProvider_genesisHash = new WeakMap();

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

@@ -1,70 +1,35 @@
-import { ViemWalletProvider } from "./viemWalletProvider";
+import { PrivyEvmWalletProvider, PrivyEvmWalletConfig } from "./privyEvmWalletProvider";
+import { PrivySvmWalletProvider, PrivySvmWalletConfig } from "./privySvmWalletProvider";
+export type PrivyWalletConfig = PrivyEvmWalletConfig | PrivySvmWalletConfig;
 /**
- * Configuration options for the Privy wallet provider.
- *
- * @interface
+ * Factory class for creating chain-specific Privy wallet providers
  */
-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 chain ID to connect to */
-    chainId?: string;
-    /** Optional authorization key for the wallet API */
-    authorizationPrivateKey?: string;
-    /** Optional authorization key ID for creating new wallets */
-    authorizationKeyId?: string;
-}
-type PrivyWalletExport = {
-    walletId: string;
-    authorizationPrivateKey: string | undefined;
-    chainId: string | undefined;
-};
-/**
- * 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 PrivyWalletProvider 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();
+export declare class PrivyWalletProvider {
     /**
-     * Creates and configures a new PrivyWalletProvider instance.
+     * Creates and configures a new wallet provider instance based on the chain type.
      *
      * @param config - The configuration options for the Privy wallet
-     * @returns A configured PrivyWalletProvider instance
+     * @returns A configured WalletProvider instance for the specified chain
      *
      * @example
      * ```typescript
-     * const provider = await PrivyWalletProvider.configureWithWallet({
+     * // For EVM (default)
+     * const evmWallet = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret"
+     * });
+     *
+     * // For Solana
+     * const solanaWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret",
-     *   walletId: "wallet-id",
-     *   chainId: "84532"
+     *   chainType: "solana"
      * });
      * ```
      */
-    static configureWithWallet(config: PrivyWalletConfig): Promise<PrivyWalletProvider>;
-    /**
-     * 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;
+    static configureWithWallet<T extends PrivyWalletConfig>(config: T & {
+        chainType?: "ethereum" | "solana";
+    }): Promise<T extends {
+        chainType: "solana";
+    } ? PrivySvmWalletProvider : PrivyEvmWalletProvider>;
 }
-export {};

package/dist/wallet-providers/privyWalletProvider.js

@@ -1,139 +1,39 @@
 "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 _PrivyWalletProvider_walletId, _PrivyWalletProvider_authorizationPrivateKey;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrivyWalletProvider = 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");
+const privyEvmWalletProvider_1 = require("./privyEvmWalletProvider");
+const privySvmWalletProvider_1 = require("./privySvmWalletProvider");
 /**
- * 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.
+ * Factory class for creating chain-specific Privy wallet providers
  */
-class PrivyWalletProvider extends viemWalletProvider_1.ViemWalletProvider {
+class PrivyWalletProvider {
     /**
-     * Private constructor to enforce use of factory method.
+     * Creates and configures a new wallet provider instance based on the chain type.
      *
-     * @param walletClient - The Viem wallet client instance
      * @param config - The configuration options for the Privy wallet
-     */
-    constructor(walletClient, config) {
-        super(walletClient);
-        _PrivyWalletProvider_walletId.set(this, void 0);
-        _PrivyWalletProvider_authorizationPrivateKey.set(this, void 0);
-        __classPrivateFieldSet(this, _PrivyWalletProvider_walletId, config.walletId, "f"); // Now guaranteed to exist
-        __classPrivateFieldSet(this, _PrivyWalletProvider_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
+     * @returns A configured WalletProvider instance for the specified chain
      *
      * @example
      * ```typescript
-     * const provider = await PrivyWalletProvider.configureWithWallet({
+     * // For EVM (default)
+     * const evmWallet = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret"
+     * });
+     *
+     * // For Solana
+     * const solanaWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret",
-     *   walletId: "wallet-id",
-     *   chainId: "84532"
+     *   chainType: "solana"
      * });
      * ```
      */
     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;
+        if (config.chainType === "solana") {
+            return (await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(config));
         }
-        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 PrivyWalletProvider(walletClient, { ...config, walletId });
-    }
-    /**
-     * Gets the name of the wallet provider.
-     *
-     * @returns The string identifier for this wallet provider
-     */
-    getName() {
-        return "privy_wallet_provider";
-    }
-    /**
-     * Exports the wallet data.
-     *
-     * @returns The wallet data
-     */
-    exportWallet() {
-        return {
-            walletId: __classPrivateFieldGet(this, _PrivyWalletProvider_walletId, "f"),
-            authorizationPrivateKey: __classPrivateFieldGet(this, _PrivyWalletProvider_authorizationPrivateKey, "f"),
-            chainId: this.getNetwork().chainId,
-        };
+        return (await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(config));
     }
 }
 exports.PrivyWalletProvider = PrivyWalletProvider;
-_PrivyWalletProvider_walletId = new WeakMap(), _PrivyWalletProvider_authorizationPrivateKey = new WeakMap();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",