Feature/add spltoken2022 (#314)

# Pull Request Description

## Related Issue
Feature Suggestion
[#274](#274)

## Changes Made
This PR adds the following changes:

Add a function to create a token based on the SPL Token 2022 Program.
The current implementation takes name, symbol, uri, decimal (optional),
and initialSupply (optional) as parameters to create an SPL Token 2022.
  
## Implementation Details
This PR includes the implementation of a basic SPL Token 2022 creation.
Users can create a token based on the SPL Token 2022 library by
providing name, symbol, uri, decimal (optional), and initialSupply
(optional) as parameters.

The basic implementation is similar to deployToken, but to implement the
minting function based on initialSupply, I have added a method to obtain
the PDA using findAssociatedTokenPda from the
@metaplex-foundation/mpl-toolbox library.

In the code that generates tokens using Metaplex, we used
TOKEN_2022_PROGRAM_ID, which is defined as a constant in the
@solana/spl-token library.

To distinguish it from the standard deployToken, we explicitly added
2022 to the action in deployToken2022.

## Transaction executed by agent 
- [View Tranaction on
Solscan](https://solscan.io/tx/iHt6MDYspeey64R7d53cC31E1crJ8QSqEUTaogXWz7yyHCJspP9wkqmBvdDHhMpYD3YzavnZdmLarF1cRdL9Xnp?cluster=devnet)

## Prompt Used
```typescript
const userPrompt = `
  Deploy SPL Token 2022 to Solana blockchain using Solana Agent Kit.

  Here is the required information:

  Token Name: "Test Token 2022"
  Token Symbol: "TEST22"
  Token Decimals: 9
  Token URI: https://media1.giphy.com/media/l1KVboXQeiaX7FHgI/200.webp?cid=790b7611povvf63fxibbudqw20p4e8qfxs1dxunbk1qa3n89&ep=v1_gifs_search&rid=200.webp&ct=g
  Initial Supply: 1000000

  After deploying the token 2022, provide the token address.
`;
```

## Checklist
- [x] I have tested these changes locally
- [x] I have updated the documentation
- [x] I have added a transaction link
- [x] I have added the prompt used to test it

Author: thearyanag

README.md

@@ -151,6 +151,27 @@ const result = await agent.deployToken(
 console.log("Token Mint Address:", result.mint.toString());
 ```
 
+### Deploy a New Token2022
+
+```typescript
+const result = await agent.delpoyToken2022(
+  "my ai token 2022", // name
+  "uri", // uri
+  "token2022", // symbol
+  9, // decimals
+  {
+    mintAuthority: null, // by default, deployer account
+    freezeAuthority: null, // by default, deployer account
+    updateAuthority: undefined, // by default, deployer account
+    isMutable: false // by default, true
+  },
+  1000000 // initial supply
+);
+
+console.log("Token2022 Mint Address:", result.mint.toString());
+```
+
+
 
 ### Get all supported chains using Wormhole
 ```typescript

src/actions/index.ts

@@ -1,5 +1,6 @@
 import tokenBalancesAction from "./tokenBalances";
 import deployTokenAction from "./metaplex/deployToken";
+import deployToken2022Action from "./metaplex/deployToken2022";
 import balanceAction from "./solana/balance";
 import transferAction from "./solana/transfer";
 import deployCollectionAction from "./metaplex/deployCollection";
@@ -127,6 +128,7 @@ export const ACTIONS = {
   WALLET_ADDRESS_ACTION: getWalletAddressAction,
   TOKEN_BALANCES_ACTION: tokenBalancesAction,
   DEPLOY_TOKEN_ACTION: deployTokenAction,
+  DEPLOY_TOKEN2022_ACTION: deployToken2022Action,
   BALANCE_ACTION: balanceAction,
   TRANSFER_ACTION: transferAction,
   DEPLOY_COLLECTION_ACTION: deployCollectionAction,

src/actions/metaplex/deployToken2022.ts

@@ -0,0 +1,83 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { deploy_token2022 } from "../../tools";
+
+const deployToken2022Action: Action = {
+  name: "DEPLOY_TOKEN_2022",
+  similes: [
+    "create token2022",
+    "launch token2022",
+    "deploy new token2022",
+    "create new token2022",
+    "mint token2022",
+  ],
+  description:
+    "Deploy a new SPL token2022 on the Solana blockchain with specified parameters",
+  examples: [
+    [
+      {
+        input: {
+          name: "My Token",
+          uri: "https://example.com/token.json",
+          symbol: "MTK",
+          decimals: 9,
+          initialSupply: 1000000,
+        },
+        output: {
+          mint: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN",
+          status: "success",
+          message: "Token deployed successfully",
+        },
+        explanation: "Deploy a token2022 with initial supply and metadata",
+      },
+    ],
+    [
+      {
+        input: {
+          name: "Basic Token",
+          uri: "https://example.com/basic.json",
+          symbol: "BASIC",
+        },
+        output: {
+          mint: "8nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkM",
+          status: "success",
+          message: "Token deployed successfully",
+        },
+        explanation: "Deploy a basic token2022 with minimal parameters",
+      },
+    ],
+  ],
+  schema: z.object({
+    name: z.string().min(1, "Name is required"),
+    uri: z.string().url("URI must be a valid URL"),
+    symbol: z.string().min(1, "Symbol is required"),
+    decimals: z.number().optional(),
+    initialSupply: z.number().optional(),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    try {
+      const result = await deploy_token2022(
+        agent,
+        input.name,
+        input.uri,
+        input.symbol,
+        input.decimals,
+        input.initialSupply,
+      );
+
+      return {
+        mint: result.mint.toString(),
+        status: "success",
+        message: "Token deployed successfully",
+      };
+    } catch (error: any) {
+      return {
+        status: "error",
+        message: `Token deployment failed: ${error.message}`,
+      };
+    }
+  },
+};
+
+export default deployToken2022Action;

src/agent/index.ts

@@ -11,6 +11,7 @@ import { DEFAULT_OPTIONS } from "../constants";
 import {
   deploy_collection,
   deploy_token,
+  deploy_token2022,
   get_balance,
   get_balance_other,
   getTPS,
@@ -276,6 +277,16 @@ export class SolanaAgentKit {
     );
   }
 
+  async deployToken2022(
+    name: string,
+    uri: string,
+    symbol: string,
+    decimals: number = DEFAULT_OPTIONS.TOKEN_DECIMALS,
+    initialSupply?: number,
+  ): Promise<{ mint: PublicKey }> {
+    return deploy_token2022(this, name, uri, symbol, decimals, initialSupply);
+  }
+
   async deployCollection(
     options: CollectionOptions,
   ): Promise<CollectionDeployment> {

src/langchain/index.ts

@@ -44,6 +44,7 @@ import {
   SolanaBalanceOtherTool,
   SolanaTransferTool,
   SolanaDeployTokenTool,
+  SolanaDeployToken2022Tool,
   SolanaDeployCollectionTool,
   SolanaMintNFTTool,
   SolanaTradeTool,
@@ -179,6 +180,7 @@ export function createSolanaTools(solanaKit: SolanaAgentKit) {
     new SolanaBalanceOtherTool(solanaKit),
     new SolanaTransferTool(solanaKit),
     new SolanaDeployTokenTool(solanaKit),
+    new SolanaDeployToken2022Tool(solanaKit),
     new SolanaDeployCollectionTool(solanaKit),
     new SolanaMintNFTTool(solanaKit),
     new SolanaTradeTool(solanaKit),

src/langchain/metaplex/deploy_token2022.ts

@@ -0,0 +1,45 @@
+import { Tool } from "langchain/tools";
+import { SolanaAgentKit } from "../../agent";
+
+export class SolanaDeployToken2022Tool extends Tool {
+  name = "solana_deploy_token2022";
+  description = `Deploy a new token2022 on Solana blockchain.
+  
+  Inputs (input is a JSON string):
+  name: string, eg "My Token" (required)
+  uri: string, eg "https://example.com/token.json" (required)
+  symbol: string, eg "MTK" (required)
+  decimals?: number, eg 9 (optional, defaults to 9)
+  initialSupply?: number, eg 1000000 (optional)`;
+
+  constructor(private solanaKit: SolanaAgentKit) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const parsedInput = JSON.parse(input);
+
+      const result = await this.solanaKit.deployToken2022(
+        parsedInput.name,
+        parsedInput.uri,
+        parsedInput.symbol,
+        parsedInput.decimals,
+        parsedInput.initialSupply,
+      );
+
+      return JSON.stringify({
+        status: "success",
+        message: "Token2022 deployed successfully",
+        mintAddress: result.mint.toString(),
+        decimals: parsedInput.decimals || 9,
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message,
+        code: error.code || "UNKNOWN_ERROR",
+      });
+    }
+  }
+}

src/langchain/metaplex/index.ts

@@ -1,6 +1,7 @@
 export * from "./deploy_collection";
 export * from "./mint_nft";
 export * from "./deploy_token";
+export * from "./deploy_token2022";
 export * from "./get_asset";
 export * from "./get_assets_by_authority";
 export * from "./get_assets_by_creator";

src/tools/metaplex/deploy_token2022.ts

@@ -0,0 +1,99 @@
+import { SolanaAgentKit } from "../../index";
+import { PublicKey as LegacyPublicKey } from "@solana/web3.js";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import {
+  generateSigner,
+  keypairIdentity,
+  publicKey,
+} from "@metaplex-foundation/umi";
+import {
+  createFungible,
+  mintV1,
+  TokenStandard,
+} from "@metaplex-foundation/mpl-token-metadata";
+import {
+  fromWeb3JsKeypair,
+  fromWeb3JsPublicKey,
+  toWeb3JsPublicKey,
+} from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  mplToolbox,
+  findAssociatedTokenPda,
+} from "@metaplex-foundation/mpl-toolbox";
+import { TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";
+import type { PublicKey } from "@metaplex-foundation/umi";
+
+/**
+ * Deploy a new SPL token
+ * @param agent SolanaAgentKit instance
+ * @param name Name of the token
+ * @param uri URI for the token metadata
+ * @param symbol Symbol of the token
+ * @param decimals Number of decimals for the token (default: 9)
+ * @param initialSupply Initial supply to mint (optional)
+ * @returns Object containing token mint address and initial account (if supply was minted)
+ */
+
+export async function deploy_token2022(
+  agent: SolanaAgentKit,
+  name: string,
+  uri: string,
+  symbol: string,
+  decimals: number = 9,
+  initialSupply?: number,
+): Promise<{ mint: LegacyPublicKey }> {
+  try {
+    // Create UMI instance from agent
+    const umi = createUmi(agent.connection.rpcEndpoint).use(mplToolbox());
+    umi.use(keypairIdentity(fromWeb3JsKeypair(agent.wallet)));
+
+    const SPL_TOKEN_2022_PROGRAM_ID: PublicKey = publicKey(
+      TOKEN_2022_PROGRAM_ID.toBase58(),
+    );
+    // Create new token2022 mint
+    const mint = generateSigner(umi);
+
+    let builder = createFungible(umi, {
+      name,
+      uri,
+      symbol,
+      splTokenProgram: SPL_TOKEN_2022_PROGRAM_ID,
+      sellerFeeBasisPoints: {
+        basisPoints: 0n,
+        identifier: "%",
+        decimals: 2,
+      },
+      decimals,
+      mint,
+    });
+
+    if (initialSupply) {
+      const token = findAssociatedTokenPda(umi, {
+        mint: mint.publicKey,
+        owner: fromWeb3JsPublicKey(agent.wallet_address),
+        tokenProgramId: SPL_TOKEN_2022_PROGRAM_ID,
+      });
+
+      builder = builder.add(
+        mintV1(umi, {
+          mint: mint.publicKey,
+          token,
+          splTokenProgram: SPL_TOKEN_2022_PROGRAM_ID,
+          tokenStandard: TokenStandard.Fungible,
+          tokenOwner: fromWeb3JsPublicKey(agent.wallet_address),
+          amount: initialSupply * Math.pow(10, decimals),
+        }),
+      );
+    }
+
+    await builder.sendAndConfirm(umi, {
+      confirm: { commitment: "processed" },
+    });
+
+    return {
+      mint: toWeb3JsPublicKey(mint.publicKey),
+    };
+  } catch (error: any) {
+    throw new Error(`Token deployment failed: ${error.message}`);
+  }
+}

src/tools/metaplex/index.ts

@@ -1,6 +1,7 @@
 export * from "./deploy_collection";
 export * from "./mint_nft";
 export * from "./deploy_token";
+export * from "./deploy_token2022";
 export * from "./get_asset";
 export * from "./get_assets_by_authority";
 export * from "./get_assets_by_creator";