@coinbase/agentkit 0.6.0 → 0.6.2

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.test.js

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vaultsfyiActionProvider_1 = require("./vaultsfyiActionProvider");
+const constants_1 = require("./constants");
+const mockFetchResult = (status, data) => {
+    return {
+        json: async () => data,
+        status,
+        ok: status >= 200 && status < 300,
+    };
+};
+const mockVault = (num) => ({
+    apiResult: {
+        address: `0x${num.toString(16).padStart(40, "0")}`,
+        network: `network-${num}`,
+        name: `vault-${num}`,
+        protocol: `protocol-${num}`,
+        token: {
+            name: `token-${num}`,
+            assetAddress: `0x${num.toString(16).padStart(40, "0")}`,
+            symbol: `T${num}`,
+            decimals: 18,
+        },
+        tvlDetails: {
+            tvlUsd: num.toString(),
+        },
+        apy: {
+            base: {
+                "7day": num * 100,
+            },
+            rewards: {
+                "7day": num * 100,
+            },
+            total: {
+                "7day": num * 100,
+            },
+        },
+        isTransactional: true,
+    },
+    transformedResult: {
+        name: `vault-${num}`,
+        address: `0x${num.toString(16).padStart(40, "0")}`,
+        network: `network-${num}`,
+        protocol: `protocol-${num}`,
+        tvlInUsd: num,
+        token: {
+            name: `token-${num}`,
+            address: `0x${num.toString(16).padStart(40, "0")}`,
+            symbol: `T${num}`,
+        },
+        apy: {
+            base: num,
+            rewards: num,
+            total: num,
+        },
+        link: `https://app.vaults.fyi/opportunity/network-${num}/0x${num.toString(16).padStart(40, "0")}`,
+    },
+});
+const MOCK_TX_HASH = "0xmock-hash";
+describe("VaultsfyiActionProvider", () => {
+    const provider = new vaultsfyiActionProvider_1.VaultsfyiActionProvider({ apiKey: "test-api-key" });
+    let mockWalletProvider;
+    let mockedFetch;
+    const originalFetch = global.fetch;
+    beforeAll(() => {
+        global.fetch = mockedFetch = jest.fn();
+    });
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn(),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "test-network",
+            }),
+            nativeTransfer: jest.fn(),
+            readContract: jest.fn(() => Promise.resolve(18)), // token decimals
+            sendTransaction: jest.fn(() => Promise.resolve(MOCK_TX_HASH)),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    describe("network support", () => {
+        it("should support all vaultsfyi networks", () => {
+            Object.keys(constants_1.VAULTSFYI_SUPPORTED_CHAINS).forEach(network => {
+                expect(provider.supportsNetwork({
+                    protocolFamily: "evm",
+                    chainId: network,
+                })).toBe(true);
+            });
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                chainId: "some-other-chain",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("vaults action", () => {
+        it("should return a transformed vault", async () => {
+            const mockedVault = mockVault(1);
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: [mockedVault.apiResult] }));
+            const args = {};
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 1,
+                nextPage: false,
+                results: [mockedVault.transformedResult],
+            });
+        });
+        it("should filter by protocol", async () => {
+            const mockedVaults = [mockVault(1), mockVault(2)];
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+            const args = { protocol: "protocol-1" };
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 1,
+                nextPage: false,
+                results: [mockedVaults[0].transformedResult],
+            });
+        });
+        it("should take a limit", async () => {
+            const mockedVaults = [mockVault(1), mockVault(2)];
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+            const args = { take: 1 };
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 2,
+                nextPage: true,
+                results: [mockedVaults[0].transformedResult],
+            });
+        });
+        describe("sorting", () => {
+            it("should sort by TVL", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = { sort: { field: "tvl", direction: "asc" } };
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+            it("should sort by APY", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = { sort: { field: "apy", direction: "asc" } };
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+            it("should sort by name by default", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = {};
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {};
+            expect(await provider.vaults(mockWalletProvider, args)).toBe("Failed to fetch vaults: Internal Server Error, some more info");
+        });
+    });
+    describe("deposit action", () => {
+        it("should execute deposit", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.deposit(mockWalletProvider, args);
+            expect(response).toBe("Deposit successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should execute multiple transactions", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                    {
+                        tx: {
+                            to: "0x789",
+                            data: "0xabc",
+                            value: "2",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.deposit(mockWalletProvider, args);
+            expect(response).toBe("Deposit successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x789",
+                data: "0xabc",
+                value: 2n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.deposit(mockWalletProvider, args)).toBe("Failed to fetch deposit transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("redeem action", () => {
+        it("should execute redeem", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Redeem from vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.redeem(mockWalletProvider, args);
+            expect(response).toBe("Redeem successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.redeem(mockWalletProvider, args)).toBe("Failed to fetch redeem transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("claim rewards action", () => {
+        it("should execute claim rewards", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Claim rewards from vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.claim(mockWalletProvider, args);
+            expect(response).toBe("Claim successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.claim(mockWalletProvider, args)).toBe("Failed to fetch claim transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("wallet balances action", () => {
+        it("should strip and transform balances correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                mainnet: [
+                    {
+                        address: "0x123",
+                        name: "token-1",
+                        symbol: "T1",
+                        balance: (10 ** 18).toString(),
+                        decimals: 18,
+                        somethingElse: "should be stripped",
+                    },
+                ],
+            }));
+            const response = await provider.balances(mockWalletProvider);
+            expect(JSON.parse(response)).toStrictEqual({
+                mainnet: [
+                    {
+                        address: "0x123",
+                        name: "token-1",
+                        symbol: "T1",
+                        balance: 1,
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            expect(await provider.balances(mockWalletProvider)).toBe("Failed to fetch wallet balances: Internal Server Error, some more info");
+        });
+    });
+    describe("wallet positions action", () => {
+        it("should strip and transform positions correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                mainnet: [
+                    {
+                        vaultName: "vault-1",
+                        vaultAddress: "0x123",
+                        asset: {
+                            assetAddress: "0x456",
+                            name: "token-1",
+                            symbol: "T1",
+                            decimals: 18,
+                        },
+                        balanceNative: (10 ** 18).toString(),
+                        balanceLp: (10 ** 18).toString(),
+                        unclaimedUsd: "100",
+                        apy: {
+                            base: 100,
+                            rewards: 100,
+                            total: 100,
+                        },
+                    },
+                ],
+            }));
+            const response = await provider.positions(mockWalletProvider);
+            expect(JSON.parse(response)).toStrictEqual({
+                mainnet: [
+                    {
+                        name: "vault-1",
+                        vaultAddress: "0x123",
+                        asset: {
+                            address: "0x456",
+                            name: "token-1",
+                            symbol: "T1",
+                        },
+                        underlyingTokenBalance: 1,
+                        lpTokenBalance: 1,
+                        unclaimedRewards: true,
+                        apy: {
+                            base: 1,
+                            rewards: 1,
+                            total: 1,
+                        },
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: Internal Server Error, some more info");
+        });
+    });
+});

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

@@ -12,6 +12,8 @@ export interface PrivyEvmDelegatedEmbeddedWalletConfig extends PrivyWalletConfig
     networkId?: string;
     /** The chain ID to connect to */
     chainId?: string;
+    /** The wallet type to use */
+    walletType: "embedded";
 }
 /**
  * A wallet provider that uses Privy's embedded wallets with delegation.

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

@@ -123,6 +123,7 @@ describe("PrivyEvmDelegatedEmbeddedWalletProvider", () => {
         authorizationPrivateKey: "wallet-auth:test-auth-key",
         walletId: MOCK_WALLET_ID,
         networkId: "base-sepolia",
+        walletType: "embedded",
     };
     beforeEach(() => {
         jest.clearAllMocks();

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

@@ -15,10 +15,6 @@ export interface PrivyWalletConfig {
     authorizationPrivateKey?: string;
     /** Optional authorization key ID for creating new wallets */
     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;
@@ -45,5 +41,7 @@ export declare const createPrivyClient: (config: PrivyWalletConfig) => PrivyClie
  * @param config - The configuration options for the Privy wallet
  * @returns The created Privy wallet
  */
-export declare function createPrivyWallet(config: PrivyWalletConfig): Promise<CreatePrivyWalletReturnType>;
+export declare function createPrivyWallet(config: PrivyWalletConfig & {
+    chainType: "ethereum" | "solana";
+}): Promise<CreatePrivyWalletReturnType>;
 export {};

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

@@ -10,6 +10,8 @@ export interface PrivySvmWalletConfig extends PrivyWalletConfig {
     networkId?: string;
     /** The connection to use for the wallet */
     connection?: Connection;
+    /** The wallet type to use */
+    walletType: "server";
 }
 /**
  * A wallet provider that uses Privy's server wallet API.

package/dist/wallet-providers/privySvmWalletProvider.js

@@ -59,7 +59,10 @@ class PrivySvmWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
      * ```
      */
     static async configureWithWallet(config) {
-        const { wallet, privy } = await (0, privyShared_1.createPrivyWallet)(config);
+        const { wallet, privy } = await (0, privyShared_1.createPrivyWallet)({
+            ...config,
+            chainType: "solana",
+        });
         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({

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

@@ -148,6 +148,7 @@ describe("PrivySvmWalletProvider", () => {
     const MOCK_CONFIG = {
         appId: "test-app-id",
         appSecret: "test-app-secret",
+        walletType: "server",
     };
     const MOCK_CONFIG_WITH_WALLET_ID = {
         ...MOCK_CONFIG,

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

@@ -1,7 +1,10 @@
 import { PrivyEvmWalletProvider, PrivyEvmWalletConfig } from "./privyEvmWalletProvider";
 import { PrivySvmWalletProvider, PrivySvmWalletConfig } from "./privySvmWalletProvider";
 import { PrivyEvmDelegatedEmbeddedWalletProvider, PrivyEvmDelegatedEmbeddedWalletConfig } from "./privyEvmDelegatedEmbeddedWalletProvider";
-export type PrivyWalletConfig = PrivyEvmWalletConfig | PrivySvmWalletConfig | PrivyEvmDelegatedEmbeddedWalletConfig;
+type PrivyWalletConfig = (PrivyEvmWalletConfig | PrivySvmWalletConfig | PrivyEvmDelegatedEmbeddedWalletConfig) & {
+    chainType?: "ethereum" | "solana";
+    walletType?: "server" | "embedded";
+};
 export type PrivyWalletProviderVariant<T> = T extends {
     walletType: "embedded";
 } ? PrivyEvmDelegatedEmbeddedWalletProvider : T extends {
@@ -41,8 +44,6 @@ export declare class PrivyWalletProvider {
      * });
      * ```
      */
-    static configureWithWallet<T extends PrivyWalletConfig>(config: T & {
-        chainType?: "ethereum" | "solana";
-        walletType?: "server" | "embedded";
-    }): Promise<PrivyWalletProviderVariant<T>>;
+    static configureWithWallet<T extends PrivyWalletConfig>(config: T): Promise<PrivyWalletProviderVariant<T>>;
 }
+export {};

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const privyWalletProvider_1 = require("./privyWalletProvider");
 const privyEvmWalletProvider_1 = require("./privyEvmWalletProvider");
 const privySvmWalletProvider_1 = require("./privySvmWalletProvider");
+const privyEvmDelegatedEmbeddedWalletProvider_1 = require("./privyEvmDelegatedEmbeddedWalletProvider");
 global.fetch = jest.fn(() => Promise.resolve({
     ok: true,
     json: () => Promise.resolve({}),
@@ -34,6 +35,18 @@ jest.mock("./privySvmWalletProvider", () => ({
         }),
     },
 }));
+jest.mock("./privyEvmDelegatedEmbeddedWalletProvider", () => ({
+    PrivyEvmDelegatedEmbeddedWalletProvider: {
+        configureWithWallet: jest.fn().mockResolvedValue({
+            getAddress: jest.fn().mockReturnValue("0x324335Cc6634C0532925a3b844Bc454e4438d22g"),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                chainId: "1",
+                networkId: "mainnet",
+            }),
+        }),
+    },
+}));
 describe("PrivyWalletProvider", () => {
     const MOCK_EVM_CONFIG = {
         appId: "test-app-id",
@@ -44,6 +57,12 @@ describe("PrivyWalletProvider", () => {
         appSecret: "test-app-secret",
         chainType: "solana",
     };
+    const MOCK_EVM_EMBEDDED_WALLET_CONFIG = {
+        ...MOCK_EVM_CONFIG,
+        authorizationPrivateKey: "test-auth-key",
+        walletId: "test-wallet-id",
+        walletType: "embedded",
+    };
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -51,6 +70,7 @@ describe("PrivyWalletProvider", () => {
         const provider = await privyWalletProvider_1.PrivyWalletProvider.configureWithWallet(MOCK_EVM_CONFIG);
         expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet).toHaveBeenCalledWith(MOCK_EVM_CONFIG);
         expect(privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet).not.toHaveBeenCalled();
+        expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet).not.toHaveBeenCalled();
         expect(provider.getAddress()).toBe("0x742d35Cc6634C0532925a3b844Bc454e4438f44e");
         expect(provider.getNetwork().protocolFamily).toBe("evm");
     });
@@ -62,6 +82,7 @@ describe("PrivyWalletProvider", () => {
         const provider = await privyWalletProvider_1.PrivyWalletProvider.configureWithWallet(config);
         expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet).toHaveBeenCalledWith(config);
         expect(privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet).not.toHaveBeenCalled();
+        expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet).not.toHaveBeenCalled();
         expect(provider.getAddress()).toBe("0x742d35Cc6634C0532925a3b844Bc454e4438f44e");
         expect(provider.getNetwork().protocolFamily).toBe("evm");
     });
@@ -69,9 +90,18 @@ describe("PrivyWalletProvider", () => {
         const provider = await privyWalletProvider_1.PrivyWalletProvider.configureWithWallet(MOCK_SVM_CONFIG);
         expect(privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet).toHaveBeenCalledWith(MOCK_SVM_CONFIG);
         expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet).not.toHaveBeenCalled();
+        expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet).not.toHaveBeenCalled();
         expect(provider.getAddress()).toBe("AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM");
         expect(provider.getNetwork().protocolFamily).toBe("solana");
     });
+    it("should create an EVM embedded wallet provider when embedded is specified", async () => {
+        const provider = await privyWalletProvider_1.PrivyWalletProvider.configureWithWallet(MOCK_EVM_EMBEDDED_WALLET_CONFIG);
+        expect(privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet).toHaveBeenCalledWith(MOCK_EVM_EMBEDDED_WALLET_CONFIG);
+        expect(privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet).not.toHaveBeenCalled();
+        expect(privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet).not.toHaveBeenCalled();
+        expect(provider.getAddress()).toBe("0x324335Cc6634C0532925a3b844Bc454e4438d22g");
+        expect(provider.getNetwork().protocolFamily).toBe("evm");
+    });
     it("should pass through all config properties", async () => {
         const fullConfig = {
             ...MOCK_EVM_CONFIG,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -26,6 +26,7 @@
     "@alloralabs/allora-sdk": "^0.1.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
+    "@privy-io/public-api": "^2.18.5",
     "@privy-io/server-auth": "^1.18.4",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",