@coinbase/agentkit 0.7.0 → 0.7.2

package/dist/action-providers/cdp-v2/cdpApiV2ActionProvider.d.ts

@@ -1,16 +1,14 @@
 import { z } from "zod";
 import { Network } from "../../network";
 import { WalletProvider } from "../../wallet-providers";
-import { WalletProviderWithClient } from "../../wallet-providers/cdpV2Shared";
 import { ActionProvider } from "../actionProvider";
 import { RequestFaucetFundsV2Schema } from "./schemas";
-type CdpV2WalletProviderWithClient = WalletProvider & WalletProviderWithClient;
 /**
  * CdpApiActionProvider is an action provider for CDP API.
  *
  * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
  */
-export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletProviderWithClient> {
+export declare class CdpApiV2ActionProvider extends ActionProvider<WalletProvider> {
     /**
      * Constructor for the CdpApiActionProvider class.
      */
@@ -22,7 +20,7 @@ export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletPr
      * @param args - The input arguments for the action.
      * @returns A confirmation message with transaction details.
      */
-    faucet(walletProvider: CdpV2WalletProviderWithClient, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
     /**
      * Checks if the Cdp action provider supports the given network.
      *
@@ -34,4 +32,3 @@ export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletPr
     supportsNetwork: (_: Network) => boolean;
 }
 export declare const cdpApiV2ActionProvider: () => CdpApiV2ActionProvider;
-export {};

package/dist/action-providers/cdp-v2/cdpApiV2ActionProvider.js

@@ -11,6 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiV2ActionProvider = exports.CdpApiV2ActionProvider = void 0;
 const zod_1 = require("zod");
+const wallet_providers_1 = require("../../wallet-providers");
+const cdpV2Shared_1 = require("../../wallet-providers/cdpV2Shared");
 const actionDecorator_1 = require("../actionDecorator");
 const actionProvider_1 = require("../actionProvider");
 const schemas_1 = require("./schemas");
@@ -45,29 +47,34 @@ class CdpApiV2ActionProvider extends actionProvider_1.ActionProvider {
     async faucet(walletProvider, args) {
         const network = walletProvider.getNetwork();
         const networkId = network.networkId;
-        if (network.protocolFamily === "evm") {
-            if (networkId !== "base-sepolia" && networkId !== "ethereum-sepolia") {
-                throw new Error("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks.");
+        if ((0, cdpV2Shared_1.isWalletProviderWithClient)(walletProvider)) {
+            if (network.protocolFamily === "evm") {
+                if (networkId !== "base-sepolia" && networkId !== "ethereum-sepolia") {
+                    throw new Error("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks.");
+                }
+                const faucetTx = await walletProvider.getClient().evm.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "eth"),
+                    network: networkId,
+                });
+                return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
             }
-            const faucetTx = await walletProvider.getClient().evm.requestFaucet({
-                address: walletProvider.getAddress(),
-                token: (args.assetId || "eth"),
-                network: networkId,
-            });
-            return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
-        }
-        else if (network.protocolFamily === "svm") {
-            if (networkId !== "solana-devnet") {
-                throw new Error("Faucet is only supported on 'solana-devnet' solana networks.");
+            else if (network.protocolFamily === "svm") {
+                if (networkId !== "solana-devnet") {
+                    throw new Error("Faucet is only supported on 'solana-devnet' solana networks.");
+                }
+                const faucetTx = await walletProvider.getClient().solana.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "sol"),
+                });
+                return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
+            }
+            else {
+                throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
             }
-            const faucetTx = await walletProvider.getClient().solana.requestFaucet({
-                address: walletProvider.getAddress(),
-                token: (args.assetId || "sol"),
-            });
-            return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
         }
         else {
-            throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
+            throw new Error("Wallet provider is not a CDP Wallet Provider.");
         }
     }
 }
@@ -84,7 +91,7 @@ from another wallet and provide the user with your wallet details.`,
         schema: schemas_1.RequestFaucetFundsV2Schema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpApiV2ActionProvider.prototype, "faucet", null);
 const cdpApiV2ActionProvider = () => new CdpApiV2ActionProvider();

package/dist/action-providers/flaunch/utils.js

@@ -313,7 +313,7 @@ const ethToMemecoin = (params) => {
     };
 };
 exports.ethToMemecoin = ethToMemecoin;
-// @notice Beofre calling the UniversalRouter the user must have:
+// @notice Before calling the UniversalRouter the user must have:
 // 1. Given the Permit2 contract allowance to spend the memecoin
 const memecoinToEthWithPermit2 = (params) => {
     const flETH = constants_1.FLETHAddress[params.chainId];

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

@@ -29,7 +29,8 @@ export interface TwitterActionProviderConfig {
  * @augments ActionProvider
  */
 export declare class TwitterActionProvider extends ActionProvider {
-    private readonly client;
+    private client;
+    private config;
     /**
      * Constructor for the TwitterActionProvider class.
      *
@@ -72,6 +73,12 @@ export declare class TwitterActionProvider extends ActionProvider {
      * @returns Always returns true as Twitter actions are network-independent
      */
     supportsNetwork(_: Network): boolean;
+    /**
+     * Get the Twitter API client, initializing it if needed
+     *
+     * @returns The Twitter API client
+     */
+    private getClient;
 }
 /**
  * Factory function to create a new TwitterActionProvider instance.

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/wallet-providers/cdpV2EvmWalletProvider.js

@@ -118,9 +118,29 @@ class CdpV2EvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @returns The hash of the transaction.
      */
     async sendTransaction(transaction) {
+        const txWithGasParams = {
+            ...transaction,
+            chainId: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_network, "f").chainId,
+        };
+        if (!txWithGasParams.maxFeePerGas && !txWithGasParams.gasPrice) {
+            const feeData = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").estimateFeesPerGas();
+            txWithGasParams.maxFeePerGas = feeData.maxFeePerGas;
+            txWithGasParams.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+        }
+        if (!txWithGasParams.gas) {
+            try {
+                txWithGasParams.gas = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").estimateGas({
+                    account: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
+                    ...txWithGasParams,
+                });
+            }
+            catch (error) {
+                console.warn("Failed to estimate gas, continuing without gas estimation", error);
+            }
+        }
         const result = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_cdp, "f").evm.sendTransaction({
             address: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
-            transaction: (0, viem_1.serializeTransaction)(transaction),
+            transaction: (0, viem_1.serializeTransaction)(txWithGasParams),
             network: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_instances, "m", _CdpV2EvmWalletProvider_getCdpSdkNetwork).call(this),
         });
         return result.transactionHash;

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

@@ -39,3 +39,10 @@ export interface WalletProviderWithClient {
      */
     getClient(): CdpClient;
 }
+/**
+ * Type guard to check if a wallet provider implements WalletProviderWithClient interface.
+ *
+ * @param provider - The provider to check
+ * @returns True if the provider implements WalletProviderWithClient
+ */
+export declare function isWalletProviderWithClient(provider: unknown): provider is WalletProviderWithClient;

package/dist/wallet-providers/cdpV2Shared.js

@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWalletProviderWithClient = isWalletProviderWithClient;
+/**
+ * Type guard to check if a wallet provider implements WalletProviderWithClient interface.
+ *
+ * @param provider - The provider to check
+ * @returns True if the provider implements WalletProviderWithClient
+ */
+function isWalletProviderWithClient(provider) {
+    return (provider !== null &&
+        typeof provider === "object" &&
+        "getClient" in provider &&
+        typeof provider.getClient === "function");
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",