solana-agent-kit-torch-market 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -0,0 +1,595 @@
+// src/tools/torch.ts
+import { Transaction } from "@solana/web3.js";
+import { signOrSendTX } from "solana-agent-kit";
+var TORCH_API = "https://torch.market/api/v1";
+async function torchListTokens(agent, status, sort, limit) {
+  const params = new URLSearchParams();
+  if (status) params.set("status", status);
+  if (sort) params.set("sort", sort);
+  if (limit) params.set("limit", limit.toString());
+  const res = await fetch(`${TORCH_API}/tokens?${params}`);
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to list tokens");
+  return json.data.tokens;
+}
+async function torchGetToken(agent, mint) {
+  const res = await fetch(`${TORCH_API}/tokens/${mint}`);
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Token not found");
+  return json.data;
+}
+async function torchBuyToken(agent, mint, amountLamports, slippageBps = 100) {
+  const res = await fetch(`${TORCH_API}/transactions/buy`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      mint,
+      buyer: agent.wallet.publicKey.toBase58(),
+      amount_sol: amountLamports,
+      slippage_bps: slippageBps
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build buy transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  return signOrSendTX(agent, tx);
+}
+async function torchSellToken(agent, mint, amountTokens, slippageBps = 100) {
+  const res = await fetch(`${TORCH_API}/transactions/sell`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      mint,
+      seller: agent.wallet.publicKey.toBase58(),
+      amount_tokens: amountTokens,
+      slippage_bps: slippageBps
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build sell transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  return signOrSendTX(agent, tx);
+}
+async function torchVoteToken(agent, mint, vote) {
+  const res = await fetch(`${TORCH_API}/transactions/vote`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      mint,
+      voter: agent.wallet.publicKey.toBase58(),
+      vote
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build vote transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  return signOrSendTX(agent, tx);
+}
+async function torchStarToken(agent, mint) {
+  const res = await fetch(`${TORCH_API}/transactions/star`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      mint,
+      user: agent.wallet.publicKey.toBase58()
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build star transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  return signOrSendTX(agent, tx);
+}
+async function torchCreateToken(agent, name, symbol, metadataUri) {
+  const res = await fetch(`${TORCH_API}/transactions/create`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      creator: agent.wallet.publicKey.toBase58(),
+      name,
+      symbol,
+      metadata_uri: metadataUri
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build create transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  const signature = await signOrSendTX(agent, tx);
+  return {
+    signature,
+    mint: json.data.mint
+  };
+}
+async function torchGetMessages(agent, mint, limit = 50) {
+  const params = new URLSearchParams();
+  if (limit) params.set("limit", limit.toString());
+  const res = await fetch(`${TORCH_API}/tokens/${mint}/messages?${params}`);
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to get messages");
+  return json.data.messages;
+}
+async function torchPostMessage(agent, mint, message) {
+  const res = await fetch(`${TORCH_API}/transactions/message`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      mint,
+      sender: agent.wallet.publicKey.toBase58(),
+      message
+    })
+  });
+  const json = await res.json();
+  if (!json.success) throw new Error(json.error?.message || "Failed to build message transaction");
+  const tx = Transaction.from(Buffer.from(json.data.transaction, "base64"));
+  const { blockhash } = await agent.connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  return signOrSendTX(agent, tx);
+}
+
+// src/actions/torch.ts
+import { z } from "zod";
+var torchListTokensAction = {
+  name: "TORCH_LIST_TOKENS",
+  similes: [
+    "list torch tokens",
+    "browse torch market",
+    "find bonding curve tokens",
+    "show torch launchpad tokens",
+    "what tokens are on torch market"
+  ],
+  description: "List tokens on Torch Market - a fair-launch platform with bonding curves and community treasuries. Filter by status (bonding, complete, migrated) and sort by newest, volume, or marketcap.",
+  examples: [
+    [
+      {
+        input: { status: "bonding", sort: "volume", limit: 10 },
+        output: {
+          status: "success",
+          tokens: [{ mint: "ABC...", name: "Example", symbol: "EX", progress_percent: 45 }],
+          count: 10
+        },
+        explanation: "List the top 10 bonding tokens by volume on Torch Market"
+      }
+    ]
+  ],
+  schema: z.object({
+    status: z.enum(["bonding", "complete", "migrated", "all"]).optional().describe("Filter by token status"),
+    sort: z.enum(["newest", "volume", "marketcap"]).optional().describe("Sort order"),
+    limit: z.number().positive().max(100).optional().describe("Number of tokens to return")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const tokens = await torchListTokens(agent, input.status, input.sort, input.limit);
+      return {
+        status: "success",
+        tokens,
+        count: tokens.length,
+        message: `Found ${tokens.length} tokens on Torch Market`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Failed to list tokens: ${error.message}`
+      };
+    }
+  }
+};
+var torchGetTokenAction = {
+  name: "TORCH_GET_TOKEN",
+  similes: [
+    "get torch token info",
+    "torch token details",
+    "check torch token",
+    "lookup token on torch"
+  ],
+  description: "Get detailed information about a specific token on Torch Market, including price, progress, treasury state, and vote counts.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123..." },
+        output: {
+          status: "success",
+          token: { name: "Example", symbol: "EX", progress_percent: 45, votes_burn: 100 }
+        },
+        explanation: "Get details for a specific Torch token"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const token = await torchGetToken(agent, input.mint);
+      return {
+        status: "success",
+        token,
+        message: `${token.name} (${token.symbol}) - ${token.progress_percent.toFixed(1)}% complete`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Failed to get token: ${error.message}`
+      };
+    }
+  }
+};
+var torchBuyTokenAction = {
+  name: "TORCH_BUY_TOKEN",
+  similes: [
+    "buy token on torch",
+    "purchase torch token",
+    "buy on torch market",
+    "invest in torch token"
+  ],
+  description: "Buy tokens on Torch Market bonding curve. Specify amount in SOL. 10% of tokens go to community treasury, 90% to you. 1% protocol fee on buys.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123...", amountSol: 0.1 },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          message: "Bought tokens for 0.1 SOL"
+        },
+        explanation: "Buy tokens with 0.1 SOL on Torch Market"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address"),
+    amountSol: z.number().positive().describe("Amount of SOL to spend"),
+    slippagePercent: z.number().positive().max(50).optional().describe("Slippage tolerance as percentage (default 1%)")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const lamports = Math.floor(input.amountSol * 1e9);
+      const bps = input.slippagePercent ? Math.floor(input.slippagePercent * 100) : 100;
+      const signature = await torchBuyToken(agent, input.mint, lamports, bps);
+      return {
+        status: "success",
+        signature,
+        message: `Bought tokens for ${input.amountSol} SOL`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Buy failed: ${error.message}`
+      };
+    }
+  }
+};
+var torchSellTokenAction = {
+  name: "TORCH_SELL_TOKEN",
+  similes: [
+    "sell token on torch",
+    "sell torch token",
+    "exit torch position"
+  ],
+  description: "Sell tokens back to Torch Market bonding curve. No sell fees. Specify amount in tokens.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123...", amountTokens: 1e6 },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          message: "Sold 1M tokens"
+        },
+        explanation: "Sell 1M tokens back to the bonding curve"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address"),
+    amountTokens: z.number().positive().describe("Amount of tokens to sell"),
+    slippagePercent: z.number().positive().max(50).optional().describe("Slippage tolerance as percentage (default 1%)")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const baseUnits = Math.floor(input.amountTokens * 1e6);
+      const bps = input.slippagePercent ? Math.floor(input.slippagePercent * 100) : 100;
+      const signature = await torchSellToken(agent, input.mint, baseUnits, bps);
+      return {
+        status: "success",
+        signature,
+        message: `Sold ${input.amountTokens.toLocaleString()} tokens`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Sell failed: ${error.message}`
+      };
+    }
+  }
+};
+var torchVoteTokenAction = {
+  name: "TORCH_VOTE_TOKEN",
+  similes: [
+    "vote on torch token",
+    "torch treasury vote",
+    "vote burn torch",
+    "vote return torch"
+  ],
+  description: "Vote on treasury outcome for a graduated Torch token. After reaching 200 SOL, holders vote: 'burn' destroys treasury tokens (reducing supply), 'return' gives them to the creator. You must hold the token to vote.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123...", vote: "burn" },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          message: "Voted to burn treasury tokens"
+        },
+        explanation: "Vote to burn the community treasury tokens"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address"),
+    vote: z.enum(["burn", "return"]).describe("'burn' = destroy treasury tokens, 'return' = give to creator")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const signature = await torchVoteToken(agent, input.mint, input.vote);
+      const desc = input.vote === "burn" ? "burn treasury tokens" : "return tokens to creator";
+      return {
+        status: "success",
+        signature,
+        vote: input.vote,
+        message: `Voted to ${desc}`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Vote failed: ${error.message}`
+      };
+    }
+  }
+};
+var torchStarTokenAction = {
+  name: "TORCH_STAR_TOKEN",
+  similes: [
+    "star torch token",
+    "support torch token",
+    "like token on torch"
+  ],
+  description: "Star a token on Torch Market to show support (costs 0.05 SOL). When tokens reach the star threshold, creators receive rewards.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123..." },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          message: "Starred token for 0.05 SOL"
+        },
+        explanation: "Star a token to show support"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address to star")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const signature = await torchStarToken(agent, input.mint);
+      return {
+        status: "success",
+        signature,
+        cost: 0.05,
+        message: "Starred token (cost: 0.05 SOL)"
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Star failed: ${error.message}`
+      };
+    }
+  }
+};
+var torchCreateTokenAction = {
+  name: "TORCH_CREATE_TOKEN",
+  similes: [
+    "create token on torch",
+    "launch token on torch",
+    "create my own token",
+    "make a torch token",
+    "deploy token to torch market"
+  ],
+  description: "Create a new token on Torch Market with automatic bonding curve, community treasury, and Raydium migration. You need to provide a metadata_uri pointing to a JSON file with name, symbol, description, and image URL.",
+  examples: [
+    [
+      {
+        input: {
+          name: "My Agent Token",
+          symbol: "MAT",
+          metadataUri: "https://arweave.net/abc123"
+        },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          mint: "NEW_MINT_ADDRESS",
+          message: "Created token My Agent Token ($MAT)"
+        },
+        explanation: "Create a new token with bonding curve"
+      }
+    ]
+  ],
+  schema: z.object({
+    name: z.string().max(32).describe("Token name (max 32 characters)"),
+    symbol: z.string().max(10).describe("Token symbol (max 10 characters)"),
+    metadataUri: z.string().url().describe("URI pointing to token metadata JSON with name, symbol, description, and image")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const result = await torchCreateToken(
+        agent,
+        input.name,
+        input.symbol,
+        input.metadataUri
+      );
+      return {
+        status: "success",
+        signature: result.signature,
+        mint: result.mint,
+        message: `Created token ${input.name} ($${input.symbol})`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Create token failed: ${error.message}`
+      };
+    }
+  }
+};
+var torchGetMessagesAction = {
+  name: "TORCH_GET_MESSAGES",
+  similes: [
+    "get torch messages",
+    "read torch messages",
+    "see messages on torch",
+    "what are agents saying on torch",
+    "read token chat"
+  ],
+  description: "Get messages from a token's page on Torch Market. AI agents can use this to read what other agents are saying and coordinate.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123...", limit: 20 },
+        output: {
+          status: "success",
+          messages: [{ memo: "Hello from an AI!", sender: "5xKp...", timestamp: 1234567890 }],
+          count: 1
+        },
+        explanation: "Read the last 20 messages on a token's page"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address"),
+    limit: z.number().positive().max(100).optional().describe("Number of messages to return (default 50, max 100)")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const messages = await torchGetMessages(agent, input.mint, input.limit);
+      return {
+        status: "success",
+        messages,
+        count: messages.length,
+        message: `Found ${messages.length} messages`
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Failed to get messages: ${error.message}`
+      };
+    }
+  }
+};
+var torchPostMessageAction = {
+  name: "TORCH_POST_MESSAGE",
+  similes: [
+    "post torch message",
+    "send torch message",
+    "say something on torch",
+    "communicate on torch",
+    "message other agents"
+  ],
+  description: "Post a message on a token's page on Torch Market. AI agents can use this to communicate with each other. Messages are stored on-chain as SPL Memos and are permanent.",
+  examples: [
+    [
+      {
+        input: { mint: "ABC123...", message: "Hello from an AI agent!" },
+        output: {
+          status: "success",
+          signature: "5xKp...",
+          message: "Posted message"
+        },
+        explanation: "Post a message on a token's page"
+      }
+    ]
+  ],
+  schema: z.object({
+    mint: z.string().describe("Token mint address"),
+    message: z.string().max(500).describe("Message to post (max 500 characters)")
+  }),
+  handler: async (agent, input) => {
+    try {
+      const signature = await torchPostMessage(agent, input.mint, input.message);
+      return {
+        status: "success",
+        signature,
+        message: "Posted message"
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Post message failed: ${error.message}`
+      };
+    }
+  }
+};
+
+// src/index.ts
+var TorchMarketPlugin = {
+  name: "torch-market",
+  // Methods available on agent.methods
+  methods: {
+    torchListTokens,
+    torchGetToken,
+    torchBuyToken,
+    torchSellToken,
+    torchVoteToken,
+    torchStarToken,
+    torchCreateToken,
+    torchGetMessages,
+    torchPostMessage
+  },
+  // Actions for LangChain/AI agents
+  actions: [
+    torchListTokensAction,
+    torchGetTokenAction,
+    torchBuyTokenAction,
+    torchSellTokenAction,
+    torchVoteTokenAction,
+    torchStarTokenAction,
+    torchCreateTokenAction,
+    torchGetMessagesAction,
+    torchPostMessageAction
+  ],
+  // Initialize (required by Plugin interface)
+  initialize: function() {
+  }
+};
+var index_default = TorchMarketPlugin;
+export {
+  TorchMarketPlugin,
+  index_default as default,
+  torchBuyToken,
+  torchBuyTokenAction,
+  torchCreateToken,
+  torchCreateTokenAction,
+  torchGetMessages,
+  torchGetMessagesAction,
+  torchGetToken,
+  torchGetTokenAction,
+  torchListTokens,
+  torchListTokensAction,
+  torchPostMessage,
+  torchPostMessageAction,
+  torchSellToken,
+  torchSellTokenAction,
+  torchStarToken,
+  torchStarTokenAction,
+  torchVoteToken,
+  torchVoteTokenAction
+};

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "solana-agent-kit-torch-market",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Solana Agent Kit plugin for Torch Market - fair-launch token platform with community treasuries",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "files": [
@@ -34,7 +34,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/torch-market/solana-agent-kit-plugin"
+    "url": "https://github.com/mrsirg97-rgb/solana-agent-kit"
   },
   "homepage": "https://torch.market",
   "peerDependencies": {