@coinbase/agentkit 0.2.0 → 0.2.2

package/README.md

@@ -34,6 +34,10 @@ AgentKit is a framework for easily enabling AI agents to take actions onchain. I
   - [SolanaKeypairWalletProvider](#solanakeypairwalletprovider)
     - [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)
 
 ## Getting Started
@@ -290,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
 
@@ -556,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
@@ -598,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`.
@@ -634,6 +650,76 @@ const rpcUrl = process.env.SOLANA_RPC_URL;
 const walletProvider = await SolanaKeypairWalletProvider.fromRpcUrl(network, privateKey);
 ```
 
+### PrivyWalletProvider (Solana)
+
+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, PrivyWalletConfig } from "@coinbase/agentkit";
+
+// Configure Wallet Provider
+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!
+    networkId: "solana-devnet", // optional, defaults to "solana-devnet"
+    walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
+    authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
+    authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
+};
+
+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, PrivyWalletConfig } from "@coinbase/agentkit";
+
+const connection = new Connection("YOUR_RPC_URL");
+
+// Configure Wallet Provider
+const config: PrivyWalletConfig = {
+    appId: "PRIVY_APP_ID",
+    appSecret: "PRIVY_APP_SECRET",
+    connection,
+    chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
+    networkId: "solana-devnet", // optional, defaults to "solana-devnet"
+    walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
+    authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
+    authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
+};
+
+const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
+```
+
+#### Authorization Keys
+
+Privy offers the option to use authorization keys to secure your server wallets.
+
+You can manage authorization keys from your [Privy dashboard](https://dashboard.privy.io/account) or programmatically [using the API](https://docs.privy.io/guide/server-wallets/authorization/signatures).
+
+When using authorization keys, you must provide the `authorizationPrivateKey` and `authorizationKeyId` parameters to the `configureWithWallet` method if you are creating a new wallet. Please note that when creating a key, if you enable "Create and modify wallets", you will be required to use that key when creating new wallets via the PrivyWalletProvider.
+
+#### Exporting Privy Wallet information
+
+The `PrivyWalletProvider` can export wallet information by calling the `exportWallet` method.
+
+```typescript
+const walletData = await walletProvider.exportWallet();
+
+// walletData will be in the following format:
+{
+    walletId: string;
+    authorizationKey: string | undefined;
+    networkId: string | undefined;
+}
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](../../CONTRIBUTING.md) for more information.

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