@coinbase/agentkit 0.0.0-nightly-20250328174338

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/privySvmWalletProvider.test.d.ts

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

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

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const privySvmWalletProvider_1 = require("./privySvmWalletProvider");
+const web3_js_1 = require("@solana/web3.js");
+const solanaNetworks = __importStar(require("../network/svm"));
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+jest.mock("@privy-io/server-auth", () => ({
+    PrivyClient: jest.fn().mockImplementation(() => ({
+        walletApi: {
+            getWallet: jest.fn().mockResolvedValue({
+                id: "test-wallet-id",
+                address: "AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM",
+            }),
+            create: jest.fn().mockResolvedValue({
+                id: "test-wallet-id",
+                address: "AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM",
+            }),
+            solana: {
+                signTransaction: jest.fn().mockResolvedValue({
+                    signedTransaction: "mock-signed-transaction",
+                }),
+                signAndSendTransaction: jest.fn().mockResolvedValue({
+                    hash: "mock-hash",
+                }),
+            },
+        },
+    })),
+}));
+jest.mock("@solana/web3.js", () => {
+    const actual = jest.requireActual("@solana/web3.js");
+    return {
+        ...actual,
+        Connection: jest.fn().mockImplementation(() => ({
+            getGenesisHash: jest.fn().mockResolvedValue(solanaNetworks.SOLANA_DEVNET_GENESIS_BLOCK_HASH),
+            getBalance: jest.fn().mockResolvedValue(1000000000),
+            getSignatureStatus: jest.fn().mockResolvedValue({
+                context: { slot: 123 },
+                value: { slot: 123, confirmations: 10, err: null },
+            }),
+            confirmTransaction: jest.fn().mockResolvedValue({
+                context: { slot: 123 },
+                value: { err: null },
+            }),
+        })),
+        PublicKey: jest.fn().mockImplementation(address => ({
+            toBase58: jest.fn().mockReturnValue(address),
+        })),
+        VersionedTransaction: jest.fn().mockImplementation(() => ({
+            signatures: [],
+            message: { compiledMessage: Buffer.from([]) },
+        })),
+        clusterApiUrl: jest.fn().mockImplementation(network => `https://api.${network}.solana.com`),
+    };
+});
+jest.mock("./privyShared", () => ({
+    createPrivyWallet: jest.fn().mockResolvedValue({
+        wallet: {
+            id: "test-wallet-id",
+            address: "AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM",
+        },
+        privy: {
+            walletApi: {
+                solana: {
+                    signTransaction: jest.fn().mockResolvedValue({
+                        signedTransaction: "mock-signed-transaction",
+                    }),
+                    signAndSendTransaction: jest.fn().mockResolvedValue({
+                        hash: "mock-hash",
+                    }),
+                },
+            },
+        },
+    }),
+}));
+jest.mock("../network/svm", () => {
+    const SOLANA_DEVNET_GENESIS_BLOCK_HASH = "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+    const SOLANA_TESTNET_GENESIS_BLOCK_HASH = "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY";
+    const SOLANA_MAINNET_GENESIS_BLOCK_HASH = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
+    return {
+        SOLANA_DEVNET_GENESIS_BLOCK_HASH,
+        SOLANA_TESTNET_GENESIS_BLOCK_HASH,
+        SOLANA_MAINNET_GENESIS_BLOCK_HASH,
+        SOLANA_CLUSTER_ID_BY_NETWORK_ID: {
+            devnet: "devnet",
+            testnet: "testnet",
+            "mainnet-beta": "mainnet-beta",
+        },
+        SOLANA_NETWORKS: {
+            [SOLANA_DEVNET_GENESIS_BLOCK_HASH]: {
+                protocolFamily: "solana",
+                chainId: "devnet",
+                networkId: "devnet",
+            },
+            [SOLANA_TESTNET_GENESIS_BLOCK_HASH]: {
+                protocolFamily: "solana",
+                chainId: "testnet",
+                networkId: "testnet",
+            },
+            [SOLANA_MAINNET_GENESIS_BLOCK_HASH]: {
+                protocolFamily: "solana",
+                chainId: "mainnet-beta",
+                networkId: "mainnet-beta",
+            },
+        },
+    };
+});
+describe("PrivySvmWalletProvider", () => {
+    const MOCK_ADDRESS = "AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM";
+    const MOCK_CONFIG = {
+        appId: "test-app-id",
+        appSecret: "test-app-secret",
+    };
+    const MOCK_CONFIG_WITH_WALLET_ID = {
+        ...MOCK_CONFIG,
+        walletId: "test-wallet-id",
+    };
+    const MOCK_CONFIG_WITH_NETWORK_ID = {
+        ...MOCK_CONFIG,
+        networkId: "devnet",
+    };
+    const MOCK_CONFIG_WITH_AUTH_KEY = {
+        ...MOCK_CONFIG,
+        authorizationPrivateKey: "test-auth-key",
+        authorizationKeyId: "test-auth-key-id",
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("configureWithWallet", () => {
+        it("should configure with default settings", async () => {
+            const provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(MOCK_CONFIG);
+            expect(provider).toBeInstanceOf(privySvmWalletProvider_1.PrivySvmWalletProvider);
+        });
+        it("should configure with an existing wallet ID", async () => {
+            const provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(MOCK_CONFIG_WITH_WALLET_ID);
+            expect(provider).toBeInstanceOf(privySvmWalletProvider_1.PrivySvmWalletProvider);
+        });
+        it("should configure with a specified network ID", async () => {
+            const provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(MOCK_CONFIG_WITH_NETWORK_ID);
+            expect(provider).toBeInstanceOf(privySvmWalletProvider_1.PrivySvmWalletProvider);
+        });
+        it("should configure with authorization keys", async () => {
+            const provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(MOCK_CONFIG_WITH_AUTH_KEY);
+            expect(provider).toBeInstanceOf(privySvmWalletProvider_1.PrivySvmWalletProvider);
+        });
+        it("should configure with a custom connection", async () => {
+            const connection = new web3_js_1.Connection("https://custom-rpc.example.com");
+            const provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet({
+                ...MOCK_CONFIG,
+                connection,
+            });
+            expect(provider).toBeInstanceOf(privySvmWalletProvider_1.PrivySvmWalletProvider);
+        });
+        it("should handle configuration with invalid network", async () => {
+            const mockClusterApiUrl = jest.fn().mockImplementation(() => {
+                throw new Error("Invalid cluster");
+            });
+            const webThreeJs = jest.requireMock("@solana/web3.js");
+            const originalFn = webThreeJs.clusterApiUrl;
+            webThreeJs.clusterApiUrl = mockClusterApiUrl;
+            await expect(privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet({
+                ...MOCK_CONFIG,
+                networkId: "this-network-definitely-does-not-exist",
+            })).rejects.toThrow();
+            webThreeJs.clusterApiUrl = originalFn;
+        });
+    });
+    describe("wallet methods", () => {
+        let provider;
+        let mockTransaction;
+        beforeEach(async () => {
+            provider = await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(MOCK_CONFIG);
+            mockTransaction = {
+                message: { compiledMessage: Buffer.from([]) },
+                signatures: [],
+            };
+        });
+        it("should get the wallet address", () => {
+            expect(provider.getAddress()).toBe(MOCK_ADDRESS);
+        });
+        it("should get the network information", () => {
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "solana",
+                chainId: "devnet",
+                networkId: "devnet",
+            });
+        });
+        it("should get the provider name", () => {
+            expect(provider.getName()).toBe("privy_svm_wallet_provider");
+        });
+        it("should get the wallet balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(BigInt(1000000000));
+        });
+        it("should sign a transaction", async () => {
+            const signedTx = await provider.signTransaction(mockTransaction);
+            expect(signedTx).toBe("mock-signed-transaction");
+        });
+        it("should sign and send a transaction", async () => {
+            const hash = await provider.signAndSendTransaction(mockTransaction);
+            expect(hash).toBe("mock-hash");
+        });
+        it("should throw an error when sending a transaction directly", async () => {
+            await expect(provider.sendTransaction(mockTransaction)).rejects.toThrow("Method not implemented");
+        });
+        it("should throw an error when transferring native tokens", async () => {
+            await expect(provider.nativeTransfer("destination-address", "1.0")).rejects.toThrow("Method not implemented");
+        });
+        it("should get the signature status", async () => {
+            const status = await provider.getSignatureStatus("mock-signature");
+            expect(status).toEqual({
+                context: { slot: 123 },
+                value: { slot: 123, confirmations: 10, err: null },
+            });
+        });
+        it("should wait for signature result", async () => {
+            const result = await provider.waitForSignatureResult("mock-signature");
+            expect(result).toEqual({
+                context: { slot: 123 },
+                value: { err: null },
+            });
+        });
+        it("should get the connection", () => {
+            const connection = provider.getConnection();
+            expect(connection).toBeDefined();
+        });
+        it("should get the public key", () => {
+            const publicKey = provider.getPublicKey();
+            expect(publicKey.toBase58()).toBe(MOCK_ADDRESS);
+        });
+        it("should export wallet data", () => {
+            const walletData = provider.exportWallet();
+            expect(walletData).toEqual({
+                walletId: "test-wallet-id",
+                authorizationPrivateKey: undefined,
+                chainId: "devnet",
+                networkId: "devnet",
+            });
+        });
+        it("should handle errors when signing transaction", async () => {
+            jest.spyOn(provider, "signTransaction").mockRejectedValueOnce(new Error("Signing failed"));
+            const mockTransaction = {
+                message: { compiledMessage: Buffer.from([]) },
+                signatures: [],
+            };
+            await expect(provider.signTransaction(mockTransaction)).rejects.toThrow("Signing failed");
+        });
+        it("should handle errors when signing and sending transaction", async () => {
+            jest
+                .spyOn(provider, "signAndSendTransaction")
+                .mockRejectedValueOnce(new Error("Failed to send transaction"));
+            const mockTransaction = {
+                message: { compiledMessage: Buffer.from([]) },
+                signatures: [],
+            };
+            await expect(provider.signAndSendTransaction(mockTransaction)).rejects.toThrow("Failed to send transaction");
+        });
+        it("should handle timeout during transaction signature status check", async () => {
+            const mockMethod = jest.fn().mockRejectedValueOnce(new Error("Request timed out"));
+            const connection = provider.getConnection();
+            connection.getSignatureStatus = mockMethod;
+            await expect(provider.getSignatureStatus("mock-signature")).rejects.toThrow("Request timed out");
+        });
+        it("should handle network errors during balance check", async () => {
+            const mockMethod = jest.fn().mockRejectedValueOnce(new Error("RPC endpoint error"));
+            const connection = provider.getConnection();
+            connection.getBalance = mockMethod;
+            await expect(provider.getBalance()).rejects.toThrow("RPC endpoint error");
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { PrivyEvmWalletProvider, PrivyEvmWalletConfig } from "./privyEvmWalletProvider";
+import { PrivySvmWalletProvider, PrivySvmWalletConfig } from "./privySvmWalletProvider";
+export type PrivyWalletConfig = PrivyEvmWalletConfig | PrivySvmWalletConfig;
+/**
+ * Factory class for creating chain-specific Privy wallet providers
+ */
+export declare class PrivyWalletProvider {
+    /**
+     * 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 WalletProvider instance for the specified chain
+     *
+     * @example
+     * ```typescript
+     * // 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",
+     *   chainType: "solana"
+     * });
+     * ```
+     */
+    static configureWithWallet<T extends PrivyWalletConfig>(config: T & {
+        chainType?: "ethereum" | "solana";
+    }): Promise<T extends {
+        chainType: "solana";
+    } ? PrivySvmWalletProvider : PrivyEvmWalletProvider>;
+}

package/dist/wallet-providers/privyWalletProvider.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivyWalletProvider = void 0;
+const privyEvmWalletProvider_1 = require("./privyEvmWalletProvider");
+const privySvmWalletProvider_1 = require("./privySvmWalletProvider");
+/**
+ * Factory class for creating chain-specific Privy wallet providers
+ */
+class PrivyWalletProvider {
+    /**
+     * 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 WalletProvider instance for the specified chain
+     *
+     * @example
+     * ```typescript
+     * // 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",
+     *   chainType: "solana"
+     * });
+     * ```
+     */
+    static async configureWithWallet(config) {
+        if (config.chainType === "solana") {
+            return (await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(config));
+        }
+        return (await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(config));
+    }
+}
+exports.PrivyWalletProvider = PrivyWalletProvider;

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

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