@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwitterPostTweetReplySchema = exports.TwitterPostTweetSchema = exports.TwitterAccountMentionsSchema = exports.TwitterAccountDetailsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for retrieving account details.
+ */
+exports.TwitterAccountDetailsSchema = zod_1.z
+    .object({})
+    .strip()
+    .describe("Input schema for retrieving account details");
+/**
+ * Input schema for retrieving account mentions.
+ */
+exports.TwitterAccountMentionsSchema = zod_1.z
+    .object({
+    userId: zod_1.z
+        .string()
+        .min(1, "Account ID is required.")
+        .describe("The Twitter (X) user id to return mentions for"),
+})
+    .strip()
+    .describe("Input schema for retrieving account mentions");
+/**
+ * Input schema for posting a tweet.
+ */
+exports.TwitterPostTweetSchema = zod_1.z
+    .object({
+    tweet: zod_1.z.string().max(280, "Tweet must be a maximum of 280 characters."),
+})
+    .strip()
+    .describe("Input schema for posting a tweet");
+/**
+ * Input schema for posting a tweet reply.
+ */
+exports.TwitterPostTweetReplySchema = zod_1.z
+    .object({
+    tweetId: zod_1.z.string().describe("The id of the tweet to reply to"),
+    tweetReply: zod_1.z
+        .string()
+        .max(280, "The reply to the tweet which must be a maximum of 280 characters."),
+})
+    .strip()
+    .describe("Input schema for posting a tweet reply");

package/dist/action-providers/twitter/twitterActionProvider.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { TwitterAccountDetailsSchema, TwitterAccountMentionsSchema, TwitterPostTweetSchema, TwitterPostTweetReplySchema } from "./schemas";
+/**
+ * Configuration options for the TwitterActionProvider.
+ */
+export interface TwitterActionProviderConfig {
+    /**
+     * Twitter API Key
+     */
+    apiKey?: string;
+    /**
+     * Twitter API Secret
+     */
+    apiSecret?: string;
+    /**
+     * Twitter Access Token
+     */
+    accessToken?: string;
+    /**
+     * Twitter Access Token Secret
+     */
+    accessTokenSecret?: string;
+}
+/**
+ * TwitterActionProvider is an action provider for Twitter (X) interactions.
+ *
+ * @augments ActionProvider
+ */
+export declare class TwitterActionProvider extends ActionProvider {
+    private readonly client;
+    /**
+     * Constructor for the TwitterActionProvider class.
+     *
+     * @param config - The configuration options for the TwitterActionProvider
+     */
+    constructor(config?: TwitterActionProviderConfig);
+    /**
+     * Get account details for the currently authenticated Twitter (X) user.
+     *
+     * @param _ - Empty parameter object (not used)
+     * @returns A JSON string containing the account details or error message
+     */
+    accountDetails(_: z.infer<typeof TwitterAccountDetailsSchema>): Promise<string>;
+    /**
+     * Get mentions for a specified Twitter (X) user.
+     *
+     * @param args - The arguments containing userId
+     * @returns A JSON string containing the mentions or error message
+     */
+    accountMentions(args: z.infer<typeof TwitterAccountMentionsSchema>): Promise<string>;
+    /**
+     * Post a tweet on Twitter (X).
+     *
+     * @param args - The arguments containing the tweet text
+     * @returns A JSON string containing the posted tweet details or error message
+     */
+    postTweet(args: z.infer<typeof TwitterPostTweetSchema>): Promise<string>;
+    /**
+     * Post a reply to a tweet on Twitter (X).
+     *
+     * @param args - The arguments containing the reply text and tweet ID
+     * @returns A JSON string containing the posted reply details or error message
+     */
+    postTweetReply(args: z.infer<typeof TwitterPostTweetReplySchema>): Promise<string>;
+    /**
+     * Checks if the Twitter action provider supports the given network.
+     * Twitter actions don't depend on blockchain networks, so always return true.
+     *
+     * @param _ - The network to check (not used)
+     * @returns Always returns true as Twitter actions are network-independent
+     */
+    supportsNetwork(_: Network): boolean;
+}
+/**
+ * Factory function to create a new TwitterActionProvider instance.
+ *
+ * @param config - The configuration options for the TwitterActionProvider
+ * @returns A new instance of TwitterActionProvider
+ */
+export declare const twitterActionProvider: (config?: TwitterActionProviderConfig) => TwitterActionProvider;

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

@@ -0,0 +1,204 @@
+"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.twitterActionProvider = exports.TwitterActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const twitter_api_v2_1 = require("twitter-api-v2");
+const schemas_1 = require("./schemas");
+/**
+ * TwitterActionProvider is an action provider for Twitter (X) interactions.
+ *
+ * @augments ActionProvider
+ */
+class TwitterActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the TwitterActionProvider class.
+     *
+     * @param config - The configuration options for the TwitterActionProvider
+     */
+    constructor(config = {}) {
+        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) {
+            throw new Error("TWITTER_API_KEY is not configured.");
+        }
+        if (!config.apiSecret) {
+            throw new Error("TWITTER_API_SECRET is not configured.");
+        }
+        if (!config.accessToken) {
+            throw new Error("TWITTER_ACCESS_TOKEN is not configured.");
+        }
+        if (!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.
+     *
+     * @param _ - Empty parameter object (not used)
+     * @returns A JSON string containing the account details or error message
+     */
+    async accountDetails(_) {
+        try {
+            const response = await this.client.v2.me();
+            response.data.url = `https://x.com/${response.data.username}`;
+            return `Successfully retrieved authenticated user account details:\n${JSON.stringify(response)}`;
+        }
+        catch (error) {
+            return `Error retrieving authenticated user account details: ${error}`;
+        }
+    }
+    /**
+     * Get mentions for a specified Twitter (X) user.
+     *
+     * @param args - The arguments containing userId
+     * @returns A JSON string containing the mentions or error message
+     */
+    async accountMentions(args) {
+        try {
+            const response = await this.client.v2.userMentionTimeline(args.userId);
+            return `Successfully retrieved account mentions:\n${JSON.stringify(response)}`;
+        }
+        catch (error) {
+            return `Error retrieving authenticated account mentions: ${error}`;
+        }
+    }
+    /**
+     * Post a tweet on Twitter (X).
+     *
+     * @param args - The arguments containing the tweet text
+     * @returns A JSON string containing the posted tweet details or error message
+     */
+    async postTweet(args) {
+        try {
+            const response = await this.client.v2.tweet(args.tweet);
+            return `Successfully posted to Twitter:\n${JSON.stringify(response)}`;
+        }
+        catch (error) {
+            return `Error posting to Twitter:\n${error}`;
+        }
+    }
+    /**
+     * Post a reply to a tweet on Twitter (X).
+     *
+     * @param args - The arguments containing the reply text and tweet ID
+     * @returns A JSON string containing the posted reply details or error message
+     */
+    async postTweetReply(args) {
+        try {
+            const response = await this.client.v2.tweet(args.tweetReply, {
+                reply: { in_reply_to_tweet_id: args.tweetId },
+            });
+            return `Successfully posted reply to Twitter:\n${JSON.stringify(response)}`;
+        }
+        catch (error) {
+            return `Error posting reply to Twitter: ${error}`;
+        }
+    }
+    /**
+     * Checks if the Twitter action provider supports the given network.
+     * Twitter actions don't depend on blockchain networks, so always return true.
+     *
+     * @param _ - The network to check (not used)
+     * @returns Always returns true as Twitter actions are network-independent
+     */
+    supportsNetwork(_) {
+        return true;
+    }
+}
+exports.TwitterActionProvider = TwitterActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "account_details",
+        description: `
+This tool will return account details for the currently authenticated Twitter (X) user context.
+
+A successful response will return a message with the api response as a json payload:
+    {"data": {"id": "1853889445319331840", "name": "CDP AgentKit", "username": "CDPAgentKit"}}
+
+A failure response will return a message with a Twitter API request error:
+    Error retrieving authenticated user account: 429 Too Many Requests`,
+        schema: schemas_1.TwitterAccountDetailsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], TwitterActionProvider.prototype, "accountDetails", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "account_mentions",
+        description: `
+This tool will return mentions for the specified Twitter (X) user id.
+
+A successful response will return a message with the API response as a JSON payload:
+    {"data": [{"id": "1857479287504584856", "text": "@CDPAgentKit reply"}]}
+
+A failure response will return a message with the Twitter API request error:
+    Error retrieving user mentions: 429 Too Many Requests`,
+        schema: schemas_1.TwitterAccountMentionsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], TwitterActionProvider.prototype, "accountMentions", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "post_tweet",
+        description: `
+This tool will post a tweet on Twitter. The tool takes the text of the tweet as input. Tweets can be maximum 280 characters.
+
+A successful response will return a message with the API response as a JSON payload:
+    {"data": {"text": "hello, world!", "id": "0123456789012345678", "edit_history_tweet_ids": ["0123456789012345678"]}}
+
+A failure response will return a message with the Twitter API request error:
+    You are not allowed to create a Tweet with duplicate content.`,
+        schema: schemas_1.TwitterPostTweetSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], TwitterActionProvider.prototype, "postTweet", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "post_tweet_reply",
+        description: `
+This tool will post a tweet on Twitter. The tool takes the text of the tweet as input. Tweets can be maximum 280 characters.
+
+A successful response will return a message with the API response as a JSON payload:
+    {"data": {"text": "hello, world!", "id": "0123456789012345678", "edit_history_tweet_ids": ["0123456789012345678"]}}
+
+A failure response will return a message with the Twitter API request error:
+    You are not allowed to create a Tweet with duplicate content.`,
+        schema: schemas_1.TwitterPostTweetReplySchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], TwitterActionProvider.prototype, "postTweetReply", null);
+/**
+ * Factory function to create a new TwitterActionProvider instance.
+ *
+ * @param config - The configuration options for the TwitterActionProvider
+ * @returns A new instance of TwitterActionProvider
+ */
+const twitterActionProvider = (config = {}) => new TwitterActionProvider(config);
+exports.twitterActionProvider = twitterActionProvider;

package/dist/action-providers/twitter/twitterActionProvider.test.d.ts

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

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

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const twitter_api_v2_1 = require("twitter-api-v2");
+const twitterActionProvider_1 = require("./twitterActionProvider");
+const MOCK_CONFIG = {
+    apiKey: "test-api-key",
+    apiSecret: "test-api-secret",
+    accessToken: "test-access-token",
+    accessTokenSecret: "test-access-token-secret",
+};
+const MOCK_ID = "1853889445319331840";
+const MOCK_NAME = "CDP Agentkit";
+const MOCK_USERNAME = "CDPAgentkit";
+const MOCK_TWEET = "Hello, world!";
+const MOCK_TWEET_ID = "0123456789012345678";
+const MOCK_TWEET_REPLY = "Hello again!";
+describe("TwitterActionProvider", () => {
+    let mockClient;
+    let provider;
+    beforeEach(() => {
+        mockClient = {
+            me: jest.fn(),
+            userMentionTimeline: jest.fn(),
+            tweet: jest.fn(),
+        };
+        jest.spyOn(twitter_api_v2_1.TwitterApi.prototype, "v2", "get").mockReturnValue(mockClient);
+        provider = new twitterActionProvider_1.TwitterActionProvider(MOCK_CONFIG);
+    });
+    describe("Constructor", () => {
+        it("should initialize with config values", () => {
+            expect(() => new twitterActionProvider_1.TwitterActionProvider(MOCK_CONFIG)).not.toThrow();
+        });
+        it("should initialize with environment variables", () => {
+            process.env.TWITTER_API_KEY = MOCK_CONFIG.apiKey;
+            process.env.TWITTER_API_SECRET = MOCK_CONFIG.apiSecret;
+            process.env.TWITTER_ACCESS_TOKEN = MOCK_CONFIG.accessToken;
+            process.env.TWITTER_ACCESS_TOKEN_SECRET = MOCK_CONFIG.accessTokenSecret;
+            expect(() => new twitterActionProvider_1.TwitterActionProvider()).not.toThrow();
+        });
+        it("should throw error if no config or env vars", () => {
+            delete process.env.TWITTER_API_KEY;
+            delete process.env.TWITTER_API_SECRET;
+            delete process.env.TWITTER_ACCESS_TOKEN;
+            delete process.env.TWITTER_ACCESS_TOKEN_SECRET;
+            expect(() => new twitterActionProvider_1.TwitterActionProvider()).toThrow("TWITTER_API_KEY is not configured.");
+        });
+    });
+    describe("Account Details Action", () => {
+        const mockResponse = {
+            data: {
+                id: MOCK_ID,
+                name: MOCK_NAME,
+                username: MOCK_USERNAME,
+            },
+        };
+        beforeEach(() => {
+            mockClient.me.mockResolvedValue(mockResponse);
+        });
+        it("should successfully retrieve account details", async () => {
+            const response = await provider.accountDetails({});
+            expect(mockClient.me).toHaveBeenCalled();
+            expect(response).toContain("Successfully retrieved authenticated user account details");
+            expect(response).toContain(JSON.stringify({
+                ...mockResponse,
+                data: { ...mockResponse.data, url: `https://x.com/${MOCK_USERNAME}` },
+            }));
+        });
+        it("should handle errors when retrieving account details", async () => {
+            const error = new Error("An error has occurred");
+            mockClient.me.mockRejectedValue(error);
+            const response = await provider.accountDetails({});
+            expect(mockClient.me).toHaveBeenCalled();
+            expect(response).toContain("Error retrieving authenticated user account details");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("Account Mentions Action", () => {
+        const mockResponse = {
+            _realData: {
+                data: [
+                    {
+                        id: MOCK_TWEET_ID,
+                        text: "@CDPAgentkit please reply!",
+                    },
+                ],
+            },
+            data: [
+                {
+                    id: MOCK_TWEET_ID,
+                    text: "@CDPAgentkit please reply!",
+                },
+            ],
+            meta: {},
+            _endpoint: {},
+            tweets: [],
+            getItemArray: () => [],
+            refreshInstanceFromResult: () => mockResponse,
+        };
+        beforeEach(() => {
+            mockClient.userMentionTimeline.mockResolvedValue(mockResponse);
+        });
+        it("should successfully retrieve account mentions", async () => {
+            const response = await provider.accountMentions({ userId: MOCK_ID });
+            expect(mockClient.userMentionTimeline).toHaveBeenCalledWith(MOCK_ID);
+            expect(response).toContain("Successfully retrieved account mentions");
+            expect(response).toContain(JSON.stringify(mockResponse));
+        });
+        it("should handle errors when retrieving mentions", async () => {
+            const error = new Error("An error has occurred");
+            mockClient.userMentionTimeline.mockRejectedValue(error);
+            const response = await provider.accountMentions({ userId: MOCK_ID });
+            expect(mockClient.userMentionTimeline).toHaveBeenCalledWith(MOCK_ID);
+            expect(response).toContain("Error retrieving authenticated account mentions");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("Post Tweet Action", () => {
+        const mockResponse = {
+            data: {
+                id: MOCK_TWEET_ID,
+                text: MOCK_TWEET,
+                edit_history_tweet_ids: [MOCK_TWEET_ID],
+            },
+        };
+        beforeEach(() => {
+            mockClient.tweet.mockResolvedValue(mockResponse);
+        });
+        it("should successfully post a tweet", async () => {
+            const response = await provider.postTweet({ tweet: MOCK_TWEET });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET);
+            expect(response).toContain("Successfully posted to Twitter");
+            expect(response).toContain(JSON.stringify(mockResponse));
+        });
+        it("should handle errors when posting a tweet", async () => {
+            const error = new Error("An error has occurred");
+            mockClient.tweet.mockRejectedValue(error);
+            const response = await provider.postTweet({ tweet: MOCK_TWEET });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET);
+            expect(response).toContain("Error posting to Twitter");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("Post Tweet Reply Action", () => {
+        const mockResponse = {
+            data: {
+                id: MOCK_TWEET_ID,
+                text: MOCK_TWEET_REPLY,
+                edit_history_tweet_ids: [MOCK_TWEET_ID],
+            },
+        };
+        beforeEach(() => {
+            mockClient.tweet.mockResolvedValue(mockResponse);
+        });
+        it("should successfully post a tweet reply", async () => {
+            const response = await provider.postTweetReply({
+                tweetId: MOCK_TWEET_ID,
+                tweetReply: MOCK_TWEET_REPLY,
+            });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET_REPLY, {
+                reply: { in_reply_to_tweet_id: MOCK_TWEET_ID },
+            });
+            expect(response).toContain("Successfully posted reply to Twitter");
+            expect(response).toContain(JSON.stringify(mockResponse));
+        });
+        it("should handle errors when posting a tweet reply", async () => {
+            const error = new Error("An error has occurred");
+            mockClient.tweet.mockRejectedValue(error);
+            const response = await provider.postTweetReply({
+                tweetId: MOCK_TWEET_ID,
+                tweetReply: MOCK_TWEET_REPLY,
+            });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET_REPLY, {
+                reply: { in_reply_to_tweet_id: MOCK_TWEET_ID },
+            });
+            expect(response).toContain("Error posting reply to Twitter");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("Network Support", () => {
+        it("should always return true for network support", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "1" })).toBe(true);
+            expect(provider.supportsNetwork({ protocolFamily: "solana", networkId: "2" })).toBe(true);
+        });
+    });
+});

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

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

package/dist/action-providers/wallet/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("./walletActionProvider"), exports);

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+/**
+ * Schema for the get_wallet_details action.
+ * This action doesn't require any input parameters, so we use an empty object schema.
+ */
+export declare const GetWalletDetailsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Input schema for native transfer action.
+ */
+export declare const NativeTransferSchema: z.ZodObject<{
+    to: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    to: string;
+    value: string;
+}, {
+    to: string;
+    value: string;
+}>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeTransferSchema = exports.GetWalletDetailsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for the get_wallet_details action.
+ * This action doesn't require any input parameters, so we use an empty object schema.
+ */
+exports.GetWalletDetailsSchema = zod_1.z.object({});
+/**
+ * Input schema for native transfer action.
+ */
+exports.NativeTransferSchema = zod_1.z
+    .object({
+    to: zod_1.z.string().describe("The destination address to receive the funds"),
+    value: zod_1.z.string().describe("The amount to transfer in whole units e.g. 1 ETH or 0.00001 ETH"),
+})
+    .strip()
+    .describe("Instructions for transferring native tokens");

package/dist/action-providers/wallet/walletActionProvider.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { WalletProvider } from "../../wallet-providers";
+import { Network } from "../../network";
+import { NativeTransferSchema, GetWalletDetailsSchema } from "./schemas";
+/**
+ * WalletActionProvider provides actions for getting basic wallet information.
+ */
+export declare class WalletActionProvider extends ActionProvider {
+    /**
+     * Constructor for the WalletActionProvider.
+     */
+    constructor();
+    /**
+     * Gets the details of the connected wallet including address, network, and balance.
+     *
+     * @param walletProvider - The wallet provider to get the details from.
+     * @param _ - Empty args object (not used).
+     * @returns A formatted string containing the wallet details.
+     */
+    getWalletDetails(walletProvider: WalletProvider, _: z.infer<typeof GetWalletDetailsSchema>): Promise<string>;
+    /**
+     * Transfers a specified amount of native currency to a destination onchain.
+     *
+     * @param walletProvider - The wallet provider to transfer from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transfer details.
+     */
+    nativeTransfer(walletProvider: WalletProvider, args: z.infer<typeof NativeTransferSchema>): Promise<string>;
+    /**
+     * Checks if the wallet action provider supports the given network.
+     * Since wallet actions are network-agnostic, this always returns true.
+     *
+     * @param _ - The network to check.
+     * @returns True, as wallet actions are supported on all networks.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+/**
+ * Factory function to create a new WalletActionProvider instance.
+ *
+ * @returns A new WalletActionProvider instance.
+ */
+export declare const walletActionProvider: () => WalletActionProvider;