@coinbase/agentkit 0.0.0-nightly-20250328174338 → 0.0.0-nightly-20250328210410

package/README.md

@@ -646,24 +646,61 @@ const walletProvider = new ViemWalletProvider(client, {
 
 ### PrivyWalletProvider
 
-The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/). This implementation extends the `ViemWalletProvider`.
+The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/) or [Privy Embedded Wallets](https://docs.privy.io/guide/embedded-wallets/). This implementation extends the `EvmWalletProvider`.
+
+#### Server Wallet Configuration
 
 ```typescript
-import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
+import { PrivyWalletProvider } from "@coinbase/agentkit";
 
-// Configure Wallet Provider
-const config: PrivyWalletConfig = {
+// Configure Server Wallet Provider
+const config = {
     appId: "PRIVY_APP_ID",
     appSecret: "PRIVY_APP_SECRET",
     chainId: "84532", // base-sepolia
     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
+    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);
 ```
 
+#### Delegated Embedded Wallet Configuration
+
+You can also use Privy's embedded wallets with delegation for agent actions. This allows your agent to use wallets that have been delegated transaction signing authority by users.
+
+```typescript
+import { PrivyWalletProvider } from "@coinbase/agentkit";
+
+// Configure Embedded Wallet Provider
+const config = {
+    appId: "PRIVY_APP_ID",
+    appSecret: "PRIVY_APP_SECRET",
+    authorizationPrivateKey: "PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY",
+    walletId: "PRIVY_DELEGATED_WALLET_ID", // The ID of the wallet that was delegated to your server
+    networkId: "base-mainnet", // or any supported network
+    walletType: "embedded" // Specify "embedded" to use the embedded wallet provider
+};
+
+const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
+```
+
+### Prerequisites
+
+Before using this wallet provider, you need to:
+
+1. Set up Privy in your application
+2. Enable server delegated actions
+3. Have users delegate permissions to your server
+4. Obtain the delegated wallet ID
+
+For more information on setting up Privy and enabling delegated actions, see [Privy's documentation](https://docs.privy.io/guide/embedded/server-delegated-actions).
+
+### Supported Operations
+
+The `PrivyEvmDelegatedEmbeddedWalletProvider` supports all standard wallet operations including transaction signing, message signing, and native transfers, using the wallet that was delegated to your server.
+
 #### Authorization Keys
 
 Privy offers the option to use authorization keys to secure your server wallets.
@@ -679,12 +716,19 @@ The `PrivyWalletProvider` can export wallet information by calling the `exportWa
 ```typescript
 const walletData = await walletProvider.exportWallet();
 
-// walletData will be in the following format:
+// For server wallets, walletData will be in the following format:
 {
     walletId: string;
     authorizationKey: string | undefined;
     chainId: string | undefined;
 }
+
+// For embedded wallets, walletData will be in the following format:
+{
+    walletId: string;
+    networkId: string;
+    chainId: string | undefined;
+}
 ```
 
 ### SmartWalletProvider

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

@@ -8,3 +8,4 @@ export * from "./solanaKeypairWalletProvider";
 export * from "./privyWalletProvider";
 export * from "./privyEvmWalletProvider";
 export * from "./privySvmWalletProvider";
+export * from "./privyEvmDelegatedEmbeddedWalletProvider";

package/dist/wallet-providers/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./solanaKeypairWalletProvider"), exports);
 __exportStar(require("./privyWalletProvider"), exports);
 __exportStar(require("./privyEvmWalletProvider"), exports);
 __exportStar(require("./privySvmWalletProvider"), exports);
+__exportStar(require("./privyEvmDelegatedEmbeddedWalletProvider"), exports);

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

@@ -0,0 +1,167 @@
+import { Abi, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionReceipt, TransactionRequest } from "viem";
+import { Network } from "../network";
+import { PrivyWalletConfig, PrivyWalletExport } from "./privyShared";
+import { WalletProvider } from "./walletProvider";
+/**
+ * Configuration options for the Privy Embedded Wallet provider.
+ */
+export interface PrivyEvmDelegatedEmbeddedWalletConfig extends PrivyWalletConfig {
+    /** The ID of the delegated wallet */
+    walletId: string;
+    /** The network ID to connect to (e.g., "base-mainnet") */
+    networkId?: string;
+    /** The chain ID to connect to */
+    chainId?: string;
+}
+/**
+ * A wallet provider that uses Privy's embedded wallets with delegation.
+ * This provider extends the EvmWalletProvider to provide Privy-specific wallet functionality
+ * while maintaining compatibility with the base wallet provider interface.
+ */
+export declare class PrivyEvmDelegatedEmbeddedWalletProvider extends WalletProvider {
+    #private;
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param config - The configuration options for the wallet provider
+     */
+    private constructor();
+    /**
+     * Creates and configures a new PrivyEvmDelegatedEmbeddedWalletProvider instance.
+     *
+     * @param config - The configuration options for the Privy wallet
+     * @returns A configured PrivyEvmDelegatedEmbeddedWalletProvider instance
+     *
+     * @example
+     * ```typescript
+     * const provider = await PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   authorizationPrivateKey: "your-auth-key",
+     *   walletId: "privy-wallet-id",
+     *   networkId: "base-mainnet"
+     * });
+     * ```
+     */
+    static configureWithWallet(config: PrivyEvmDelegatedEmbeddedWalletConfig): Promise<PrivyEvmDelegatedEmbeddedWalletProvider>;
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress(): string;
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork(): Network;
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName(): string;
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    signMessage(message: string): Promise<Hex>;
+    /**
+     * Signs typed data according to EIP-712.
+     *
+     * @param typedData - The typed data object to sign
+     * @param typedData.domain - The domain object containing contract and chain information
+     * @param typedData.types - The type definitions for the structured data
+     * @param typedData.primaryType - The primary type being signed
+     * @param typedData.message - The actual data to sign
+     * @returns A Address that resolves to the signed typed data as a hex string
+     */
+    signTypedData(typedData: {
+        domain: Record<string, unknown>;
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<Hex>;
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    signTransaction(transaction: TransactionRequest): Promise<Hex>;
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    sendTransaction(transaction: TransactionRequest): Promise<Hex>;
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    waitForTransactionReceipt(txHash: Hex): Promise<TransactionReceipt>;
+    /**
+     * Reads data from a smart contract.
+     *
+     * @param params - Parameters for reading the contract
+     * @param params.address - The address of the contract
+     * @param params.abi - The ABI of the contract
+     * @param params.functionName - The name of the function to call
+     * @param params.args - The arguments to pass to the function
+     * @returns A Address that resolves to the contract function's return value
+     */
+    readContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, "pure" | "view">, const args extends ContractFunctionArgs<abi, "pure" | "view", functionName>>(params: ReadContractParameters<abi, functionName, args>): Promise<ReadContractReturnType<abi, functionName, args>>;
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in Wei.
+     * @returns The transaction hash.
+     */
+    nativeTransfer(to: string, value: string): Promise<Hex>;
+    /**
+     * Exports the wallet information.
+     *
+     * @returns The wallet data
+     */
+    exportWallet(): PrivyWalletExport;
+    /**
+     * Generate Privy authorization signature for API requests
+     *
+     * @param url - The URL for the request
+     * @param body - The request body
+     * @returns The generated signature
+     */
+    private generatePrivySignature;
+    /**
+     * Get Privy headers for API requests
+     *
+     * @param url - The URL for the request
+     * @param body - The request body
+     * @returns The headers for the request
+     */
+    private getPrivyHeaders;
+    /**
+     * Execute a Privy API request.
+     *
+     * @param body - The request body to send to the Privy API
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    private executePrivyRequest;
+}

package/dist/wallet-providers/privyEvmDelegatedEmbeddedWalletProvider.js

@@ -0,0 +1,438 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _PrivyEvmDelegatedEmbeddedWalletProvider_walletId, _PrivyEvmDelegatedEmbeddedWalletProvider_address, _PrivyEvmDelegatedEmbeddedWalletProvider_appId, _PrivyEvmDelegatedEmbeddedWalletProvider_appSecret, _PrivyEvmDelegatedEmbeddedWalletProvider_authKey, _PrivyEvmDelegatedEmbeddedWalletProvider_network, _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivyEvmDelegatedEmbeddedWalletProvider = void 0;
+const canonicalize_1 = __importDefault(require("canonicalize"));
+const crypto_1 = __importDefault(require("crypto"));
+const viem_1 = require("viem");
+const network_1 = require("../network/network");
+const privyShared_1 = require("./privyShared");
+const walletProvider_1 = require("./walletProvider");
+/**
+ * A wallet provider that uses Privy's embedded wallets with delegation.
+ * This provider extends the EvmWalletProvider to provide Privy-specific wallet functionality
+ * while maintaining compatibility with the base wallet provider interface.
+ */
+class PrivyEvmDelegatedEmbeddedWalletProvider extends walletProvider_1.WalletProvider {
+    /**
+     * Private constructor to enforce use of factory method.
+     *
+     * @param config - The configuration options for the wallet provider
+     */
+    constructor(config) {
+        super();
+        _PrivyEvmDelegatedEmbeddedWalletProvider_walletId.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_address.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_appId.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_appSecret.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_authKey.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_network.set(this, void 0);
+        _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient.set(this, void 0);
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_walletId, config.walletId, "f");
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, config.address, "f");
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appId, config.appId, "f");
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appSecret, config.appSecret, "f");
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_authKey, config.authorizationPrivateKey || "", "f");
+        const networkId = config.networkId || "base-sepolia";
+        const chainId = config.chainId || network_1.NETWORK_ID_TO_CHAIN_ID[networkId];
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, {
+            protocolFamily: "evm",
+            networkId: networkId,
+            chainId: chainId,
+        }, "f");
+        // Create a public client for read operations
+        const chain = (0, network_1.getChain)(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        __classPrivateFieldSet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient, (0, viem_1.createPublicClient)({
+            chain,
+            transport: (0, viem_1.http)(),
+        }), "f");
+    }
+    /**
+     * Creates and configures a new PrivyEvmDelegatedEmbeddedWalletProvider instance.
+     *
+     * @param config - The configuration options for the Privy wallet
+     * @returns A configured PrivyEvmDelegatedEmbeddedWalletProvider instance
+     *
+     * @example
+     * ```typescript
+     * const provider = await PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   authorizationPrivateKey: "your-auth-key",
+     *   walletId: "privy-wallet-id",
+     *   networkId: "base-mainnet"
+     * });
+     * ```
+     */
+    static async configureWithWallet(config) {
+        try {
+            if (!config.walletId) {
+                throw new Error("walletId is required for PrivyEvmDelegatedEmbeddedWalletProvider");
+            }
+            if (!config.appId || !config.appSecret) {
+                throw new Error("appId and appSecret are required for PrivyEvmDelegatedEmbeddedWalletProvider");
+            }
+            if (!config.authorizationPrivateKey) {
+                throw new Error("authorizationPrivateKey is required for PrivyEvmDelegatedEmbeddedWalletProvider");
+            }
+            const privyClient = (0, privyShared_1.createPrivyClient)(config);
+            const user = await privyClient.getUser(config.walletId);
+            const embeddedWallets = user.linkedAccounts.filter((account) => account.type === "wallet" && account.walletClientType === "privy");
+            if (embeddedWallets.length === 0) {
+                throw new Error(`Could not find wallet address for wallet ID ${config.walletId}`);
+            }
+            const walletAddress = embeddedWallets[0].address;
+            // Verify the network/chain ID if provided
+            if (config.chainId) {
+                const chain = (0, network_1.getChain)(config.chainId);
+                if (!chain) {
+                    throw new Error(`Chain with ID ${config.chainId} not found`);
+                }
+            }
+            return new PrivyEvmDelegatedEmbeddedWalletProvider({
+                ...config,
+                address: walletAddress,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to configure Privy embedded wallet provider: ${error.message}`);
+            }
+            throw new Error("Failed to configure Privy embedded wallet provider");
+        }
+    }
+    /**
+     * Gets the address of the wallet.
+     *
+     * @returns The address of the wallet.
+     */
+    getAddress() {
+        return __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f");
+    }
+    /**
+     * Gets the network of the wallet.
+     *
+     * @returns The network of the wallet.
+     */
+    getNetwork() {
+        return __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f");
+    }
+    /**
+     * Gets the name of the wallet provider.
+     *
+     * @returns The name of the wallet provider.
+     */
+    getName() {
+        return "privy_evm_embedded_wallet_provider";
+    }
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    async getBalance() {
+        try {
+            const balance = await __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient, "f").getBalance({
+                address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            });
+            return balance;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Error getting balance: ${error.message}`);
+            }
+            throw new Error("Error getting balance");
+        }
+    }
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    async signMessage(message) {
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            method: "personal_sign",
+            params: {
+                message,
+                encoding: "utf-8",
+            },
+        };
+        try {
+            const response = await this.executePrivyRequest(body);
+            return response.data?.signature;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Message signing failed: ${error.message}`);
+            }
+            throw new Error("Message signing failed");
+        }
+    }
+    /**
+     * Signs typed data according to EIP-712.
+     *
+     * @param typedData - The typed data object to sign
+     * @param typedData.domain - The domain object containing contract and chain information
+     * @param typedData.types - The type definitions for the structured data
+     * @param typedData.primaryType - The primary type being signed
+     * @param typedData.message - The actual data to sign
+     * @returns A Address that resolves to the signed typed data as a hex string
+     */
+    async signTypedData(typedData) {
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            chain_id: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f").chainId,
+            ...typedData,
+        };
+        try {
+            const response = await this.executePrivyRequest({
+                method: "eth_signTypedData_v4",
+                params: body,
+            });
+            return response.signature;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error("Typed data signing failed: " + error.message);
+            }
+            throw new Error("Typed data signing failed with unknown error");
+        }
+    }
+    /**
+     * Signs a transaction.
+     *
+     * @param transaction - The transaction to sign.
+     * @returns The signed transaction.
+     */
+    async signTransaction(transaction) {
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            method: "eth_signTransaction",
+            params: {
+                transaction: {
+                    ...transaction,
+                    from: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+                },
+            },
+        };
+        try {
+            const response = await this.executePrivyRequest(body);
+            return response.data?.signed_transaction;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Transaction signing failed: ${error.message}`);
+            }
+            throw new Error("Transaction signing failed");
+        }
+    }
+    /**
+     * Sends a transaction.
+     *
+     * @param transaction - The transaction to send.
+     * @returns The hash of the transaction.
+     */
+    async sendTransaction(transaction) {
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            method: "eth_sendTransaction",
+            caip2: `eip155:${__classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f").chainId}`,
+            params: {
+                transaction: {
+                    ...transaction,
+                    from: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+                },
+            },
+        };
+        try {
+            const response = await this.executePrivyRequest(body);
+            return response.data?.hash;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Transaction sending failed: ${error.message}`);
+            }
+            throw new Error("Transaction sending failed");
+        }
+    }
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    async waitForTransactionReceipt(txHash) {
+        return await __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient, "f").waitForTransactionReceipt({
+            hash: txHash,
+        });
+    }
+    /**
+     * Reads data from a smart contract.
+     *
+     * @param params - Parameters for reading the contract
+     * @param params.address - The address of the contract
+     * @param params.abi - The ABI of the contract
+     * @param params.functionName - The name of the function to call
+     * @param params.args - The arguments to pass to the function
+     * @returns A Address that resolves to the contract function's return value
+     */
+    async readContract(params) {
+        return __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient, "f").readContract(params);
+    }
+    /**
+     * Transfer the native asset of the network.
+     *
+     * @param to - The destination address.
+     * @param value - The amount to transfer in Wei.
+     * @returns The transaction hash.
+     */
+    async nativeTransfer(to, value) {
+        const valueInWei = (0, viem_1.parseEther)(value);
+        const valueHex = `0x${valueInWei.toString(16)}`;
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            method: "eth_sendTransaction",
+            caip2: `eip155:${__classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f").chainId}`,
+            params: {
+                transaction: {
+                    to,
+                    value: valueHex,
+                },
+            },
+        };
+        try {
+            const response = await this.executePrivyRequest(body);
+            const receipt = await this.waitForTransactionReceipt(response.data.hash);
+            if (!receipt) {
+                throw new Error("Transaction failed");
+            }
+            return receipt.transactionHash;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Native transfer failed: ${error.message}`);
+            }
+            throw new Error("Native transfer failed");
+        }
+    }
+    /**
+     * Exports the wallet information.
+     *
+     * @returns The wallet data
+     */
+    exportWallet() {
+        return {
+            walletId: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_walletId, "f"),
+            authorizationPrivateKey: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_authKey, "f"),
+            networkId: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f").networkId,
+            chainId: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_network, "f").chainId,
+        };
+    }
+    /**
+     * Generate Privy authorization signature for API requests
+     *
+     * @param url - The URL for the request
+     * @param body - The request body
+     * @returns The generated signature
+     */
+    generatePrivySignature(url, body) {
+        try {
+            const payload = {
+                version: 1,
+                method: "POST",
+                url,
+                body,
+                headers: {
+                    "privy-app-id": __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appId, "f"),
+                },
+            };
+            const serializedPayload = (0, canonicalize_1.default)(payload);
+            if (!serializedPayload)
+                throw new Error("Failed to canonicalize payload");
+            const serializedPayloadBuffer = Buffer.from(serializedPayload);
+            const privateKeyAsString = __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_authKey, "f").replace("wallet-auth:", "");
+            const privateKeyAsPem = `-----BEGIN PRIVATE KEY-----\n${privateKeyAsString}\n-----END PRIVATE KEY-----`;
+            const privateKey = crypto_1.default.createPrivateKey({
+                key: privateKeyAsPem,
+                format: "pem",
+            });
+            const signatureBuffer = crypto_1.default.sign("sha256", serializedPayloadBuffer, privateKey);
+            return signatureBuffer.toString("base64");
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Error generating Privy authorization signature: ${error.message}`);
+            }
+            throw new Error("Error generating Privy authorization signature");
+        }
+    }
+    /**
+     * Get Privy headers for API requests
+     *
+     * @param url - The URL for the request
+     * @param body - The request body
+     * @returns The headers for the request
+     */
+    getPrivyHeaders(url, body) {
+        return {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${Buffer.from(`${__classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appId, "f")}:${__classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appSecret, "f")}`).toString("base64")}`,
+            "privy-app-id": __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_appId, "f"),
+            "privy-authorization-signature": this.generatePrivySignature(url, body),
+        };
+    }
+    /**
+     * Execute a Privy API request.
+     *
+     * @param body - The request body to send to the Privy API
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    async executePrivyRequest(body) {
+        const url = `https://api.privy.io/v1/wallets/rpc`;
+        const headers = this.getPrivyHeaders(url, body);
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error("Privy request failed: " + error.message);
+            }
+            throw new Error("Privy request failed with unknown error");
+        }
+    }
+}
+exports.PrivyEvmDelegatedEmbeddedWalletProvider = PrivyEvmDelegatedEmbeddedWalletProvider;
+_PrivyEvmDelegatedEmbeddedWalletProvider_walletId = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_address = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_appId = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_appSecret = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_authKey = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_network = new WeakMap(), _PrivyEvmDelegatedEmbeddedWalletProvider_publicClient = new WeakMap();

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

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

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

@@ -1,35 +1,48 @@
 import { PrivyEvmWalletProvider, PrivyEvmWalletConfig } from "./privyEvmWalletProvider";
 import { PrivySvmWalletProvider, PrivySvmWalletConfig } from "./privySvmWalletProvider";
-export type PrivyWalletConfig = PrivyEvmWalletConfig | PrivySvmWalletConfig;
+import { PrivyEvmDelegatedEmbeddedWalletProvider, PrivyEvmDelegatedEmbeddedWalletConfig } from "./privyEvmDelegatedEmbeddedWalletProvider";
+export type PrivyWalletConfig = PrivyEvmWalletConfig | PrivySvmWalletConfig | PrivyEvmDelegatedEmbeddedWalletConfig;
+export type PrivyWalletProviderVariant<T> = T extends {
+    walletType: "embedded";
+} ? PrivyEvmDelegatedEmbeddedWalletProvider : T extends {
+    chainType: "solana";
+} ? PrivySvmWalletProvider : PrivyEvmWalletProvider;
 /**
  * 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.
+     * Creates and configures a new wallet provider instance based on the chain type and wallet type.
      *
      * @param config - The configuration options for the Privy wallet
-     * @returns A configured WalletProvider instance for the specified chain
+     * @returns A configured WalletProvider instance for the specified chain and wallet type
      *
      * @example
      * ```typescript
-     * // For EVM (default)
+     * // For EVM server wallets (default)
      * const evmWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret"
      * });
      *
-     * // For Solana
+     * // For Solana server wallets
      * const solanaWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret",
      *   chainType: "solana"
      * });
+     *
+     * // For Ethereum embedded wallets
+     * const embeddedWallet = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   walletId: "delegated-wallet-id",
+     *   walletType: "embedded"
+     * });
      * ```
      */
     static configureWithWallet<T extends PrivyWalletConfig>(config: T & {
         chainType?: "ethereum" | "solana";
-    }): Promise<T extends {
-        chainType: "solana";
-    } ? PrivySvmWalletProvider : PrivyEvmWalletProvider>;
+        walletType?: "server" | "embedded";
+    }): Promise<PrivyWalletProviderVariant<T>>;
 }

package/dist/wallet-providers/privyWalletProvider.js

@@ -3,37 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrivyWalletProvider = void 0;
 const privyEvmWalletProvider_1 = require("./privyEvmWalletProvider");
 const privySvmWalletProvider_1 = require("./privySvmWalletProvider");
+const privyEvmDelegatedEmbeddedWalletProvider_1 = require("./privyEvmDelegatedEmbeddedWalletProvider");
 /**
  * Factory class for creating chain-specific Privy wallet providers
  */
 class PrivyWalletProvider {
     /**
-     * Creates and configures a new wallet provider instance based on the chain type.
+     * Creates and configures a new wallet provider instance based on the chain type and wallet type.
      *
      * @param config - The configuration options for the Privy wallet
-     * @returns A configured WalletProvider instance for the specified chain
+     * @returns A configured WalletProvider instance for the specified chain and wallet type
      *
      * @example
      * ```typescript
-     * // For EVM (default)
+     * // For EVM server wallets (default)
      * const evmWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret"
      * });
      *
-     * // For Solana
+     * // For Solana server wallets
      * const solanaWallet = await PrivyWalletProvider.configureWithWallet({
      *   appId: "your-app-id",
      *   appSecret: "your-app-secret",
      *   chainType: "solana"
      * });
+     *
+     * // For Ethereum embedded wallets
+     * const embeddedWallet = await PrivyWalletProvider.configureWithWallet({
+     *   appId: "your-app-id",
+     *   appSecret: "your-app-secret",
+     *   walletId: "delegated-wallet-id",
+     *   walletType: "embedded"
+     * });
      * ```
      */
     static async configureWithWallet(config) {
-        if (config.chainType === "solana") {
-            return (await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(config));
+        const chainType = config.chainType || "ethereum";
+        const walletType = config.walletType || "server";
+        switch (chainType) {
+            case "ethereum": {
+                switch (walletType) {
+                    case "server":
+                        return (await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(config));
+                    case "embedded":
+                        return (await privyEvmDelegatedEmbeddedWalletProvider_1.PrivyEvmDelegatedEmbeddedWalletProvider.configureWithWallet(config));
+                    default:
+                        throw new Error("Invalid wallet type");
+                }
+            }
+            case "solana": {
+                switch (walletType) {
+                    case "server":
+                        return (await privySvmWalletProvider_1.PrivySvmWalletProvider.configureWithWallet(config));
+                    case "embedded":
+                        throw new Error("Embedded wallets are not supported for Solana");
+                    default:
+                        throw new Error("Invalid wallet type");
+                }
+            }
+            default: {
+                throw new Error("Invalid chain type");
+            }
         }
-        return (await privyEvmWalletProvider_1.PrivyEvmWalletProvider.configureWithWallet(config));
     }
 }
 exports.PrivyWalletProvider = PrivyWalletProvider;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.0.0-nightly-20250328174338",
+  "version": "0.0.0-nightly-20250328210410",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -30,6 +30,7 @@
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",
     "bs58": "^4.0.1",
+    "canonicalize": "^2.1.0",
     "decimal.js": "^10.5.0",
     "ethers": "^6.13.5",
     "md5": "^2.3.0",