@coinbase/agentkit 0.10.1 → 0.10.3

package/dist/utils.js

@@ -2,19 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.approve = approve;
 exports.applyGasMultiplier = applyGasMultiplier;
+exports.retryWithExponentialBackoff = retryWithExponentialBackoff;
 const viem_1 = require("viem");
-const ERC20_ABI = [
-    {
-        inputs: [
-            { name: "spender", type: "address" },
-            { name: "amount", type: "uint256" },
-        ],
-        name: "approve",
-        outputs: [{ name: "", type: "bool" }],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-];
+const viem_2 = require("viem");
 /**
  * Approves a spender to spend tokens on behalf of the owner
  *
@@ -27,7 +17,7 @@ const ERC20_ABI = [
 async function approve(wallet, tokenAddress, spenderAddress, amount) {
     try {
         const data = (0, viem_1.encodeFunctionData)({
-            abi: ERC20_ABI,
+            abi: viem_2.erc20Abi,
             functionName: "approve",
             args: [spenderAddress, amount],
         });
@@ -55,3 +45,43 @@ async function approve(wallet, tokenAddress, spenderAddress, amount) {
 function applyGasMultiplier(gas, multiplier) {
     return BigInt(Math.round(Number(gas) * multiplier));
 }
+/**
+ * Utility function to sleep for a given number of milliseconds
+ *
+ * @param ms - Number of milliseconds to sleep
+ * @returns Promise that resolves after the specified delay
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Retry function with exponential backoff
+ *
+ * @param fn - The function to retry
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param baseDelay - Base delay in milliseconds for retries (default: 1000)
+ * @param initialDelay - Initial delay before the first attempt in milliseconds (default: 0)
+ * @returns Promise that resolves with the function result or rejects with the last error
+ */
+async function retryWithExponentialBackoff(fn, maxRetries = 3, baseDelay = 1000, initialDelay = 0) {
+    let lastError;
+    // Wait before the first attempt if initialDelay is specified
+    if (initialDelay > 0) {
+        await sleep(initialDelay);
+    }
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // If this was the last attempt, throw the error
+            if (attempt === maxRetries) {
+                throw lastError;
+            }
+            // Wait after failed attempt with exponential backoff
+            // Calculate delay with exponential backoff: baseDelay * 2^attempt
+            const delay = baseDelay * Math.pow(2, attempt);
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}

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

@@ -35,6 +35,13 @@ export declare class CdpEvmWalletProvider extends EvmWalletProvider implements W
         name: string | undefined;
         address: `0x${string}`;
     }>;
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    sign(hash: `0x${string}`): Promise<Hex>;
     /**
      * Signs a message.
      *

package/dist/wallet-providers/cdpEvmWalletProvider.js

@@ -89,6 +89,15 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             address: __classPrivateFieldGet(this, _CdpEvmWalletProvider_serverAccount, "f").address,
         };
     }
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    async sign(hash) {
+        return __classPrivateFieldGet(this, _CdpEvmWalletProvider_serverAccount, "f").sign({ hash });
+    }
     /**
      * Signs a message.
      *
@@ -129,29 +138,13 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @returns The hash of the transaction.
      */
     async sendTransaction(transaction) {
-        const txWithGasParams = {
-            ...transaction,
-            chainId: __classPrivateFieldGet(this, _CdpEvmWalletProvider_network, "f").chainId,
-        };
-        if (!txWithGasParams.maxFeePerGas && !txWithGasParams.gasPrice) {
-            const feeData = await __classPrivateFieldGet(this, _CdpEvmWalletProvider_publicClient, "f").estimateFeesPerGas();
-            txWithGasParams.maxFeePerGas = feeData.maxFeePerGas;
-            txWithGasParams.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
-        }
-        if (!txWithGasParams.gas) {
-            try {
-                txWithGasParams.gas = await __classPrivateFieldGet(this, _CdpEvmWalletProvider_publicClient, "f").estimateGas({
-                    account: __classPrivateFieldGet(this, _CdpEvmWalletProvider_serverAccount, "f").address,
-                    ...txWithGasParams,
-                });
-            }
-            catch (error) {
-                console.warn("Failed to estimate gas, continuing without gas estimation", error);
-            }
-        }
         const result = await __classPrivateFieldGet(this, _CdpEvmWalletProvider_cdp, "f").evm.sendTransaction({
             address: __classPrivateFieldGet(this, _CdpEvmWalletProvider_serverAccount, "f").address,
-            transaction: (0, viem_1.serializeTransaction)(txWithGasParams),
+            transaction: {
+                to: transaction.to,
+                value: transaction.value ? BigInt(transaction.value.toString()) : 0n,
+                data: transaction.data || "0x",
+            },
             network: this.getCdpSdkNetwork(),
         });
         return result.transactionHash;

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

@@ -114,6 +114,7 @@ describe("CdpEvmWalletProvider", () => {
         });
         mockServerAccount = {
             address: MOCK_ADDRESS,
+            sign: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
             signMessage: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
             signTypedData: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
         };
@@ -214,6 +215,12 @@ describe("CdpEvmWalletProvider", () => {
     // signing operation tests
     // =========================================================
     describe("signing operations", () => {
+        it("should sign a hash", async () => {
+            const testHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+            const signature = await provider.sign(testHash);
+            expect(mockServerAccount.sign).toHaveBeenCalledWith({ hash: testHash });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
         it("should sign messages", async () => {
             const signature = await provider.signMessage("Hello, world!");
             expect(mockServerAccount.signMessage).toHaveBeenCalledWith({ message: "Hello, world!" });

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

@@ -38,6 +38,13 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
         address: Address;
         ownerAddress: Address;
     }>;
+    /**
+     * Signs a raw hash using the owner account.
+     *
+     * @param _hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    sign(_hash: Hex): Promise<Hex>;
     /**
      * Signs a message using the owner account.
      *

package/dist/wallet-providers/cdpSmartWalletProvider.js

@@ -56,10 +56,6 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             throw new Error("Missing required environment variables. CDP_API_KEY_ID, CDP_API_KEY_SECRET, CDP_WALLET_SECRET are required.");
         }
         const networkId = config.networkId || process.env.NETWORK_ID || "base-sepolia";
-        // Smart wallets are currently only supported on Base networks
-        if (!networkId.startsWith("base-")) {
-            throw new Error(`Smart wallets are only supported on Base networks. Got: ${networkId}`);
-        }
         const network = {
             protocolFamily: "evm",
             chainId: network_1.NETWORK_ID_TO_CHAIN_ID[networkId],
@@ -116,6 +112,18 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             ownerAddress: this.ownerAccount.address,
         };
     }
+    /**
+     * Signs a raw hash using the owner account.
+     *
+     * @param _hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    async sign(_hash) {
+        if (!this.ownerAccount.sign) {
+            throw new Error("Owner account does not support raw hash signing");
+        }
+        return this.ownerAccount.sign({ hash: _hash });
+    }
     /**
      * Signs a message using the owner account.
      *
@@ -123,7 +131,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @returns The signed message.
      */
     async signMessage(_message) {
-        throw new Error("Direct message signing not supported for smart wallets. Use sendTransaction instead.");
+        return this.ownerAccount.signMessage({ message: _message });
     }
     /**
      * Signs a typed data object using the owner account.
@@ -238,12 +246,19 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async waitForTransactionReceipt(userOpHash) {
         // For smart wallets, we need to wait for the user operation to be confirmed
-        // This is a simplified implementation - in practice you might want to poll
-        // the CDP API for user operation status
-        return __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.waitForUserOperation({
+        const receipt = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.waitForUserOperation({
             smartAccountAddress: this.smartAccount.address,
             userOpHash,
         });
+        // Append transaction logs if available
+        if (receipt.status === "complete") {
+            const receiptTx = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_publicClient, "f").waitForTransactionReceipt({
+                hash: receipt.transactionHash,
+            });
+            if (receiptTx.logs)
+                return { ...receipt, logs: receiptTx.logs };
+        }
+        return receipt;
     }
     /**
      * Reads a contract.

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

@@ -109,6 +109,7 @@ describe("CdpSmartWalletProvider", () => {
         });
         mockOwnerAccount = {
             address: MOCK_ADDRESS,
+            sign: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
             signMessage: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
             signTypedData: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
         };
@@ -141,14 +142,6 @@ describe("CdpSmartWalletProvider", () => {
             expect(provider.getAddress()).toBe(MOCK_SMART_ADDRESS);
             expect(provider.getNetwork()).toEqual(MOCK_NETWORK);
         });
-        it("should throw error for non-Base networks", async () => {
-            await expect(cdpSmartWalletProvider_1.CdpSmartWalletProvider.configureWithWallet({
-                apiKeyId: "test-key-id",
-                apiKeySecret: "test-key-secret",
-                walletSecret: "test-wallet-secret",
-                networkId: "ethereum-sepolia",
-            })).rejects.toThrow("Smart wallets are only supported on Base networks");
-        });
         it("should create smart account with name", async () => {
             await cdpSmartWalletProvider_1.CdpSmartWalletProvider.configureWithWallet({
                 apiKeyId: "test-key-id",
@@ -188,8 +181,11 @@ describe("CdpSmartWalletProvider", () => {
     // signing operation tests
     // =========================================================
     describe("signing operations", () => {
-        it("should throw error for direct message signing", async () => {
-            await expect(provider.signMessage("Hello, world!")).rejects.toThrow("Direct message signing not supported for smart wallets. Use sendTransaction instead.");
+        it("should sign a hash using owner account", async () => {
+            const testHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+            const signature = await provider.sign(testHash);
+            expect(mockOwnerAccount.sign).toHaveBeenCalledWith({ hash: testHash });
+            expect(signature).toBe(MOCK_SIGNATURE);
         });
         it("should sign typed data using smart account", async () => {
             const typedData = {

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

@@ -1,4 +1,5 @@
 import { CdpClient } from "@coinbase/cdp-sdk";
+import type { KeyPairSigner } from "@solana/kit";
 import { Connection, PublicKey, RpcResponseAndContext, SignatureResult, SignatureStatus, SignatureStatusConfig, VersionedTransaction } from "@solana/web3.js";
 import { Network } from "../network";
 import { WalletProviderWithClient, CdpWalletProviderConfig } from "./cdpShared";
@@ -109,6 +110,13 @@ export declare class CdpSolanaWalletProvider extends SvmWalletProvider implement
      * @returns The CDP client.
      */
     getClient(): CdpClient;
+    /**
+     * Sign a message.
+     *
+     * @param message - The message to sign as a Uint8Array
+     * @returns The signature as a Uint8Array
+     */
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
     /**
      * Transfer SOL from the wallet to another address
      *
@@ -117,4 +125,10 @@ export declare class CdpSolanaWalletProvider extends SvmWalletProvider implement
      * @returns The signature
      */
     nativeTransfer(to: string, value: string): Promise<string>;
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    getKeyPairSigner(): Promise<KeyPairSigner>;
 }

package/dist/wallet-providers/cdpSolanaWalletProvider.js

@@ -10,11 +10,15 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _CdpSolanaWalletProvider_connection, _CdpSolanaWalletProvider_serverAccount, _CdpSolanaWalletProvider_cdp, _CdpSolanaWalletProvider_network;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _CdpSolanaWalletProvider_connection, _CdpSolanaWalletProvider_cdp, _CdpSolanaWalletProvider_network, _CdpSolanaWalletProvider_serverAccount;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpSolanaWalletProvider = void 0;
 const cdp_sdk_1 = require("@coinbase/cdp-sdk");
 const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
 const svm_1 = require("../network/svm");
 const svmWalletProvider_1 = require("./svmWalletProvider");
 /**
@@ -29,9 +33,9 @@ class CdpSolanaWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
     constructor(config) {
         super();
         _CdpSolanaWalletProvider_connection.set(this, void 0);
-        _CdpSolanaWalletProvider_serverAccount.set(this, void 0);
         _CdpSolanaWalletProvider_cdp.set(this, void 0);
         _CdpSolanaWalletProvider_network.set(this, void 0);
+        _CdpSolanaWalletProvider_serverAccount.set(this, void 0);
         __classPrivateFieldSet(this, _CdpSolanaWalletProvider_serverAccount, config.serverAccount, "f");
         __classPrivateFieldSet(this, _CdpSolanaWalletProvider_cdp, config.cdp, "f");
         __classPrivateFieldSet(this, _CdpSolanaWalletProvider_connection, config.connection, "f");
@@ -216,6 +220,23 @@ class CdpSolanaWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
     getClient() {
         return __classPrivateFieldGet(this, _CdpSolanaWalletProvider_cdp, "f");
     }
+    /**
+     * Sign a message.
+     *
+     * @param message - The message to sign as a Uint8Array
+     * @returns The signature as a Uint8Array
+     */
+    async signMessage(message) {
+        // Convert Uint8Array to string for CDP SDK
+        const messageString = Buffer.from(message).toString("utf8");
+        const { signature } = await __classPrivateFieldGet(this, _CdpSolanaWalletProvider_cdp, "f").solana.signMessage({
+            address: __classPrivateFieldGet(this, _CdpSolanaWalletProvider_serverAccount, "f").address,
+            message: messageString,
+        });
+        // Convert signature string back to Uint8Array
+        // CDP returns signature as a hex string, convert to bytes
+        return new Uint8Array(Buffer.from(signature, "hex"));
+    }
     /**
      * Transfer SOL from the wallet to another address
      *
@@ -253,6 +274,21 @@ class CdpSolanaWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
         await this.waitForSignatureResult(signature);
         return signature;
     }
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    async getKeyPairSigner() {
+        // Export the private key from CDP
+        const exportedPrivateKey = await __classPrivateFieldGet(this, _CdpSolanaWalletProvider_cdp, "f").solana.exportAccount({
+            address: __classPrivateFieldGet(this, _CdpSolanaWalletProvider_serverAccount, "f").address,
+        });
+        // Decode the base58 encoded private key to get the full 64-byte key
+        const fullKeyBytes = bs58_1.default.decode(exportedPrivateKey);
+        // Create and return the KeyPairSigner using the full key bytes
+        return (0, svmWalletProvider_1.createSignerFromBytes)(fullKeyBytes);
+    }
 }
 exports.CdpSolanaWalletProvider = CdpSolanaWalletProvider;
-_CdpSolanaWalletProvider_connection = new WeakMap(), _CdpSolanaWalletProvider_serverAccount = new WeakMap(), _CdpSolanaWalletProvider_cdp = new WeakMap(), _CdpSolanaWalletProvider_network = new WeakMap();
+_CdpSolanaWalletProvider_connection = new WeakMap(), _CdpSolanaWalletProvider_cdp = new WeakMap(), _CdpSolanaWalletProvider_network = new WeakMap(), _CdpSolanaWalletProvider_serverAccount = new WeakMap();

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

@@ -307,4 +307,20 @@ describe("CdpSolanaWalletProvider", () => {
             await expect(provider.nativeTransfer(invalidAddress, amount)).rejects.toThrow();
         });
     });
+    // =========================================================
+    // KeyPairSigner tests
+    // =========================================================
+    describe("KeyPairSigner", () => {
+        it("should handle errors when getting KeyPairSigner", async () => {
+            // Mock exportAccount to throw an error
+            mockCdpClient.solana.exportAccount = jest.fn().mockRejectedValue(new Error("Export failed"));
+            await expect(provider.getKeyPairSigner()).rejects.toThrow("Export failed");
+        });
+        it("should handle errors gracefully in isKeyPairSigner", async () => {
+            // Mock exportAccount to throw an error
+            mockCdpClient.solana.exportAccount = jest.fn().mockRejectedValue(new Error("Export failed"));
+            const isValid = await provider.isKeyPairSigner();
+            expect(isValid).toBe(false);
+        });
+    });
 });

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

@@ -1,5 +1,5 @@
 import { WalletProvider } from "./walletProvider";
-import { TransactionRequest, ReadContractParameters, ReadContractReturnType, ContractFunctionName, Abi, ContractFunctionArgs, Account, PublicClient } from "viem";
+import { TransactionRequest, ReadContractParameters, ReadContractReturnType, ContractFunctionName, Abi, ContractFunctionArgs, PublicClient, LocalAccount } from "viem";
 /**
  * EvmWalletProvider is the abstract base class for all EVM wallet providers.
  *
@@ -11,7 +11,14 @@ export declare abstract class EvmWalletProvider extends WalletProvider {
      *
      * @returns The signer.
      */
-    toSigner(): Account;
+    toSigner(): LocalAccount;
+    /**
+     * Sign a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    abstract sign(hash: `0x${string}`): Promise<`0x${string}`>;
     /**
      * Sign a message.
      *

package/dist/wallet-providers/evmWalletProvider.js

@@ -18,7 +18,11 @@ class EvmWalletProvider extends walletProvider_1.WalletProvider {
      */
     toSigner() {
         return (0, accounts_1.toAccount)({
+            type: "local",
             address: this.getAddress(),
+            sign: async ({ hash }) => {
+                return this.sign(hash);
+            },
             signMessage: async ({ message }) => {
                 return this.signMessage(message);
             },

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

@@ -47,6 +47,15 @@ export declare class LegacyCdpSmartWalletProvider extends EvmWalletProvider {
      * ```
      */
     static configureWithWallet(config: ConfigureLegacyCdpSmartWalletOptions): Promise<LegacyCdpSmartWalletProvider>;
+    /**
+     * Stub for hash signing
+     *
+     * @throws as signing hashes is not implemented for SmartWallets.
+     *
+     * @param _ - The hash to sign.
+     * @returns The signed hash.
+     */
+    sign(_: `0x${string}`): Promise<Hex>;
     /**
      * Stub for message signing
      *

package/dist/wallet-providers/legacyCdpSmartWalletProvider.js

@@ -111,6 +111,17 @@ class LegacyCdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider
         });
         return legacyCdpSmartWalletProvider;
     }
+    /**
+     * Stub for hash signing
+     *
+     * @throws as signing hashes is not implemented for SmartWallets.
+     *
+     * @param _ - The hash to sign.
+     * @returns The signed hash.
+     */
+    async sign(_) {
+        throw new Error("Not implemented");
+    }
     /**
      * Stub for message signing
      *

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

@@ -89,6 +89,13 @@ export declare class LegacyCdpWalletProvider extends EvmWalletProvider {
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
     static configureWithWallet(config?: ConfigureLegacyCdpAgentkitWithWalletOptions): Promise<LegacyCdpWalletProvider>;
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    sign(hash: `0x${string}`): Promise<`0x${string}`>;
     /**
      * Signs a message.
      *

package/dist/wallet-providers/legacyCdpWalletProvider.js

@@ -106,6 +106,22 @@ class LegacyCdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         });
         return cdpWalletProvider;
     }
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    async sign(hash) {
+        if (!__classPrivateFieldGet(this, _LegacyCdpWalletProvider_cdpWallet, "f")) {
+            throw new Error("Wallet not initialized");
+        }
+        const payload = await __classPrivateFieldGet(this, _LegacyCdpWalletProvider_cdpWallet, "f").createPayloadSignature(hash);
+        if (payload.getStatus() === "pending" && payload?.wait) {
+            await payload.wait(); // needed for Server-Signers
+        }
+        return payload.getSignature();
+    }
     /**
      * Signs a message.
      *

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

@@ -268,6 +268,12 @@ describe("LegacyCdpWalletProvider", () => {
     // signing operation tests
     // =========================================================
     describe("signing operations", () => {
+        it("should sign a hash", async () => {
+            const testHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+            const signature = await provider.sign(testHash);
+            expect(mockWalletObj.createPayloadSignature).toHaveBeenCalledWith(testHash);
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
         it("should sign messages", async () => {
             const signature = await provider.signMessage("Hello, world!");
             expect(mockWalletObj.createPayloadSignature).toHaveBeenCalled();

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

@@ -78,6 +78,13 @@ export declare class PrivyEvmDelegatedEmbeddedWalletProvider extends WalletProvi
      * @returns The balance of the wallet in wei
      */
     getBalance(): Promise<bigint>;
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    sign(hash: `0x${string}`): Promise<Hex>;
     /**
      * Signs a message.
      *

package/dist/wallet-providers/privyEvmDelegatedEmbeddedWalletProvider.js

@@ -170,6 +170,33 @@ class PrivyEvmDelegatedEmbeddedWalletProvider extends walletProvider_1.WalletPro
             throw new Error("Error getting balance");
         }
     }
+    /**
+     * Signs a raw hash.
+     *
+     * @param hash - The hash to sign.
+     * @returns The signed hash.
+     */
+    async sign(hash) {
+        const body = {
+            address: __classPrivateFieldGet(this, _PrivyEvmDelegatedEmbeddedWalletProvider_address, "f"),
+            chain_type: "ethereum",
+            method: "personal_sign",
+            params: {
+                message: hash,
+                encoding: "hex",
+            },
+        };
+        try {
+            const response = await this.executePrivyRequest(body);
+            return response.data?.signature;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Hash signing failed: ${error.message}`);
+            }
+            throw new Error("Hash signing failed");
+        }
+    }
     /**
      * Signs a message.
      *

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

@@ -14,6 +14,10 @@ const MOCK_TRANSACTION_HASH = "0xef01";
 const MOCK_SIGNATURE_HASH_1 = "0x1234";
 const MOCK_SIGNATURE_HASH_2 = "0x5678";
 const MOCK_SIGNATURE_HASH_3 = "0xabcd";
+const MOCK_HASH_SIGNATURE = "0xhash";
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
 jest.mock("@privy-io/server-auth", () => ({
     PrivyClient: jest.fn().mockImplementation(() => ({
         appId: "mock-app-id",
@@ -65,6 +69,7 @@ jest.mock("@privy-io/server-auth/viem", () => ({
     createViemAccount: jest.fn().mockResolvedValue({
         address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
         type: "local",
+        sign: jest.fn().mockResolvedValue("0xhash"),
         signMessage: jest.fn().mockResolvedValue("0x1234"),
         signTypedData: jest.fn().mockResolvedValue("0x5678"),
         signTransaction: jest.fn().mockResolvedValue("0xabcd"),
@@ -120,6 +125,7 @@ jest.mock("viem", () => {
         createWalletClient: jest.fn().mockReturnValue({
             account: {
                 address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+                sign: jest.fn().mockResolvedValue("0xhash"),
             },
             chain: {
                 id: 1,
@@ -214,6 +220,11 @@ describe("PrivyEvmWalletProvider", () => {
         it("should get the provider name", () => {
             expect(provider.getName()).toBe("privy_evm_wallet_provider");
         });
+        it("should sign a hash", async () => {
+            const testHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+            const result = await provider.sign(testHash);
+            expect(result).toBe(MOCK_HASH_SIGNATURE);
+        });
         it("should sign a message", async () => {
             const result = await provider.signMessage("Hello, world!");
             expect(result).toBe(MOCK_SIGNATURE_HASH_1);

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

@@ -1,3 +1,4 @@
+import type { KeyPairSigner } from "@solana/kit";
 import { SvmWalletProvider } from "./svmWalletProvider";
 import { RpcResponseAndContext, SignatureStatus, VersionedTransaction, Connection, PublicKey, SignatureResult } from "@solana/web3.js";
 import { Network } from "../network/types";
@@ -127,4 +128,17 @@ export declare class PrivySvmWalletProvider extends SvmWalletProvider {
      * @returns The public key.
      */
     getPublicKey(): PublicKey;
+    /**
+     * Sign a message.
+     *
+     * @param _ - The message to sign as a Uint8Array (unused)
+     * @returns Never - throws an error as message signing is not supported yet
+     */
+    signMessage(_: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    getKeyPairSigner(): Promise<KeyPairSigner>;
 }