@coinbase/agentkit 0.0.0-nightly-20250918210440 → 0.0.0-nightly-20251001210424

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.js

@@ -138,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/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],
@@ -252,10 +248,19 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         // 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").getTransactionReceipt({
+                hash: receipt.transactionHash,
+            });
+            if (receiptTx.logs)
+                return { ...receipt, logs: receiptTx.logs };
+        }
+        return receipt;
     }
     /**
      * Reads a contract.

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

@@ -142,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",

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/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>;
 }

package/dist/wallet-providers/privySvmWalletProvider.js

@@ -210,6 +210,23 @@ class PrivySvmWalletProvider extends svmWalletProvider_1.SvmWalletProvider {
     getPublicKey() {
         return new web3_js_1.PublicKey(__classPrivateFieldGet(this, _PrivySvmWalletProvider_address, "f"));
     }
+    /**
+     * Sign a message.
+     *
+     * @param _ - The message to sign as a Uint8Array (unused)
+     * @returns Never - throws an error as message signing is not supported yet
+     */
+    async signMessage(_) {
+        throw new Error("Message signing is not supported yet for PrivySvmWalletProvider");
+    }
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    async getKeyPairSigner() {
+        throw new Error("getKeyPairSigner is not supported for PrivySvmWalletProvider");
+    }
 }
 exports.PrivySvmWalletProvider = PrivySvmWalletProvider;
 _PrivySvmWalletProvider_walletId = new WeakMap(), _PrivySvmWalletProvider_address = new WeakMap(), _PrivySvmWalletProvider_authorizationPrivateKey = new WeakMap(), _PrivySvmWalletProvider_privyClient = new WeakMap(), _PrivySvmWalletProvider_connection = new WeakMap(), _PrivySvmWalletProvider_genesisHash = new WeakMap();

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

@@ -307,5 +307,15 @@ describe("PrivySvmWalletProvider", () => {
             connection.getBalance = mockMethod;
             await expect(provider.getBalance()).rejects.toThrow("RPC endpoint error");
         });
+        it("should throw error when trying to get KeyPairSigner", async () => {
+            await expect(provider.getKeyPairSigner()).rejects.toThrow("getKeyPairSigner is not supported for PrivySvmWalletProvider");
+        });
+        it("should throw error when trying to convert to signer", async () => {
+            await expect(provider.toSigner()).rejects.toThrow("getKeyPairSigner is not supported for PrivySvmWalletProvider");
+        });
+        it("should return false for isKeyPairSigner", async () => {
+            const isValid = await provider.isKeyPairSigner();
+            expect(isValid).toBe(false);
+        });
     });
 });

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

@@ -2,6 +2,7 @@ import { SvmWalletProvider } from "./svmWalletProvider";
 import { Network } from "../network";
 import { Connection, PublicKey, VersionedTransaction, RpcResponseAndContext, SignatureResult, SignatureStatus, SignatureStatusConfig } from "@solana/web3.js";
 import { SOLANA_CLUSTER, SOLANA_NETWORK_ID } from "../network/svm";
+import { KeyPairSigner } from "@solana/kit";
 /**
  * SolanaKeypairWalletProvider is a wallet provider that uses a local Solana keypair.
  *
@@ -133,6 +134,13 @@ export declare class SolanaKeypairWalletProvider extends SvmWalletProvider {
      * @returns The signature
      */
     nativeTransfer(to: string, value: string): Promise<string>;
+    /**
+     * 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>;
     /**
      * Request SOL tokens from the Solana faucet. This method only works on devnet and testnet networks.
      *
@@ -140,4 +148,10 @@ export declare class SolanaKeypairWalletProvider extends SvmWalletProvider {
      * @returns A Promise that resolves to the signature of the airdrop
      */
     requestAirdrop(lamports: number): Promise<string>;
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    getKeyPairSigner(): Promise<KeyPairSigner>;
 }

package/dist/wallet-providers/solanaKeypairWalletProvider.js

@@ -265,6 +265,15 @@ class SolanaKeypairWalletProvider extends svmWalletProvider_1.SvmWalletProvider
         await this.waitForSignatureResult(signature);
         return signature;
     }
+    /**
+     * Sign a message.
+     *
+     * @param _ - The message to sign as a Uint8Array (unused)
+     * @returns Never - throws an error as message signing is not supported yet
+     */
+    async signMessage(_) {
+        throw new Error("Message signing is not supported yet for SolanaKeypairWalletProvider");
+    }
     /**
      * Request SOL tokens from the Solana faucet. This method only works on devnet and testnet networks.
      *
@@ -274,6 +283,14 @@ class SolanaKeypairWalletProvider extends svmWalletProvider_1.SvmWalletProvider
     async requestAirdrop(lamports) {
         return await __classPrivateFieldGet(this, _SolanaKeypairWalletProvider_connection, "f").requestAirdrop(__classPrivateFieldGet(this, _SolanaKeypairWalletProvider_keypair, "f").publicKey, lamports);
     }
+    /**
+     * Get the keypair signer for this wallet.
+     *
+     * @returns The KeyPairSigner
+     */
+    async getKeyPairSigner() {
+        return (0, svmWalletProvider_1.createSignerFromBytes)(__classPrivateFieldGet(this, _SolanaKeypairWalletProvider_keypair, "f").secretKey);
+    }
 }
 exports.SolanaKeypairWalletProvider = SolanaKeypairWalletProvider;
 _SolanaKeypairWalletProvider_keypair = new WeakMap(), _SolanaKeypairWalletProvider_connection = new WeakMap(), _SolanaKeypairWalletProvider_genesisHash = new WeakMap();

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

@@ -1,11 +1,24 @@
 import { WalletProvider } from "./walletProvider";
 import { Connection, PublicKey, RpcResponseAndContext, SignatureStatus, SignatureStatusConfig, VersionedTransaction, SignatureResult } from "@solana/web3.js";
+import { KeyPairSigner } from "@solana/kit";
 /**
  * SvmWalletProvider is the abstract base class for all Solana wallet providers (non browsers).
  *
  * @abstract
  */
 export declare abstract class SvmWalletProvider extends WalletProvider {
+    /**
+     * Convert the wallet provider to a KeyPairSigner.
+     *
+     * @returns The KeyPairSigner instance
+     */
+    toSigner(): Promise<KeyPairSigner>;
+    /**
+     * Check if this wallet's signer is a valid KeyPairSigner.
+     *
+     * @returns True if the signer is a valid KeyPairSigner, false otherwise
+     */
+    isKeyPairSigner(): Promise<boolean>;
     /**
      * Get the connection instance.
      *
@@ -53,4 +66,25 @@ export declare abstract class SvmWalletProvider extends WalletProvider {
      * @returns The confirmation response
      */
     abstract waitForSignatureResult(signature: string): Promise<RpcResponseAndContext<SignatureResult>>;
+    /**
+     * Sign a message.
+     *
+     * @param message - The message to sign as a Uint8Array
+     * @returns The signature as a Uint8Array
+     */
+    abstract signMessage(message: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the keypair for this wallet.
+     *
+     * @returns The CryptoKeyPair for KeyPairSigner compatibility
+     */
+    abstract getKeyPairSigner(): Promise<KeyPairSigner>;
 }
+/**
+ * Create a KeyPairSigner from raw bytes.
+ *
+ * @param bytes - The raw key bytes (32 bytes for private key only, 64 bytes for private + public key)
+ * @returns A KeyPairSigner instance
+ * @throws Error if the byte length is not 32 or 64
+ */
+export declare function createSignerFromBytes(bytes: Uint8Array): Promise<KeyPairSigner>;

package/dist/wallet-providers/svmWalletProvider.js

@@ -2,12 +2,55 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SvmWalletProvider = void 0;
+exports.createSignerFromBytes = createSignerFromBytes;
 const walletProvider_1 = require("./walletProvider");
+const kit_1 = require("@solana/kit");
 /**
  * SvmWalletProvider is the abstract base class for all Solana wallet providers (non browsers).
  *
  * @abstract
  */
 class SvmWalletProvider extends walletProvider_1.WalletProvider {
+    /**
+     * Convert the wallet provider to a KeyPairSigner.
+     *
+     * @returns The KeyPairSigner instance
+     */
+    async toSigner() {
+        return this.getKeyPairSigner();
+    }
+    /**
+     * Check if this wallet's signer is a valid KeyPairSigner.
+     *
+     * @returns True if the signer is a valid KeyPairSigner, false otherwise
+     */
+    async isKeyPairSigner() {
+        try {
+            const signer = await this.toSigner();
+            return (0, kit_1.isKeyPairSigner)(signer);
+        }
+        catch {
+            return false;
+        }
+    }
 }
 exports.SvmWalletProvider = SvmWalletProvider;
+/**
+ * Create a KeyPairSigner from raw bytes.
+ *
+ * @param bytes - The raw key bytes (32 bytes for private key only, 64 bytes for private + public key)
+ * @returns A KeyPairSigner instance
+ * @throws Error if the byte length is not 32 or 64
+ */
+async function createSignerFromBytes(bytes) {
+    // generate a keypair signer from the bytes based on the byte-length
+    // 64 bytes represents concatenated private + public key
+    if (bytes.length === 64) {
+        return await (0, kit_1.createKeyPairSignerFromBytes)(bytes);
+    }
+    // 32 bytes represents only the private key
+    if (bytes.length === 32) {
+        return await (0, kit_1.createKeyPairSignerFromPrivateKeyBytes)(bytes);
+    }
+    throw new Error(`Unexpected key length: ${bytes.length}. Expected 32 or 64 bytes.`);
+}

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

@@ -52,4 +52,14 @@ describe("SvmWalletProvider", () => {
         expect(getConnectionDescriptor).toBeDefined();
         expect(typeof getConnectionDescriptor.value).toBe("function");
     });
+    it("should have toSigner method", () => {
+        const toSignerDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "toSigner");
+        expect(toSignerDescriptor).toBeDefined();
+        expect(typeof toSignerDescriptor.value).toBe("function");
+    });
+    it("should have isKeyPairSigner method", () => {
+        const isKeyPairSignerDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "isKeyPairSigner");
+        expect(isKeyPairSignerDescriptor).toBeDefined();
+        expect(typeof isKeyPairSignerDescriptor.value).toBe("function");
+    });
 });

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

@@ -43,7 +43,7 @@ export declare class ViemWalletProvider extends EvmWalletProvider {
      * @param message - The message to sign.
      * @returns The signed message.
      */
-    signMessage(message: string): Promise<`0x${string}`>;
+    signMessage(message: string | Uint8Array): Promise<`0x${string}`>;
     /**
      * Signs a typed data object.
      *

package/dist/wallet-providers/viemWalletProvider.js

@@ -71,7 +71,11 @@ class ViemWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         if (!account) {
             throw new Error("Account not found");
         }
-        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").signMessage({ account, message });
+        const _message = typeof message === "string" ? ((0, viem_1.isHex)(message) ? message : (0, viem_1.toHex)(message)) : message;
+        return __classPrivateFieldGet(this, _ViemWalletProvider_walletClient, "f").signMessage({
+            account,
+            message: { raw: _message },
+        });
     }
     /**
      * Signs a typed data object.

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

@@ -104,6 +104,8 @@ jest.mock("viem", () => {
         fromHex: jest.fn(),
         formatEther: jest.fn(),
         privateKeyToAccount: jest.fn(),
+        isHex: jest.fn(value => typeof value === "string" && value.startsWith("0x")),
+        toHex: jest.fn(value => `0x${value}`),
     };
 });
 jest.mock("viem/accounts", () => {
@@ -222,7 +224,16 @@ describe("ViemWalletProvider", () => {
             const signature = await provider.signMessage(MOCK_MESSAGE);
             expect(mockWalletClient.signMessage).toHaveBeenCalledWith({
                 account: mockWalletClient.account,
-                message: MOCK_MESSAGE,
+                message: { raw: `0x${MOCK_MESSAGE}` },
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign a hex message", async () => {
+            const hexMessage = "0x48656c6c6f2c20576f726c6421"; // "Hello, World!" in hex
+            const signature = await provider.signMessage(hexMessage);
+            expect(mockWalletClient.signMessage).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                message: { raw: hexMessage },
             });
             expect(signature).toBe(MOCK_SIGNATURE);
         });

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-20250918210440",
+  "version": "0.0.0-nightly-20251001210424",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -24,12 +24,14 @@
   "dependencies": {
     "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
+    "@base-org/account": "^2.2.0",
     "@coinbase/cdp-sdk": "^1.38.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@coinbase/x402": "^0.6.3",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/public-api": "2.18.5",
     "@privy-io/server-auth": "1.18.4",
+    "@solana/kit": "^2.1.1",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.1",
     "@zerodev/ecdsa-validator": "^5.4.5",
@@ -46,6 +48,7 @@
     "md5": "^2.3.0",
     "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
+    "@ensofinance/sdk": "^2.0.6",
     "twitter-api-v2": "^1.18.2",
     "viem": "^2.22.16",
     "x402": "^0.6.0",