@coinbase/agentkit 0.6.2 → 0.7.1

package/dist/action-providers/twitter/twitterActionProvider.js

@@ -27,29 +27,29 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      * @param config - The configuration options for the TwitterActionProvider
      */
     constructor(config = {}) {
+        var _a, _b, _c, _d;
         super("twitter", []);
-        config.apiKey || (config.apiKey = process.env.TWITTER_API_KEY);
-        config.apiSecret || (config.apiSecret = process.env.TWITTER_API_SECRET);
-        config.accessToken || (config.accessToken = process.env.TWITTER_ACCESS_TOKEN);
-        config.accessTokenSecret || (config.accessTokenSecret = process.env.TWITTER_ACCESS_TOKEN_SECRET);
-        if (!config.apiKey) {
+        this.client = null;
+        // Store config for later use but don't initialize the client yet
+        this.config = { ...config };
+        // Set defaults from environment variables
+        (_a = this.config).apiKey || (_a.apiKey = process.env.TWITTER_API_KEY);
+        (_b = this.config).apiSecret || (_b.apiSecret = process.env.TWITTER_API_SECRET);
+        (_c = this.config).accessToken || (_c.accessToken = process.env.TWITTER_ACCESS_TOKEN);
+        (_d = this.config).accessTokenSecret || (_d.accessTokenSecret = process.env.TWITTER_ACCESS_TOKEN_SECRET);
+        // Validate config
+        if (!this.config.apiKey) {
             throw new Error("TWITTER_API_KEY is not configured.");
         }
-        if (!config.apiSecret) {
+        if (!this.config.apiSecret) {
             throw new Error("TWITTER_API_SECRET is not configured.");
         }
-        if (!config.accessToken) {
+        if (!this.config.accessToken) {
             throw new Error("TWITTER_ACCESS_TOKEN is not configured.");
         }
-        if (!config.accessTokenSecret) {
+        if (!this.config.accessTokenSecret) {
             throw new Error("TWITTER_ACCESS_TOKEN_SECRET is not configured.");
         }
-        this.client = new twitter_api_v2_1.TwitterApi({
-            appKey: config.apiKey,
-            appSecret: config.apiSecret,
-            accessToken: config.accessToken,
-            accessSecret: config.accessTokenSecret,
-        });
     }
     /**
      * Get account details for the currently authenticated Twitter (X) user.
@@ -59,7 +59,7 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async accountDetails(_) {
         try {
-            const response = await this.client.v2.me();
+            const response = await this.getClient().v2.me();
             response.data.url = `https://x.com/${response.data.username}`;
             return `Successfully retrieved authenticated user account details:\n${JSON.stringify(response)}`;
         }
@@ -75,7 +75,7 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async accountMentions(args) {
         try {
-            const response = await this.client.v2.userMentionTimeline(args.userId);
+            const response = await this.getClient().v2.userMentionTimeline(args.userId);
             return `Successfully retrieved account mentions:\n${JSON.stringify(response)}`;
         }
         catch (error) {
@@ -90,7 +90,7 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async postTweet(args) {
         try {
-            const response = await this.client.v2.tweet(args.tweet);
+            const response = await this.getClient().v2.tweet(args.tweet);
             return `Successfully posted to Twitter:\n${JSON.stringify(response)}`;
         }
         catch (error) {
@@ -105,7 +105,7 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async postTweetReply(args) {
         try {
-            const response = await this.client.v2.tweet(args.tweetReply, {
+            const response = await this.getClient().v2.tweet(args.tweetReply, {
                 reply: { in_reply_to_tweet_id: args.tweetId },
             });
             return `Successfully posted reply to Twitter:\n${JSON.stringify(response)}`;
@@ -124,6 +124,24 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
     supportsNetwork(_) {
         return true;
     }
+    /**
+     * Get the Twitter API client, initializing it if needed
+     *
+     * @returns The Twitter API client
+     */
+    getClient() {
+        if (!this.client) {
+            // Initialize client only when needed
+            const tokens = {
+                appKey: this.config.apiKey,
+                appSecret: this.config.apiSecret,
+                accessToken: this.config.accessToken,
+                accessSecret: this.config.accessTokenSecret,
+            };
+            this.client = new twitter_api_v2_1.TwitterApi(tokens);
+        }
+        return this.client;
+    }
 }
 exports.TwitterActionProvider = TwitterActionProvider;
 __decorate([

package/dist/action-providers/twitter/twitterActionProvider.test.js

@@ -44,6 +44,24 @@ describe("TwitterActionProvider", () => {
             delete process.env.TWITTER_ACCESS_TOKEN_SECRET;
             expect(() => new twitterActionProvider_1.TwitterActionProvider()).toThrow("TWITTER_API_KEY is not configured.");
         });
+        it("should implement lazy initialization", async () => {
+            // We'll check lazy initialization by observing that we can create an instance
+            // without error, and then use it to call methods successfully
+            const provider = new twitterActionProvider_1.TwitterActionProvider(MOCK_CONFIG);
+            // Mock a response for accountDetails
+            mockClient.me.mockResolvedValue({
+                data: {
+                    id: MOCK_ID,
+                    name: MOCK_NAME,
+                    username: MOCK_USERNAME,
+                },
+            });
+            // Call a method that should trigger initialization
+            const response = await provider.accountDetails({});
+            // Verify the method worked, which means initialization succeeded
+            expect(response).toContain("Successfully retrieved authenticated user account details");
+            expect(mockClient.me).toHaveBeenCalled();
+        });
     });
     describe("Account Details Action", () => {
         const mockResponse = {
@@ -182,4 +200,31 @@ describe("TwitterActionProvider", () => {
             expect(provider.supportsNetwork({ protocolFamily: "solana", networkId: "2" })).toBe(true);
         });
     });
+    describe("Next.js Integration", () => {
+        it("should work in a simulated Next.js environment", async () => {
+            // Create a clean instance of the provider
+            const provider = new twitterActionProvider_1.TwitterActionProvider(MOCK_CONFIG);
+            // Mock v2.me to test functionality
+            const mockResponse = {
+                data: {
+                    id: MOCK_ID,
+                    name: MOCK_NAME,
+                    username: MOCK_USERNAME,
+                },
+            };
+            const mockTwitterApi = {
+                v2: {
+                    me: jest.fn().mockResolvedValue(mockResponse),
+                },
+            };
+            // Override the getClient method to return our mocked API
+            jest
+                .spyOn(provider, "getClient")
+                .mockReturnValue(mockTwitterApi);
+            // Simulate a Next.js API route calling the provider
+            const result = await provider.accountDetails({});
+            expect(result).toContain("Successfully retrieved authenticated user account details");
+            expect(mockTwitterApi.v2.me).toHaveBeenCalled();
+        });
+    });
 });

package/dist/action-providers/zerodev/index.d.ts

@@ -0,0 +1 @@
+export * from "./zeroDevWalletActionProvider";

package/dist/action-providers/zerodev/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zeroDevWalletActionProvider"), exports);

package/dist/action-providers/zerodev/schemas.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * Input schema for get CAB action.
+ */
+export declare const GetCABSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"networkFilter">;
+    tokenTickers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    networks: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "networkFilter";
+    networks: number[];
+    tokenTickers?: string[] | undefined;
+}, {
+    type: "networkFilter";
+    networks: number[];
+    tokenTickers?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"networkType">;
+    tokenTickers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    networkType: z.ZodEnum<["mainnet", "testnet"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "networkType";
+    networkType: "testnet" | "mainnet";
+    tokenTickers?: string[] | undefined;
+}, {
+    type: "networkType";
+    networkType: "testnet" | "mainnet";
+    tokenTickers?: string[] | undefined;
+}>]>;

package/dist/action-providers/zerodev/schemas.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCABSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for get CAB action.
+ */
+exports.GetCABSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("networkFilter"),
+        tokenTickers: zod_1.z.array(zod_1.z.string()).optional(),
+        networks: zod_1.z.array(zod_1.z.number()).describe("The networks to get the balance for."),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("networkType"),
+        tokenTickers: zod_1.z.array(zod_1.z.string()).optional(),
+        networkType: zod_1.z
+            .enum(["mainnet", "testnet"])
+            .describe("The type of network to get the balance for."),
+    }),
+]);

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.d.ts

@@ -0,0 +1,32 @@
+import { ZeroDevWalletProvider } from "../../wallet-providers";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { GetCABSchema } from "./schemas";
+import { z } from "zod";
+/**
+ * ZeroDevWalletActionProvider is an action provider for ZeroDevWalletProvider.
+ *
+ * This provider is used for any action that requires a ZeroDevWalletProvider.
+ */
+export declare class ZeroDevWalletActionProvider extends ActionProvider<ZeroDevWalletProvider> {
+    /**
+     * Constructs a new ZeroDevWalletActionProvider.
+     */
+    constructor();
+    /**
+     * Gets the chain abstracted balance for the wallet.
+     *
+     * @param walletProvider - The wallet provider to get the balance for.
+     * @param args - The arguments for the action.
+     * @returns The chain abstracted balance for the wallet.
+     */
+    getCAB(walletProvider: ZeroDevWalletProvider, args: z.infer<typeof GetCABSchema>): Promise<import("@zerodev/intent").GetCABResult>;
+    /**
+     * Checks if the ZeroDevWalletActionProvider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the ZeroDevWalletActionProvider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const zeroDevWalletActionProvider: () => ZeroDevWalletActionProvider;

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zeroDevWalletActionProvider = exports.ZeroDevWalletActionProvider = void 0;
+const wallet_providers_1 = require("../../wallet-providers");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const zod_1 = require("zod");
+/**
+ * ZeroDevWalletActionProvider is an action provider for ZeroDevWalletProvider.
+ *
+ * This provider is used for any action that requires a ZeroDevWalletProvider.
+ */
+class ZeroDevWalletActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructs a new ZeroDevWalletActionProvider.
+     */
+    constructor() {
+        super("zeroDevWallet", []);
+        /**
+         * Checks if the ZeroDevWalletActionProvider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the ZeroDevWalletActionProvider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+    }
+    /**
+     * Gets the chain abstracted balance for the wallet.
+     *
+     * @param walletProvider - The wallet provider to get the balance for.
+     * @param args - The arguments for the action.
+     * @returns The chain abstracted balance for the wallet.
+     */
+    async getCAB(walletProvider, args) {
+        return walletProvider.getCAB(args);
+    }
+}
+exports.ZeroDevWalletActionProvider = ZeroDevWalletActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_cab",
+        description: `This tool retrieves the chain abstracted balance (CAB) for specified tokens across multiple networks. 
+It takes the following inputs:
+- tokenTickers: An array of token symbols (e.g., ["ETH", "USDC"]) to get balances for
+- networks (optional): An array of network IDs to check balances on. If not provided, will check all supported networks
+- networkType (optional): Filter networks by type ("mainnet" or "testnet"). If not provided, will check both types
+
+The tool will return the aggregated balance across all specified networks for each token ticker. This is useful for getting a complete picture of a wallet's holdings across different chains in a single call.`,
+        schema: schemas_1.GetCABSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.ZeroDevWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZeroDevWalletActionProvider.prototype, "getCAB", null);
+const zeroDevWalletActionProvider = () => new ZeroDevWalletActionProvider();
+exports.zeroDevWalletActionProvider = zeroDevWalletActionProvider;

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.test.d.ts

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

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.test.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zeroDevWalletActionProvider_1 = require("./zeroDevWalletActionProvider");
+const schemas_1 = require("./schemas");
+describe("ZeroDev Wallet Action Provider Input Schemas", () => {
+    describe("Get CAB Schema", () => {
+        it("should successfully parse valid input with network type", () => {
+            const validInput = {
+                type: "networkType",
+                tokenTickers: ["ETH", "USDC"],
+                networkType: "mainnet",
+            };
+            const result = schemas_1.GetCABSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should successfully parse valid input with network filter", () => {
+            const validInput = {
+                type: "networkFilter",
+                tokenTickers: ["ETH", "USDC"],
+                networks: [1, 8453], // ethereum and base network IDs
+            };
+            const result = schemas_1.GetCABSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should successfully parse input with optional tokenTickers omitted", () => {
+            const validInput = {
+                type: "networkType",
+                networkType: "mainnet",
+            };
+            const result = schemas_1.GetCABSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing empty input", () => {
+            const emptyInput = {};
+            const result = schemas_1.GetCABSchema.safeParse(emptyInput);
+            expect(result.success).toBe(false);
+        });
+    });
+});
+describe("ZeroDev Wallet Action Provider", () => {
+    let actionProvider;
+    let mockWallet;
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new zeroDevWalletActionProvider_1.ZeroDevWalletActionProvider();
+        mockWallet = {
+            getCAB: jest.fn(),
+            getAddress: jest.fn().mockReturnValue("0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83"),
+            getNetwork: jest.fn().mockReturnValue({ networkId: "ethereum-mainnet" }),
+        };
+    });
+    describe("getCAB", () => {
+        const MOCK_BALANCES = {
+            balance: BigInt(1000000000000000000),
+            tokenAddress: "0x1234567890123456789012345678901234567890",
+            tokens: {
+                ETH: {
+                    ethereum: "1.5",
+                    base: "0.5",
+                },
+                USDC: {
+                    ethereum: "1000",
+                    base: "500",
+                },
+            },
+        };
+        beforeEach(() => {
+            mockWallet.getCAB.mockResolvedValue(MOCK_BALANCES);
+        });
+        it("should successfully get chain abstracted balances with network type", async () => {
+            const args = {
+                type: "networkType",
+                tokenTickers: ["ETH", "USDC"],
+                networkType: "mainnet",
+            };
+            const result = await actionProvider.getCAB(mockWallet, args);
+            expect(mockWallet.getCAB).toHaveBeenCalledWith(args);
+            expect(result).toEqual(MOCK_BALANCES);
+        });
+        it("should successfully get chain abstracted balances with network filter", async () => {
+            const args = {
+                type: "networkFilter",
+                tokenTickers: ["ETH", "USDC"],
+                networks: [1, 8453], // ethereum and base network IDs
+            };
+            const result = await actionProvider.getCAB(mockWallet, args);
+            expect(mockWallet.getCAB).toHaveBeenCalledWith(args);
+            expect(result).toEqual(MOCK_BALANCES);
+        });
+        it("should handle errors when getting balances", async () => {
+            const args = {
+                type: "networkType",
+                networkType: "mainnet",
+            };
+            const error = new Error("Failed to get balances");
+            mockWallet.getCAB.mockRejectedValue(error);
+            await expect(actionProvider.getCAB(mockWallet, args)).rejects.toThrow(error);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+});

package/dist/network/svm.d.ts

@@ -3,6 +3,7 @@ export declare const SOLANA_MAINNET_NETWORK_ID = "solana-mainnet";
 export declare const SOLANA_TESTNET_NETWORK_ID = "solana-testnet";
 export declare const SOLANA_DEVNET_NETWORK_ID = "solana-devnet";
 export type SOLANA_NETWORK_ID = typeof SOLANA_MAINNET_NETWORK_ID | typeof SOLANA_TESTNET_NETWORK_ID | typeof SOLANA_DEVNET_NETWORK_ID;
+export declare const SOLANA_NETWORK_IDS: SOLANA_NETWORK_ID[];
 export declare const SOLANA_PROTOCOL_FAMILY = "svm";
 export declare const SOLANA_MAINNET_GENESIS_BLOCK_HASH = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
 export declare const SOLANA_TESTNET_GENESIS_BLOCK_HASH = "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY";

package/dist/network/svm.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOLANA_CLUSTER_ID_BY_NETWORK_ID = exports.SOLANA_NETWORKS = exports.SOLANA_DEVNET_NETWORK = exports.SOLANA_TESTNET_NETWORK = exports.SOLANA_MAINNET_NETWORK = exports.SOLANA_DEVNET_GENESIS_BLOCK_HASH = exports.SOLANA_TESTNET_GENESIS_BLOCK_HASH = exports.SOLANA_MAINNET_GENESIS_BLOCK_HASH = exports.SOLANA_PROTOCOL_FAMILY = exports.SOLANA_DEVNET_NETWORK_ID = exports.SOLANA_TESTNET_NETWORK_ID = exports.SOLANA_MAINNET_NETWORK_ID = void 0;
+exports.SOLANA_CLUSTER_ID_BY_NETWORK_ID = exports.SOLANA_NETWORKS = exports.SOLANA_DEVNET_NETWORK = exports.SOLANA_TESTNET_NETWORK = exports.SOLANA_MAINNET_NETWORK = exports.SOLANA_DEVNET_GENESIS_BLOCK_HASH = exports.SOLANA_TESTNET_GENESIS_BLOCK_HASH = exports.SOLANA_MAINNET_GENESIS_BLOCK_HASH = exports.SOLANA_PROTOCOL_FAMILY = exports.SOLANA_NETWORK_IDS = exports.SOLANA_DEVNET_NETWORK_ID = exports.SOLANA_TESTNET_NETWORK_ID = exports.SOLANA_MAINNET_NETWORK_ID = void 0;
 // CDP Network IDs
 exports.SOLANA_MAINNET_NETWORK_ID = "solana-mainnet";
 exports.SOLANA_TESTNET_NETWORK_ID = "solana-testnet";
 exports.SOLANA_DEVNET_NETWORK_ID = "solana-devnet";
+exports.SOLANA_NETWORK_IDS = [
+    exports.SOLANA_MAINNET_NETWORK_ID,
+    exports.SOLANA_TESTNET_NETWORK_ID,
+    exports.SOLANA_DEVNET_NETWORK_ID,
+];
 // AgentKit Protocol Family
 exports.SOLANA_PROTOCOL_FAMILY = "svm";
 // Chain IDs - Genesis Block Hashes

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

@@ -0,0 +1,105 @@
+import { CdpClient } from "@coinbase/cdp-sdk";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
+import { Network } from "../network";
+import { EvmWalletProvider } from "./evmWalletProvider";
+import { WalletProviderWithClient, CdpV2WalletProviderConfig } from "./cdpV2Shared";
+/**
+ * A wallet provider that uses the Coinbase SDK.
+ */
+export declare class CdpV2EvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
+    #private;
+    /**
+     * Constructs a new CdpWalletProvider.
+     *
+     * @param config - The configuration options for the CdpWalletProvider.
+     */
+    private constructor();
+    /**
+     * Configures a new CdpWalletProvider with a wallet.
+     *
+     * @param config - Optional configuration parameters
+     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @throws Error if required environment variables are missing or wallet initialization fails
+     */
+    static configureWithWallet(config?: CdpV2WalletProviderConfig): Promise<CdpV2EvmWalletProvider>;
+    /**
+     * Signs a message.
+     *
+     * @param message - The message to sign.
+     * @returns The signed message.
+     */
+    signMessage(message: string): Promise<Hex>;
+    /**
+     * Signs a typed data object.
+     *
+     * @param typedData - The typed data object to sign.
+     * @returns The signed typed data object.
+     */
+    signTypedData(typedData: any): 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>;
+    /**
+     * 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 CDP client.
+     *
+     * @returns The CDP client.
+     */
+    getClient(): CdpClient;
+    /**
+     * Gets the balance of the wallet.
+     *
+     * @returns The balance of the wallet in wei
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Waits for a transaction receipt.
+     *
+     * @param txHash - The hash of the transaction to wait for.
+     * @returns The transaction receipt.
+     */
+    waitForTransactionReceipt(txHash: Hex): Promise<any>;
+    /**
+     * Reads a contract.
+     *
+     * @param params - The parameters to read the contract.
+     * @returns The response from the contract.
+     */
+    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: Address, value: string): Promise<Hex>;
+}