@coinbase/agentkit 0.4.0 → 0.5.0

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

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const privyEvmDelegatedEmbeddedWalletProvider_1 = require("./privyEvmDelegatedEmbeddedWalletProvider");
+global.fetch = jest.fn().mockImplementation(async (url, init) => {
+    if (!init?.headers?.["privy-authorization-signature"]) {
+        throw new Error("Missing privy-authorization-signature header");
+    }
+    if (!init?.headers?.["privy-app-id"]) {
+        throw new Error("Missing privy-app-id header");
+    }
+    const body = JSON.parse(init.body);
+    if (url.includes("wallets/rpc")) {
+        if (body.method === "personal_sign") {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ data: { signature: "0x1234" } }),
+            });
+        }
+        if (body.method === "eth_signTypedData_v4") {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ signature: "0x1234" }),
+            });
+        }
+        if (body.method === "eth_signTransaction") {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ data: { signed_transaction: "0x1234" } }),
+            });
+        }
+        if (body.method === "eth_sendTransaction") {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ data: { hash: "0xef01" } }),
+            });
+        }
+    }
+    return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({}),
+    });
+});
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_WALLET_ID = "test-wallet-id";
+const MOCK_TRANSACTION_HASH = "0xef01";
+const MOCK_SIGNATURE = "0x1234";
+jest.mock("../network", () => {
+    const chain = {
+        id: 84532,
+        name: "Base Sepolia",
+        rpcUrls: {
+            default: { http: ["https://sepolia.base.org"] },
+        },
+        nativeCurrency: {
+            name: "Ether",
+            symbol: "ETH",
+            decimals: 18,
+        },
+    };
+    return {
+        getNetwork: jest.fn().mockReturnValue({
+            protocolFamily: "evm",
+            chainId: "84532",
+            networkId: "base-sepolia",
+        }),
+        getChain: jest.fn().mockReturnValue(chain),
+        NETWORK_ID_TO_CHAIN_ID: {
+            "base-sepolia": "84532",
+        },
+    };
+});
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        createPublicClient: jest.fn().mockReturnValue({
+            getBalance: jest.fn().mockResolvedValue(BigInt(1000000000000000000)),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({
+                transactionHash: "0xef01",
+                status: "success",
+            }),
+            readContract: jest.fn().mockResolvedValue("mock_result"),
+        }),
+        parseEther: jest.fn().mockReturnValue(BigInt(1000000000000000000)),
+    };
+});
+jest.mock("./privyShared", () => ({
+    createPrivyClient: jest.fn().mockReturnValue({
+        getUser: jest.fn().mockResolvedValue({
+            linkedAccounts: [
+                {
+                    type: "wallet",
+                    walletClientType: "privy",
+                    address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+                },
+            ],
+        }),
+    }),
+}));
+jest.mock("canonicalize", () => {
+    const mockFn = jest.fn().mockImplementation((obj) => {
+        const replacer = (key, value) => {
+            if (typeof value === "bigint") {
+                return value.toString();
+            }
+            return value;
+        };
+        return JSON.stringify(obj, replacer);
+    });
+    return mockFn;
+});
+jest.mock("crypto", () => ({
+    createPrivateKey: jest.fn().mockImplementation(() => ({})),
+    sign: jest.fn().mockImplementation(() => Buffer.from("mock-signature")),
+}));
+describe("PrivyEvmDelegatedEmbeddedWalletProvider", () => {
+    const MOCK_CONFIG = {
+        appId: "test-app-id",
+        appSecret: "test-app-secret",
+        authorizationPrivateKey: "wallet-auth:test-auth-key",
+        walletId: MOCK_WALLET_ID,
+        networkId: "base-sepolia",
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("configureWithWallet", () => {
+        it("should configure with required configuration", async () => {
+            const provider = await privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(MOCK_CONFIG);
+            expect(provider).toBeInstanceOf(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider);
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "evm",
+                chainId: "84532",
+                networkId: "base-sepolia",
+            });
+        });
+        it("should throw error if walletId is missing", async () => {
+            const { walletId: _walletId, ...configWithoutWalletId } = MOCK_CONFIG;
+            await expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(configWithoutWalletId)).rejects.toThrow("walletId is required");
+        });
+        it("should throw error if appId or appSecret is missing", async () => {
+            const { appId: _appId, ...configWithoutAppId } = MOCK_CONFIG;
+            await expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(configWithoutAppId)).rejects.toThrow("appId and appSecret are required");
+        });
+        it("should throw error if authorizationPrivateKey is missing", async () => {
+            const { authorizationPrivateKey: _authKey, ...configWithoutAuthKey } = MOCK_CONFIG;
+            await expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(configWithoutAuthKey)).rejects.toThrow("authorizationPrivateKey is required");
+        });
+    });
+    describe("wallet methods", () => {
+        let provider;
+        beforeEach(async () => {
+            provider = await privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(MOCK_CONFIG);
+        });
+        it("should get the wallet address", () => {
+            expect(provider.getAddress()).toBe(MOCK_ADDRESS);
+        });
+        it("should get the network information", () => {
+            expect(provider.getNetwork()).toEqual({
+                protocolFamily: "evm",
+                chainId: "84532",
+                networkId: "base-sepolia",
+            });
+        });
+        it("should get the provider name", () => {
+            expect(provider.getName()).toBe("privy_evm_embedded_wallet_provider");
+        });
+        it("should get the wallet balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(BigInt(1000000000000000000));
+        });
+        it("should sign a message", async () => {
+            const result = await provider.signMessage("Hello, world!");
+            expect(result).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign typed data", async () => {
+            const typedData = {
+                domain: { name: "Test" },
+                types: { Test: [{ name: "test", type: "string" }] },
+                primaryType: "Test",
+                message: { test: "test" },
+            };
+            const result = await provider.signTypedData(typedData);
+            expect(result).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign a transaction", async () => {
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            const result = await provider.signTransaction(transaction);
+            expect(result).toBe(MOCK_SIGNATURE);
+        });
+        it("should send a transaction", async () => {
+            const transaction = {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(1000000000000000000),
+            };
+            const result = await provider.sendTransaction(transaction);
+            expect(result).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should wait for transaction receipt", async () => {
+            const receipt = await provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH);
+            expect(receipt).toEqual({
+                transactionHash: MOCK_TRANSACTION_HASH,
+                status: "success",
+            });
+        });
+        it("should transfer native tokens", async () => {
+            const result = await provider.nativeTransfer("0x1234567890123456789012345678901234567890", "1.0");
+            expect(result).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should export wallet data", () => {
+            const exportData = provider.exportWallet();
+            expect(exportData).toEqual({
+                walletId: MOCK_WALLET_ID,
+                authorizationPrivateKey: MOCK_CONFIG.authorizationPrivateKey,
+                networkId: "base-sepolia",
+                chainId: "84532",
+            });
+        });
+        it("should read contract data", async () => {
+            const abi = [
+                {
+                    name: "balanceOf",
+                    type: "function",
+                    inputs: [{ name: "account", type: "address" }],
+                    outputs: [{ name: "balance", type: "uint256" }],
+                    stateMutability: "view",
+                },
+            ];
+            const result = await provider.readContract({
+                address: "0x1234567890123456789012345678901234567890",
+                abi,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            });
+            expect(result).toBe("mock_result");
+        });
+        describe("request signing", () => {
+            it("should include required headers in requests", async () => {
+                const transaction = {
+                    to: "0x1234567890123456789012345678901234567890",
+                    value: BigInt(1000000000000000000),
+                };
+                await provider.sendTransaction(transaction);
+                expect(global.fetch).toHaveBeenCalled();
+                const lastCall = global.fetch.mock.calls[global.fetch.mock.calls.length - 1];
+                const [_url, init] = lastCall;
+                expect(init.headers).toBeDefined();
+                expect(init.headers["privy-authorization-signature"]).toBeDefined();
+                expect(init.headers["privy-app-id"]).toBe("test-app-id");
+                expect(init.headers["Authorization"]).toBeDefined();
+            });
+            it("should handle signature generation errors", async () => {
+                const canonicalize = jest.requireMock("canonicalize");
+                canonicalize.mockImplementationOnce(() => null); // Force canonicalization failure
+                const transaction = {
+                    to: "0x1234567890123456789012345678901234567890",
+                    value: BigInt(1000000000000000000),
+                };
+                await expect(provider.sendTransaction(transaction)).rejects.toThrow("Error generating Privy authorization signature");
+            });
+            it("should handle HTTP errors", async () => {
+                global.fetch.mockImplementationOnce(() => Promise.resolve({
+                    ok: false,
+                    status: 400,
+                }));
+                const transaction = {
+                    to: "0x1234567890123456789012345678901234567890",
+                    value: BigInt(1000000000000000000),
+                };
+                await expect(provider.sendTransaction(transaction)).rejects.toThrow("Privy request failed: HTTP error! status: 400");
+            });
+        });
+    });
+});

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

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

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

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

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

@@ -17,6 +17,8 @@ export interface PrivyWalletConfig {
     authorizationKeyId?: string;
     /** The chain type to create the wallet on */
     chainType?: "ethereum" | "solana";
+    /** The type of wallet to use */
+    walletType?: "server" | "embedded";
 }
 export type PrivyWalletExport = {
     walletId: string;
@@ -30,6 +32,13 @@ type CreatePrivyWalletReturnType = {
     };
     privy: PrivyClient;
 };
+/**
+ * Create a Privy client
+ *
+ * @param config - The configuration options for the Privy client
+ * @returns The created Privy client
+ */
+export declare const createPrivyClient: (config: PrivyWalletConfig) => PrivyClient;
 /**
  * Create a Privy wallet
  *

package/dist/wallet-providers/privyShared.js

@@ -1,21 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrivyClient = void 0;
 exports.createPrivyWallet = createPrivyWallet;
 const server_auth_1 = require("@privy-io/server-auth");
 /**
- * Create a Privy wallet
+ * Create a Privy client
  *
- * @param config - The configuration options for the Privy wallet
- * @returns The created Privy wallet
+ * @param config - The configuration options for the Privy client
+ * @returns The created Privy client
  */
-async function createPrivyWallet(config) {
-    const privy = new server_auth_1.PrivyClient(config.appId, config.appSecret, {
+const createPrivyClient = (config) => {
+    return new server_auth_1.PrivyClient(config.appId, config.appSecret, {
         walletApi: config.authorizationPrivateKey
             ? {
                 authorizationPrivateKey: config.authorizationPrivateKey,
             }
             : undefined,
     });
+};
+exports.createPrivyClient = createPrivyClient;
+/**
+ * Create a Privy wallet
+ *
+ * @param config - The configuration options for the Privy wallet
+ * @returns The created Privy wallet
+ */
+async function createPrivyWallet(config) {
+    const privy = (0, exports.createPrivyClient)(config);
     if (config.walletId) {
         const wallet = await privy.walletApi.getWallet({ id: config.walletId });
         if (!wallet) {

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

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