@coinbase/agentkit 0.2.1 → 0.2.2

package/README.md

@@ -35,6 +35,7 @@ AgentKit is a framework for easily enabling AI agents to take actions onchain. I
     - [Network Configuration](#solana-network-configuration)
     - [RPC URL Configuration](#rpc-url-configuration)
   - [PrivyWalletProvider](#privywalletprovider-solana)
+    - [Connection Configuration](#connection-configuration)
     - [Authorization Keys](#authorization-keys)
     - [Exporting Privy Wallet information](#exporting-privy-wallet-information)
 - [Contributing](#contributing)
@@ -293,6 +294,15 @@ const agent = createReactAgent({
 </tr>
 </table>
 </details>
+<details>
+<summary><strong>Jupiter</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>swap</code></td>
+    <td width="768">Swap tokens on Solana using the Jupiter DEX aggregator.</td>
+</tr>
+</table>
+</details>
 
 ## Creating an Action Provider
 
@@ -559,10 +569,10 @@ const walletProvider = new ViemWalletProvider(client, {
 The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/). This implementation extends the `ViemWalletProvider`.
 
 ```typescript
-import { PrivyWalletProvider } from "@coinbase/agentkit";
+import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
 
 // Configure Wallet Provider
-const config = {
+const config: PrivyWalletConfig = {
     appId: "PRIVY_APP_ID",
     appSecret: "PRIVY_APP_SECRET",
     chainId: "84532", // base-sepolia
@@ -601,11 +611,14 @@ const walletData = await walletProvider.exportWallet();
 
 SVM:
 - [SolanaKeypairWalletProvider](https://github.com/coinbase/agentkit/blob/main/typescript/agentkit/src/wallet-providers/solanaKeypairWalletProvider.ts)
+- [PrivyWalletProvider](https://github.com/coinbase/agentkit/blob/main/typescript/agentkit/src/wallet-providers/privySvmWalletProvider.ts)
 
 ### SolanaKeypairWalletProvider
 
 The `SolanaKeypairWalletProvider` is a wallet provider that uses the API [Solana web3.js](https://solana-labs.github.io/solana-web3.js/).
 
+NOTE: It is highly recommended to use a dedicated RPC provider. See [here](https://solana.com/rpc) for more info on Solana RPC infrastructure, and see [here](#rpc-url-configuration) for instructions on configuring `SolanaKeypairWalletProvider` with a custom RPC URL.
+
 #### Solana Network Configuration
 
 The `SolanaKeypairWalletProvider` can be configured to use a specific network by passing the `networkId` parameter to the `fromNetwork` method. The `networkId` is the ID of the Solana network you want to use. Valid values are `solana-mainnet`, `solana-devnet` and `solana-testnet`.
@@ -641,11 +654,13 @@ const walletProvider = await SolanaKeypairWalletProvider.fromRpcUrl(network, pri
 
 The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/).
 
+NOTE: It is highly recommended to use a dedicated RPC provider. See [here](https://solana.com/rpc) for more info on Solana RPC infrastructure, and see [here](#connection-configuration) for instructions on configuring `PrivyWalletProvider` with a custom RPC URL.
+
 ```typescript
-import { PrivyWalletProvider } from "@coinbase/agentkit";
+import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
 
 // Configure Wallet Provider
-const config = {
+const config: PrivyWalletConfig = {
     appId: "PRIVY_APP_ID",
     appSecret: "PRIVY_APP_SECRET",
     chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
@@ -658,15 +673,17 @@ const config = {
 const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
 ```
 
+#### Connection Configuration
+
 Optionally, you can configure your own `@solana/web3.js` connection by passing the `connection` parameter to the `configureWithWallet` method.
 
 ```typescript
-import { PrivyWalletProvider } from "@coinbase/agentkit";
+import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
 
 const connection = new Connection("YOUR_RPC_URL");
 
 // Configure Wallet Provider
-const config = {
+const config: PrivyWalletConfig = {
     appId: "PRIVY_APP_ID",
     appSecret: "PRIVY_APP_SECRET",
     connection,

package/dist/action-providers/cdp/cdpApiActionProvider.d.ts

@@ -1,14 +1,14 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { CdpProviderConfig, EvmWalletProvider } from "../../wallet-providers";
+import { CdpProviderConfig, WalletProvider } from "../../wallet-providers";
 import { AddressReputationSchema, RequestFaucetFundsSchema } from "./schemas";
 /**
  * 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 CdpApiActionProvider extends ActionProvider<EvmWalletProvider> {
+export declare class CdpApiActionProvider extends ActionProvider<WalletProvider> {
     /**
      * Constructor for the CdpApiActionProvider class.
      *
@@ -29,10 +29,12 @@ export declare class CdpApiActionProvider extends ActionProvider<EvmWalletProvid
      * @param args - The input arguments for the action.
      * @returns A confirmation message with transaction details.
      */
-    faucet(walletProvider: EvmWalletProvider, args: z.infer<typeof RequestFaucetFundsSchema>): Promise<string>;
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsSchema>): Promise<string>;
     /**
      * Checks if the Cdp action provider supports the given network.
      *
+     * NOTE: Network scoping is done at the action implementation level
+     *
      * @param _ - The network to check.
      * @returns True if the Cdp action provider supports the network, false otherwise.
      */

package/dist/action-providers/cdp/cdpApiActionProvider.js

@@ -33,6 +33,8 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
         /**
          * Checks if the Cdp action provider supports the given network.
          *
+         * NOTE: Network scoping is done at the action implementation level
+         *
          * @param _ - The network to check.
          * @returns True if the Cdp action provider supports the network, false otherwise.
          */
@@ -40,7 +42,7 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
         if (config.apiKeyName && config.apiKeyPrivateKey) {
             coinbase_sdk_1.Coinbase.configure({
                 apiKeyName: config.apiKeyName,
-                privateKey: config.apiKeyPrivateKey,
+                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });
@@ -56,6 +58,9 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
      * @returns A string containing reputation data or error message
      */
     async addressReputation(args) {
+        if (args.network.includes("solana")) {
+            return "Address reputation is only supported on Ethereum networks.";
+        }
         try {
             const address = new coinbase_sdk_1.ExternalAddress(args.network, args.address);
             const reputation = await address.reputation();
@@ -73,10 +78,14 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
      * @returns A confirmation message with transaction details.
      */
     async faucet(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        if (network.networkId !== "base-sepolia" && network.networkId !== "solana-devnet") {
+            return `Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.`;
+        }
         try {
             const address = new coinbase_sdk_1.ExternalAddress(walletProvider.getNetwork().networkId, walletProvider.getAddress());
             const faucetTx = await address.faucet(args.assetId || undefined);
-            const result = await faucetTx.wait();
+            const result = await faucetTx.wait({ timeoutSeconds: 60 });
             return `Received ${args.assetId || "ETH"} from the faucet. Transaction: ${result.getTransactionLink()}`;
         }
         catch (error) {
@@ -104,13 +113,15 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "request_faucet_funds",
         description: `This tool will request test tokens from the faucet for the default address in the wallet. It takes the wallet and asset ID as input.
-If no asset ID is provided the faucet defaults to ETH. Faucet is only allowed on 'base-sepolia' and can only provide asset ID 'eth' or 'usdc'.
+Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.
+If fauceting on 'base-sepolia', user can only provide asset ID 'eth' or 'usdc', if no asset ID is provided, the faucet will default to 'eth'.
+If fauceting on 'solana-devnet', user can only provide asset ID 'sol', if no asset ID is provided, the faucet will default to 'sol'.
 You are not allowed to faucet with any other network or asset ID. If you are on another network, suggest that the user sends you some ETH
 from another wallet and provide the user with your wallet details.`,
         schema: schemas_1.RequestFaucetFundsSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpApiActionProvider.prototype, "faucet", null);
 const cdpApiActionProvider = (config = {}) => new CdpApiActionProvider(config);

package/dist/action-providers/cdp/cdpApiActionProvider.test.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const cdpApiActionProvider_1 = require("./cdpApiActionProvider");
 const schemas_1 = require("./schemas");
-// Mock the entire module
 jest.mock("@coinbase/coinbase-sdk");
-// Get the mocked constructor
 const { ExternalAddress } = jest.requireMock("@coinbase/coinbase-sdk");
 describe("CDP API Action Provider Input Schemas", () => {
     describe("Address Reputation Schema", () => {
@@ -93,6 +91,14 @@ describe("CDP API Action Provider", () => {
             expect(mockExternalAddressInstance.reputation).toHaveBeenCalledTimes(1);
             expect(result).toBe(`Error checking address reputation: ${error}`);
         });
+        it("should return error if not on Ethereum network", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "solana-devnet",
+            };
+            const result = await actionProvider.addressReputation(args);
+            expect(result).toBe("Address reputation is only supported on Ethereum networks.");
+        });
     });
     describe("faucet", () => {
         beforeEach(() => {
@@ -130,5 +136,11 @@ describe("CDP API Action Provider", () => {
             const result = await actionProvider.faucet(mockWallet, args);
             expect(result).toBe(`Error requesting faucet funds: ${error}`);
         });
+        it("should return error if not on base-sepolia or solana-devnet", async () => {
+            mockWallet.getNetwork.mockReturnValue({ networkId: "solana-mainnet", protocolFamily: "svm" });
+            const args = {};
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(result).toBe("Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.");
+        });
     });
 });

package/dist/action-providers/cdp/cdpWalletActionProvider.js

@@ -38,7 +38,10 @@ class CdpWalletActionProvider extends actionProvider_1.ActionProvider {
          */
         this.supportsNetwork = (_) => true;
         if (config.apiKeyName && config.apiKeyPrivateKey) {
-            coinbase_sdk_1.Coinbase.configure({ apiKeyName: config.apiKeyName, privateKey: config.apiKeyPrivateKey });
+            coinbase_sdk_1.Coinbase.configure({
+                apiKeyName: config.apiKeyName,
+                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
+            });
         }
         else {
             coinbase_sdk_1.Coinbase.configureFromJson();

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

@@ -7,6 +7,7 @@ export * from "./cdp";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
+export * from "./jupiter";
 export * from "./pyth";
 export * from "./moonwell";
 export * from "./morpho";
@@ -14,3 +15,4 @@ export * from "./spl";
 export * from "./twitter";
 export * from "./wallet";
 export * from "./weth";
+export * from "./wow";

package/dist/action-providers/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./cdp"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
+__exportStar(require("./jupiter"), exports);
 __exportStar(require("./pyth"), exports);
 __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);
@@ -30,3 +31,4 @@ __exportStar(require("./spl"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./weth"), exports);
+__exportStar(require("./wow"), exports);

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

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

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

package/dist/action-providers/jupiter/jupiterActionProvider.d.ts

@@ -0,0 +1,36 @@
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { SvmWalletProvider } from "../../wallet-providers/svmWalletProvider";
+import { z } from "zod";
+import { SwapTokenSchema } from "./schemas";
+/**
+ * JupiterActionProvider handles token swaps using Jupiter's API.
+ */
+export declare class JupiterActionProvider extends ActionProvider<SvmWalletProvider> {
+    /**
+     * Initializes Jupiter API client.
+     */
+    constructor();
+    /**
+     * Swaps tokens using Jupiter's API.
+     *
+     * @param walletProvider - The wallet provider to use for the swap
+     * @param args - Swap parameters including input token, output token, and amount
+     * @returns A message indicating success or failure with transaction details
+     */
+    swap(walletProvider: SvmWalletProvider, args: z.infer<typeof SwapTokenSchema>): Promise<string>;
+    /**
+     * Checks if the action provider supports the given network.
+     * Only supports Solana networks.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is a Solana network
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new JupiterActionProvider instance.
+ *
+ * @returns A new JupiterActionProvider instance
+ */
+export declare const jupiterActionProvider: () => JupiterActionProvider;

package/dist/action-providers/jupiter/jupiterActionProvider.js

@@ -0,0 +1,115 @@
+"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.jupiterActionProvider = exports.JupiterActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const svmWalletProvider_1 = require("../../wallet-providers/svmWalletProvider");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const web3_js_1 = require("@solana/web3.js");
+const api_1 = require("@jup-ag/api");
+/**
+ * JupiterActionProvider handles token swaps using Jupiter's API.
+ */
+class JupiterActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Initializes Jupiter API client.
+     */
+    constructor() {
+        super("jupiter", []);
+    }
+    /**
+     * Swaps tokens using Jupiter's API.
+     *
+     * @param walletProvider - The wallet provider to use for the swap
+     * @param args - Swap parameters including input token, output token, and amount
+     * @returns A message indicating success or failure with transaction details
+     */
+    async swap(walletProvider, args) {
+        try {
+            const jupiterApi = (0, api_1.createJupiterApiClient)();
+            const userPublicKey = walletProvider.getPublicKey();
+            const inputMint = new web3_js_1.PublicKey(args.inputMint);
+            const outputMint = new web3_js_1.PublicKey(args.outputMint);
+            const { getMint } = await import("@solana/spl-token");
+            let mintInfo;
+            try {
+                mintInfo = await getMint(walletProvider.getConnection(), inputMint);
+            }
+            catch (error) {
+                return `Failed to fetch mint info for mint address ${args.inputMint}. Error: ${error}`;
+            }
+            const amount = args.amount * 10 ** mintInfo.decimals;
+            const quoteResponse = await jupiterApi.quoteGet({
+                inputMint: inputMint.toBase58(),
+                outputMint: outputMint.toBase58(),
+                amount: amount,
+                slippageBps: args.slippageBps || 50, // 0.5% default slippage
+            });
+            if (!quoteResponse) {
+                throw new Error("Failed to get a swap quote.");
+            }
+            const swapRequest = {
+                userPublicKey: userPublicKey.toBase58(),
+                wrapAndUnwrapSol: true,
+                useSharedAccounts: true, // Optimize for low transaction costs
+                quoteResponse,
+            };
+            const swapResponse = await jupiterApi.swapPost({ swapRequest });
+            if (!swapResponse || !swapResponse.swapTransaction) {
+                throw new Error("Failed to generate swap transaction.");
+            }
+            const transactionBuffer = Buffer.from(swapResponse.swapTransaction, "base64");
+            const tx = web3_js_1.VersionedTransaction.deserialize(transactionBuffer);
+            const signature = await walletProvider.signAndSendTransaction(tx);
+            await walletProvider.waitForSignatureResult(signature);
+            return `Successfully swapped ${args.amount} tokens! Signature: ${signature}`;
+        }
+        catch (error) {
+            return `Error swapping tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks if the action provider supports the given network.
+     * Only supports Solana networks.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is a Solana network
+     */
+    supportsNetwork(network) {
+        return network.protocolFamily == "svm" && network.networkId === "solana-mainnet";
+    }
+}
+exports.JupiterActionProvider = JupiterActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "swap",
+        description: `
+    Swaps tokens using Jupiter's DEX aggregator.
+    - Input and output tokens must be valid SPL token mints.
+    - Ensures sufficient balance before executing swap.
+    - If says "SOL" as the input or output, use the mint address So11111111111111111111111111111111111111112
+    NOTE: Only available on Solana mainnet.
+    `,
+        schema: schemas_1.SwapTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [svmWalletProvider_1.SvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], JupiterActionProvider.prototype, "swap", null);
+/**
+ * Factory function to create a new JupiterActionProvider instance.
+ *
+ * @returns A new JupiterActionProvider instance
+ */
+const jupiterActionProvider = () => new JupiterActionProvider();
+exports.jupiterActionProvider = jupiterActionProvider;

package/dist/action-providers/jupiter/jupiterActionProvider.test.d.ts

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

package/dist/action-providers/jupiter/jupiterActionProvider.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const jupiterActionProvider_1 = require("./jupiterActionProvider");
+const api_1 = require("@jup-ag/api");
+// Default SPL token decimals for tests
+const DECIMALS = 6;
+// Mock the @solana/web3.js module
+jest.mock("@solana/web3.js", () => ({
+    // Preserve the actual implementation of @solana/web3.js while overriding specific methods
+    ...jest.requireActual("@solana/web3.js"),
+    // Mock the Solana Connection class to prevent real network calls
+    Connection: jest.fn(),
+    // Mock the VersionedTransaction class and its deserialize method
+    VersionedTransaction: {
+        deserialize: jest.fn().mockReturnValue({
+            // Mock the sign method to prevent actual signing operations
+            sign: jest.fn(),
+        }),
+    },
+    // Mock the MessageV0 class and its compile method to return an empty object
+    MessageV0: {
+        compile: jest.fn().mockReturnValue({}),
+    },
+}));
+// Mock the @solana/spl-token module
+jest.mock("@solana/spl-token", () => ({
+    // Preserve the actual implementation of @solana/spl-token while overriding specific methods
+    ...jest.requireActual("@solana/spl-token"),
+    // Mock getMint to always return a fixed decimal value for tokens
+    getMint: jest.fn().mockReturnValue({ decimals: DECIMALS }),
+}));
+// Mock the @jup-ag/api module
+jest.mock("@jup-ag/api", () => ({
+    // Mock the createJupiterApiClient function to return an object with mocked methods
+    createJupiterApiClient: jest.fn().mockReturnValue({
+        // Mock the quoteGet method, which fetches the best swap route
+        quoteGet: jest.fn(),
+        // Mock the swapPost method, which generates the swap transaction
+        swapPost: jest.fn(),
+    }),
+}));
+// Mock the custom wallet provider used for Solana transactions
+jest.mock("../../wallet-providers/svmWalletProvider");
+describe("JupiterActionProvider", () => {
+    let actionProvider;
+    let mockWallet;
+    let mockConnection;
+    let mockJupiterApi;
+    let mockQuoteGet;
+    let mockSwapPost;
+    beforeEach(() => {
+        jest.clearAllMocks(); // Reset mocks before each test to ensure no test interference
+        // Create a mock Jupiter API client with mocked methods
+        mockJupiterApi = (0, api_1.createJupiterApiClient)();
+        mockQuoteGet = mockJupiterApi.quoteGet;
+        mockSwapPost = mockJupiterApi.swapPost;
+        // Initialize the action provider
+        actionProvider = new jupiterActionProvider_1.JupiterActionProvider();
+        // Mock the Solana connection to avoid real network requests
+        mockConnection = {
+            getLatestBlockhash: jest.fn().mockResolvedValue({ blockhash: "mockedBlockhash" }),
+        };
+        // Mock the wallet provider with necessary methods
+        mockWallet = {
+            getConnection: jest.fn().mockReturnValue(mockConnection), // Return the mocked connection
+            getPublicKey: jest.fn().mockReturnValue(new web3_js_1.PublicKey("11111111111111111111111111111111")),
+            signAndSendTransaction: jest.fn().mockResolvedValue("mock-signature"),
+            waitForSignatureResult: jest.fn().mockResolvedValue({
+                context: { slot: 1234 },
+                value: { err: null },
+            }),
+            getAddress: jest.fn().mockReturnValue("11111111111111111111111111111111"),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "svm", networkId: "solana-mainnet" }),
+            getName: jest.fn().mockReturnValue("mock-wallet"),
+            getBalance: jest.fn().mockResolvedValue(BigInt(1000000000)),
+            nativeTransfer: jest.fn(),
+        };
+    });
+    /**
+     * Test cases for the swap function of JupiterActionProvider
+     */
+    describe("swap", () => {
+        const INPUT_MINT = "So11111111111111111111111111111111111111112"; // Mock SOL mint address
+        const OUTPUT_MINT = "BXXkv6FbfHZmKbMmy6KvaakKt6bYjhbjmhvJ92kp92Mw"; // Mock token mint address
+        const MOCK_SIGNATURE = "mock-signature";
+        // Mock arguments for swapping tokens
+        const swapArgs = {
+            inputMint: INPUT_MINT,
+            outputMint: OUTPUT_MINT,
+            amount: 1000, // User-specified amount
+            slippageBps: 50, // Slippage tolerance
+        };
+        /**
+         * Test successful token swap execution
+         */
+        it("should successfully swap tokens", async () => {
+            // Mock a successful quote response from Jupiter
+            mockQuoteGet.mockResolvedValue({ route: "mock-route" });
+            // Mock a successful swap transaction response from Jupiter
+            mockSwapPost.mockResolvedValue({
+                swapTransaction: Buffer.from("mock-transaction").toString("base64"),
+            });
+            // Call the swap function
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            // Verify that Jupiter was called with correct parameters
+            expect(mockQuoteGet).toHaveBeenCalledWith({
+                inputMint: INPUT_MINT,
+                outputMint: OUTPUT_MINT,
+                amount: swapArgs.amount * 10 ** DECIMALS, // Ensure correct decimal conversion
+                slippageBps: swapArgs.slippageBps,
+            });
+            expect(mockSwapPost).toHaveBeenCalled();
+            expect(mockWallet.waitForSignatureResult).toHaveBeenCalledWith(MOCK_SIGNATURE);
+            expect(result).toContain("Successfully swapped");
+        });
+        /**
+         * Test handling of errors when retrieving a swap quote
+         */
+        it("should handle swap quote errors", async () => {
+            mockQuoteGet.mockRejectedValue(new Error("Quote error")); // Simulate an API failure
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            expect(result).toBe("Error swapping tokens: Error: Quote error");
+        });
+        /**
+         * Test handling of errors when posting a swap transaction
+         */
+        it("should handle swap transaction errors", async () => {
+            mockQuoteGet.mockResolvedValue({ route: "mock-route" });
+            mockSwapPost.mockRejectedValue(new Error("Swap transaction error")); // Simulate a failure
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            expect(result).toBe("Error swapping tokens: Error: Swap transaction error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        test.each([
+            [{ protocolFamily: "svm", networkId: "solana-mainnet" }, true, "solana mainnet"],
+            [{ protocolFamily: "svm", networkId: "solana-devnet" }, false, "solana devnet"],
+            [{ protocolFamily: "evm", networkId: "ethereum-mainnet" }, false, "ethereum mainnet"],
+            [{ protocolFamily: "evm", networkId: "solana-mainnet" }, false, "wrong protocol family"],
+            [{ protocolFamily: "svm", networkId: "ethereum-mainnet" }, false, "wrong network id"],
+        ])("should return %p for %s", (network, expected) => {
+            expect(actionProvider.supportsNetwork(network)).toBe(expected);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+/**
+ * Schema for swapping tokens using Jupiter.
+ */
+export declare const SwapTokenSchema: z.ZodObject<{
+    inputMint: z.ZodString;
+    outputMint: z.ZodString;
+    amount: z.ZodNumber;
+    slippageBps: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    inputMint: string;
+    outputMint: string;
+    slippageBps: number;
+}, {
+    amount: number;
+    inputMint: string;
+    outputMint: string;
+    slippageBps?: number | undefined;
+}>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for swapping tokens using Jupiter.
+ */
+exports.SwapTokenSchema = zod_1.z
+    .object({
+    inputMint: zod_1.z.string().describe("The mint address of the token to swap from"),
+    outputMint: zod_1.z.string().describe("The mint address of the token to swap to"),
+    amount: zod_1.z.number().positive().describe("Amount of tokens to swap"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .default(50)
+        .describe("Slippage tolerance in basis points (e.g., 50 = 0.5%)"),
+})
+    .describe("Swap tokens using Jupiter DEX aggregator");

package/dist/action-providers/spl/splActionProvider.js

@@ -36,22 +36,29 @@ class SplActionProvider extends actionProvider_1.ActionProvider {
      */
     async getBalance(walletProvider, args) {
         try {
+            if (!args.address) {
+                args.address = walletProvider.getAddress();
+            }
             const connection = walletProvider.getConnection();
             const mintPubkey = new web3_js_1.PublicKey(args.mintAddress);
-            const ownerPubkey = args.address
-                ? new web3_js_1.PublicKey(args.address)
-                : walletProvider.getPublicKey();
-            const { getMint, getAssociatedTokenAddress, getAccount } = await import("@solana/spl-token");
-            const mintInfo = await getMint(connection, mintPubkey);
-            const ata = await getAssociatedTokenAddress(mintPubkey, ownerPubkey);
+            const ownerPubkey = new web3_js_1.PublicKey(args.address);
+            const { getMint, getAssociatedTokenAddress, getAccount, TokenAccountNotFoundError } = await import("@solana/spl-token");
+            let mintInfo;
+            try {
+                mintInfo = await getMint(connection, mintPubkey);
+            }
+            catch (error) {
+                return `Failed to fetch mint info for mint address ${args.mintAddress}. Error: ${error}`;
+            }
             try {
+                const ata = await getAssociatedTokenAddress(mintPubkey, ownerPubkey);
                 const account = await getAccount(connection, ata);
                 const balance = Number(account.amount) / Math.pow(10, mintInfo.decimals);
-                return `Balance for ${args.address || "connected wallet"} is ${balance} tokens`;
+                return `Balance for ${args.address} is ${balance} tokens`;
             }
             catch (error) {
-                if (error.message.includes("could not find account")) {
-                    return `Balance for ${args.address || "connected wallet"} is 0 tokens`;
+                if (error instanceof TokenAccountNotFoundError) {
+                    return `Balance for ${args.address} is 0 tokens`;
                 }
                 throw error;
             }
@@ -74,7 +81,13 @@ class SplActionProvider extends actionProvider_1.ActionProvider {
             const toPubkey = new web3_js_1.PublicKey(args.recipient);
             const mintPubkey = new web3_js_1.PublicKey(args.mintAddress);
             const { getMint, getAssociatedTokenAddress, getAccount, createAssociatedTokenAccountInstruction, createTransferCheckedInstruction, } = await import("@solana/spl-token");
-            const mintInfo = await getMint(connection, mintPubkey);
+            let mintInfo;
+            try {
+                mintInfo = await getMint(connection, mintPubkey);
+            }
+            catch (error) {
+                return `Failed to fetch mint info for mint address ${args.mintAddress}. Error: ${error}`;
+            }
             const adjustedAmount = args.amount * Math.pow(10, mintInfo.decimals);
             const sourceAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
             const destinationAta = await getAssociatedTokenAddress(mintPubkey, toPubkey);

package/dist/action-providers/spl/splActionProvider.test.js

@@ -16,13 +16,30 @@ jest.mock("@solana/web3.js", () => ({
         compile: jest.fn().mockReturnValue({}),
     },
 }));
-jest.mock("@solana/spl-token", () => ({
-    getAssociatedTokenAddress: jest.fn(),
-    getMint: jest.fn(),
-    getAccount: jest.fn(),
-    createAssociatedTokenAccountInstruction: jest.fn(),
-    createTransferCheckedInstruction: jest.fn(),
-}));
+jest.mock("@solana/spl-token", () => {
+    /**
+     * Custom error class for token account not found scenarios.
+     * Used to simulate cases where a token account doesn't exist.
+     */
+    class TokenAccountNotFoundError extends Error {
+        /**
+         * Creates a new TokenAccountNotFoundError instance.
+         * Sets the error message and name to identify token account not found scenarios.
+         */
+        constructor() {
+            super("Token account not found");
+            this.name = "TokenAccountNotFoundError";
+        }
+    }
+    return {
+        getAssociatedTokenAddress: jest.fn(),
+        getMint: jest.fn(),
+        getAccount: jest.fn(),
+        createAssociatedTokenAccountInstruction: jest.fn(),
+        createTransferCheckedInstruction: jest.fn(),
+        TokenAccountNotFoundError,
+    };
+});
 jest.mock("../../wallet-providers/svmWalletProvider");
 describe("SplActionProvider", () => {
     let actionProvider;
@@ -203,6 +220,9 @@ describe("SplActionProvider", () => {
             expect(result).toContain(`Successfully transferred ${transferArgs.amount} tokens`);
         });
     });
+    /**
+     * Tests for the getBalance method
+     */
     describe("getBalance", () => {
         const MINT_ADDRESS = "So11111111111111111111111111111111111111112";
         const TARGET_ADDRESS = "DjXsn34uz8yCBQ8bevLrEPYYC1RvhHvjzuVF8opNc4K2";
@@ -232,14 +252,22 @@ describe("SplActionProvider", () => {
             mockWallet.getPublicKey.mockReturnValue(new web3_js_1.PublicKey(SENDER_ADDRESS));
             mockWallet.getAddress.mockReturnValue(SENDER_ADDRESS);
         });
+        /**
+         * Tests that getBalance returns the correct balance for the connected wallet
+         * when no specific address is provided.
+         */
         it("should get balance for connected wallet", async () => {
             mockGetAccount.mockResolvedValue(mockTokenAccount);
             const result = await actionProvider.getBalance(mockWallet, balanceArgs);
             expect(mockGetAssociatedTokenAddress).toHaveBeenCalledWith(new web3_js_1.PublicKey(balanceArgs.mintAddress), new web3_js_1.PublicKey(SENDER_ADDRESS));
             expect(mockGetMint).toHaveBeenCalledWith(mockConnection, new web3_js_1.PublicKey(balanceArgs.mintAddress));
             expect(mockGetAccount).toHaveBeenCalled();
-            expect(result).toBe("Balance for connected wallet is 1000 tokens");
+            expect(result).toBe(`Balance for ${SENDER_ADDRESS} is 1000 tokens`);
         });
+        /**
+         * Tests that getBalance returns the correct balance when a specific
+         * address is provided in the arguments.
+         */
         it("should get balance for specified address", async () => {
             mockGetAccount.mockResolvedValue(mockTokenAccount);
             const result = await actionProvider.getBalance(mockWallet, balanceWithAddressArgs);
@@ -248,11 +276,20 @@ describe("SplActionProvider", () => {
             expect(mockGetAccount).toHaveBeenCalled();
             expect(result).toBe(`Balance for ${TARGET_ADDRESS} is 1000 tokens`);
         });
+        /**
+         * Tests that getBalance correctly handles the case where a token account
+         * does not exist, returning a zero balance instead of an error.
+         */
         it("should handle non-existent token account", async () => {
-            mockGetAccount.mockRejectedValue(new Error("could not find account"));
+            const { TokenAccountNotFoundError } = jest.requireMock("@solana/spl-token");
+            mockGetAccount.mockRejectedValue(new TokenAccountNotFoundError());
             const result = await actionProvider.getBalance(mockWallet, balanceArgs);
-            expect(result).toBe("Balance for connected wallet is 0 tokens");
+            expect(result).toBe(`Balance for ${SENDER_ADDRESS} is 0 tokens`);
         });
+        /**
+         * Tests that getBalance properly handles and reports unexpected errors
+         * that occur during the balance check.
+         */
         it("should handle errors", async () => {
             const error = new Error("Test error");
             mockGetAccount.mockRejectedValue(error);

package/dist/action-providers/wow/constants.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GENERIC_TOKEN_METADATA_URI = exports.ADDRESSES = exports.WOW_FACTORY_CONTRACT_ADDRESSES = exports.WOW_ABI = exports.WOW_FACTORY_ABI = exports.SUPPORTED_NETWORKS = void 0;
 exports.getFactoryAddress = getFactoryAddress;
-exports.SUPPORTED_NETWORKS = ["base-mainnet"];
+exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 exports.WOW_FACTORY_ABI = [
     {
         type: "constructor",

package/dist/action-providers/wow/wowActionProvider.d.ts

@@ -14,11 +14,11 @@ export declare class WowActionProvider extends ActionProvider<EvmWalletProvider>
     /**
      * Buys a Zora Wow ERC20 memecoin with ETH.
      *
-     * @param wallet - The wallet to create the token from.
+     * @param walletProvider - The wallet to create the token from.
      * @param args - The input arguments for the action.
      * @returns A message containing the token purchase details.
      */
-    buyToken(wallet: EvmWalletProvider, args: z.infer<typeof WowBuyTokenInput>): Promise<string>;
+    buyToken(walletProvider: EvmWalletProvider, args: z.infer<typeof WowBuyTokenInput>): Promise<string>;
     /**
      * Creates a Zora Wow ERC20 memecoin.
      *
@@ -30,11 +30,11 @@ export declare class WowActionProvider extends ActionProvider<EvmWalletProvider>
     /**
      * Sells WOW tokens for ETH.
      *
-     * @param wallet - The wallet to sell the tokens from.
+     * @param walletProvider - The wallet to sell the tokens from.
      * @param args - The input arguments for the action.
      * @returns A message confirming the sale with the transaction hash.
      */
-    sellToken(wallet: EvmWalletProvider, args: z.infer<typeof WowSellTokenInput>): Promise<string>;
+    sellToken(walletProvider: EvmWalletProvider, args: z.infer<typeof WowSellTokenInput>): Promise<string>;
     /**
      * Checks if the Wow action provider supports the given network.
      *

package/dist/action-providers/wow/wowActionProvider.js

@@ -39,22 +39,22 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
     /**
      * Buys a Zora Wow ERC20 memecoin with ETH.
      *
-     * @param wallet - The wallet to create the token from.
+     * @param walletProvider - The wallet to create the token from.
      * @param args - The input arguments for the action.
      * @returns A message containing the token purchase details.
      */
-    async buyToken(wallet, args) {
+    async buyToken(walletProvider, args) {
         try {
-            const tokenQuote = await (0, utils_1.getBuyQuote)(wallet, args.contractAddress, args.amountEthInWei);
+            const tokenQuote = await (0, utils_1.getBuyQuote)(walletProvider, args.contractAddress, args.amountEthInWei);
             // Multiply by 99/100 and floor to get 99% of quote as minimum
             const minTokens = BigInt(Math.floor(Number(tokenQuote) * 99)) / BigInt(100);
-            const hasGraduated = await (0, utils_2.getHasGraduated)(wallet, args.contractAddress);
+            const hasGraduated = await (0, utils_2.getHasGraduated)(walletProvider, args.contractAddress);
             const data = (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WOW_ABI,
                 functionName: "buy",
                 args: [
-                    wallet.getAddress(),
-                    wallet.getAddress(),
+                    walletProvider.getAddress(),
+                    walletProvider.getAddress(),
                     "0x0000000000000000000000000000000000000000",
                     "",
                     hasGraduated ? 1n : 0n,
@@ -62,13 +62,13 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
                     0n,
                 ],
             });
-            const txHash = await wallet.sendTransaction({
+            const txHash = await walletProvider.sendTransaction({
                 to: args.contractAddress,
                 data,
                 value: BigInt(args.amountEthInWei),
             });
-            const receipt = await wallet.waitForTransactionReceipt(txHash);
-            return `Purchased WoW ERC20 memecoin with transaction hash: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+            await walletProvider.waitForTransactionReceipt(txHash);
+            return `Purchased WoW ERC20 memecoin with transaction hash: ${txHash}`;
         }
         catch (error) {
             return `Error buying Zora Wow ERC20 memecoin: ${error}`;
@@ -99,8 +99,8 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
                 to: factoryAddress,
                 data,
             });
-            const receipt = await wallet.waitForTransactionReceipt(txHash);
-            return `Created WoW ERC20 memecoin ${args.name} with symbol ${args.symbol} on network ${wallet.getNetwork().networkId}.\nTransaction hash for the token creation: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+            await wallet.waitForTransactionReceipt(txHash);
+            return `Created WoW ERC20 memecoin ${args.name} with symbol ${args.symbol} on network ${wallet.getNetwork().networkId}.\nTransaction hash: ${txHash}`;
         }
         catch (error) {
             return `Error creating Zora Wow ERC20 memecoin: ${error}`;
@@ -109,14 +109,14 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
     /**
      * Sells WOW tokens for ETH.
      *
-     * @param wallet - The wallet to sell the tokens from.
+     * @param walletProvider - The wallet to sell the tokens from.
      * @param args - The input arguments for the action.
      * @returns A message confirming the sale with the transaction hash.
      */
-    async sellToken(wallet, args) {
+    async sellToken(walletProvider, args) {
         try {
-            const ethQuote = await (0, utils_1.getSellQuote)(wallet, args.contractAddress, args.amountTokensInWei);
-            const hasGraduated = await (0, utils_2.getHasGraduated)(wallet, args.contractAddress);
+            const ethQuote = await (0, utils_1.getSellQuote)(walletProvider, args.contractAddress, args.amountTokensInWei);
+            const hasGraduated = await (0, utils_2.getHasGraduated)(walletProvider, args.contractAddress);
             // Multiply by 98/100 and floor to get 98% of quote as minimum
             const minEth = BigInt(Math.floor(Number(ethQuote) * 98)) / BigInt(100);
             const data = (0, viem_1.encodeFunctionData)({
@@ -124,7 +124,7 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
                 functionName: "sell",
                 args: [
                     BigInt(args.amountTokensInWei),
-                    wallet.getAddress(),
+                    walletProvider.getAddress(),
                     "0x0000000000000000000000000000000000000000",
                     "",
                     hasGraduated ? 1n : 0n,
@@ -132,12 +132,12 @@ class WowActionProvider extends actionProvider_1.ActionProvider {
                     0n,
                 ],
             });
-            const txHash = await wallet.sendTransaction({
+            const txHash = await walletProvider.sendTransaction({
                 to: args.contractAddress,
                 data,
             });
-            const receipt = await wallet.waitForTransactionReceipt(txHash);
-            return `Sold WoW ERC20 memecoin with transaction hash: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+            await walletProvider.waitForTransactionReceipt(txHash);
+            return `Sold WoW ERC20 memecoin with transaction hash: ${txHash}`;
         }
         catch (error) {
             return `Error selling Zora Wow ERC20 memecoin: ${error}`;

package/dist/action-providers/wow/wowActionProvider.test.js

@@ -142,13 +142,17 @@ describe("WowActionProvider", () => {
         });
     });
     describe("supportsNetwork", () => {
-        it("should return true for supported networks", () => {
-            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-mainnet" })).toBe(true);
-        });
-        it("should return false for unsupported networks", () => {
-            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-sepolia" })).toBe(false);
-            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "ethereum" })).toBe(false);
-            expect(provider.supportsNetwork({ protocolFamily: "bitcoin", networkId: "base-mainnet" })).toBe(false);
+        const testCases = [
+            { network: { protocolFamily: "evm", networkId: "base-mainnet" }, expected: true },
+            { network: { protocolFamily: "evm", networkId: "base-sepolia" }, expected: true },
+            { network: { protocolFamily: "evm", networkId: "ethereum" }, expected: false },
+            { network: { protocolFamily: "evm", networkId: "optimism" }, expected: false },
+            { network: { protocolFamily: "bitcoin", networkId: "base-mainnet" }, expected: false },
+        ];
+        testCases.forEach(({ network, expected }) => {
+            it(`should ${expected ? "support" : "not support"} ${network.protocolFamily}/${network.networkId}`, () => {
+                expect(provider.supportsNetwork(network)).toBe(expected);
+            });
         });
     });
     describe("buyToken", () => {
@@ -186,7 +190,7 @@ describe("WowActionProvider", () => {
             const error = new Error("Buy failed");
             mockWallet.sendTransaction.mockRejectedValue(error);
             const response = await provider.buyToken(mockWallet, args);
-            expect(response).toContain(`Error buying Zora Wow ERC20 memecoin: ${error}`);
+            expect(response).toBe(`Error buying Zora Wow ERC20 memecoin: ${error}`);
         });
     });
     describe("createToken", () => {
@@ -244,7 +248,7 @@ describe("WowActionProvider", () => {
             const error = new Error("Create failed");
             mockWallet.sendTransaction.mockRejectedValue(error);
             const response = await provider.createToken(mockWallet, args);
-            expect(response).toContain(`Error creating Zora Wow ERC20 memecoin: ${error}`);
+            expect(response).toBe(`Error creating Zora Wow ERC20 memecoin: ${error}`);
         });
     });
     describe("sellToken", () => {
@@ -281,7 +285,7 @@ describe("WowActionProvider", () => {
             const error = new Error("Sell failed");
             mockWallet.sendTransaction.mockRejectedValue(error);
             const response = await provider.sellToken(mockWallet, args);
-            expect(response).toContain(`Error selling Zora Wow ERC20 memecoin: ${error}`);
+            expect(response).toBe(`Error selling Zora Wow ERC20 memecoin: ${error}`);
         });
     });
 });

package/dist/analytics/sendAnalyticsEvent.js

@@ -22,6 +22,7 @@ async function sendAnalyticsEvent(event) {
             platform: "server",
             project_name: "agentkit",
             time_start: timestamp,
+            agentkit_language: "typescript",
             ...event,
         },
     };

package/dist/wallet-providers/cdpWalletProvider.js

@@ -58,7 +58,7 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         if (config.apiKeyName && config.apiKeyPrivateKey) {
             coinbase_sdk_1.Coinbase.configure({
                 apiKeyName: config.apiKeyName,
-                privateKey: config.apiKeyPrivateKey,
+                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -40,6 +40,7 @@
   ],
   "dependencies": {
     "@coinbase/coinbase-sdk": "^0.17.0",
+    "@jup-ag/api": "^6.0.39",
     "@privy-io/server-auth": "^1.18.4",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",