@coinbase/agentkit 0.2.0 → 0.2.2-nightly.20250221.1

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
@@ -575,7 +588,7 @@ const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
 
 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).
+You can manage authorization keys from your [Privy dashboard](https://dashboard.privy.io/account).
 
 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.
 
@@ -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).
+
+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/alchemy/alchemyTokenPricesActionProvider.d.ts

@@ -44,7 +44,7 @@ export declare class AlchemyTokenPricesActionProvider extends ActionProvider {
      *
      * @returns Always returns true.
      */
-    supportsNetwork(): boolean;
+    supportsNetwork: () => boolean;
 }
 /**
  * Factory function to create a new AlchemyTokenPricesActionProvider instance.

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.js

@@ -27,6 +27,15 @@ class AlchemyTokenPricesActionProvider extends actionProvider_1.ActionProvider {
      */
     constructor(config = {}) {
         super("alchemyTokenPrices", []);
+        /**
+         * Checks if the Alchemy Prices action provider supports the given network.
+         * Since the API works with multiple networks, this always returns true.
+         *
+         * @returns Always returns true.
+         */
+        this.supportsNetwork = () => {
+            return true;
+        };
         config.apiKey || (config.apiKey = process.env.ALCHEMY_API_KEY);
         if (!config.apiKey) {
             throw new Error("ALCHEMY_API_KEY is not configured.");
@@ -91,15 +100,6 @@ class AlchemyTokenPricesActionProvider extends actionProvider_1.ActionProvider {
             return `Error fetching token prices by address: ${error}`;
         }
     }
-    /**
-     * Checks if the Alchemy Prices action provider supports the given network.
-     * Since the API works with multiple networks, this always returns true.
-     *
-     * @returns Always returns true.
-     */
-    supportsNetwork() {
-        return true;
-    }
 }
 exports.AlchemyTokenPricesActionProvider = AlchemyTokenPricesActionProvider;
 __decorate([

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.d.ts

@@ -50,9 +50,9 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
     /**
      * Checks if the Cdp action provider supports the given network.
      *
-     * @param _ - The network to check.
+     * @param network - The network to check.
      * @returns True if the Cdp action provider supports the network, false otherwise.
      */
-    supportsNetwork: (_: Network) => boolean;
+    supportsNetwork: (network: Network) => boolean;
 }
 export declare const cdpWalletActionProvider: (config?: CdpProviderConfig) => CdpWalletActionProvider;

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

@@ -33,12 +33,15 @@ class CdpWalletActionProvider extends actionProvider_1.ActionProvider {
         /**
          * Checks if the Cdp action provider supports the given network.
          *
-         * @param _ - The network to check.
+         * @param network - The network to check.
          * @returns True if the Cdp action provider supports the network, false otherwise.
          */
-        this.supportsNetwork = (_) => true;
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
         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/cdp/cdpWalletActionProvider.test.js

@@ -256,4 +256,12 @@ describe("CDP Wallet Action Provider", () => {
             expect(result).toBe(`Error trading assets: ${error}`);
         });
     });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
 });

package/dist/action-providers/erc20/erc20ActionProvider.d.ts

@@ -30,9 +30,9 @@ export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvide
     /**
      * Checks if the ERC20 action provider supports the given network.
      *
-     * @param _ - The network to check.
+     * @param network - The network to check.
      * @returns True if the ERC20 action provider supports the network, false otherwise.
      */
-    supportsNetwork: (_: Network) => boolean;
+    supportsNetwork: (network: Network) => boolean;
 }
 export declare const erc20ActionProvider: () => ERC20ActionProvider;

package/dist/action-providers/erc20/erc20ActionProvider.js

@@ -29,10 +29,10 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
         /**
          * Checks if the ERC20 action provider supports the given network.
          *
-         * @param _ - The network to check.
+         * @param network - The network to check.
          * @returns True if the ERC20 action provider supports the network, false otherwise.
          */
-        this.supportsNetwork = (_) => true;
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
     }
     /**
      * Gets the balance of an ERC20 token.

package/dist/action-providers/erc20/erc20ActionProvider.test.js

@@ -114,4 +114,12 @@ describe("Transfer Action", () => {
         });
         expect(response).toContain(`Error transferring the asset: ${error}`);
     });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
 });

package/dist/action-providers/farcaster/farcasterActionProvider.d.ts

@@ -49,9 +49,9 @@ export declare class FarcasterActionProvider extends ActionProvider {
     /**
      * Checks if the Farcaster action provider supports the given network.
      *
-     * @param _ - The network to check.
+     * @param network - The network to check.
      * @returns True if the Farcaster action provider supports the network, false otherwise.
      */
-    supportsNetwork: (_: Network) => boolean;
+    supportsNetwork: (network: Network) => boolean;
 }
 export declare const farcasterActionProvider: (config?: FarcasterActionProviderConfig) => FarcasterActionProvider;

package/dist/action-providers/farcaster/farcasterActionProvider.js

@@ -28,10 +28,10 @@ class FarcasterActionProvider extends actionProvider_1.ActionProvider {
         /**
          * Checks if the Farcaster action provider supports the given network.
          *
-         * @param _ - The network to check.
+         * @param network - The network to check.
          * @returns True if the Farcaster action provider supports the network, false otherwise.
          */
-        this.supportsNetwork = (_) => true;
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
         const neynarApiKey = config.neynarApiKey || process.env.NEYNAR_API_KEY;
         const signerUuid = config.signerUuid || process.env.NEYNAR_MANAGER_SIGNER;
         const agentFid = config.agentFid || process.env.AGENT_FID;

package/dist/action-providers/farcaster/farcasterActionProvider.test.js

@@ -140,4 +140,12 @@ describe("Farcaster Action Provider", () => {
             process.env = originalEnv;
         });
     });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
 });

package/dist/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 {};