added actions for tools

src/actions/helius/createWebhook.ts

@@ -0,0 +1,57 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { create_HeliusWebhook } from "../../tools/helius";
+
+const createWebhookAction: Action = {
+  name: "CREATE_HELIOUS_WEBHOOK",
+  similes: ["setup webhook", "register webhook", "initiate webhook"],
+  description:
+    "Creates a new webhook in the Helius system to monitor transactions for specified account addresses",
+  examples: [
+    [
+      {
+        input: {
+          accountAddresses: [
+            "BVdNLvyG2DNiWAXBE9qAmc4MTQXymd5Bzfo9xrQSUzVP",
+            "Eo2ciguhMLmcTWXELuEQPdu7DWZt67LHXb2rdHZUbot7",
+          ],
+          webhookURL: "https://yourdomain.com/webhook",
+        },
+        output: {
+          status: "success",
+          webhookURL: "https://yourdomain.com/webhook",
+          webhookID: "webhook_123",
+          message: "Webhook created successfully.",
+        },
+        explanation:
+          "Creates a Webhook to send live notifications on the given Url with the wallet Addresses.",
+      },
+    ],
+  ],
+  schema: z.object({
+    accountAddresses: z
+      .array(z.string())
+      .min(1)
+      .describe("List of Solana account public keys to monitor"),
+    webhookURL: z
+      .string()
+      .url()
+      .describe("The URL where Helius will send webhook notifications"),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    const response = await create_HeliusWebhook(
+      agent,
+      input.accountAddresses,
+      input.webhookURL,
+    );
+
+    return {
+      status: "success",
+      ...response,
+      message: "Webhook created successfully.",
+    };
+  },
+};
+
+export default createWebhookAction;

src/actions/helius/deleteWebhook.ts

@@ -0,0 +1,40 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { deleteHeliusWebhook } from "../../tools/helius";
+
+const deleteWebhookAction: Action = {
+  name: "DELETE_HELIOUS_WEBHOOK",
+  similes: ["remove webhook", "unregister webhook", "delete webhook"],
+  description: "Deletes a Helius webhook by its unique ID",
+  examples: [
+    [
+      {
+        input: {
+          webhookID: "webhook_123",
+        },
+        output: {
+          status: "success",
+          message: "Webhook deleted successfully.",
+        },
+        explanation: "Permanently removes a Helius webhook.",
+      },
+    ],
+  ],
+  schema: z.object({
+    webhookID: z
+      .string()
+      .min(1)
+      .describe("The unique identifier of the Helius webhook to delete"),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    const result = await deleteHeliusWebhook(agent, input.webhookID);
+
+    return {
+      status: "success",
+      message: result.message || "Webhook deleted successfully.",
+    };
+  },
+};
+
+export default deleteWebhookAction;

src/actions/helius/getAssetsbyOwner.ts

@@ -0,0 +1,75 @@
+import { Action } from "../../types/action";
+import { PublicKey } from "@solana/web3.js";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { getAssetsByOwner } from "../../tools/helius";
+
+const getAssetsByOwnerAction: Action = {
+  name: "FETCH_ASSETS_BY_OWNER",
+  similes: [
+    "fetch assets",
+    "get assets",
+    "retrieve assets",
+    "list assets",
+    "assets by owner",
+  ],
+  description:
+    "Fetch assets owned by a specific Solana wallet address using the Helius Digital Asset Standard API",
+  examples: [
+    [
+      {
+        input: {
+          ownerPublicKey: "4Pf8q3mHGLdkoc1M8xWZwW5q32gYmdhwC2gJ8K9EAGDX",
+          limit: 10,
+        },
+        output: {
+          status: "success",
+          assets: [
+            {
+              name: "Helius NFT #1",
+              type: "NFT",
+              owner: "4Pf8q3mHGLdkoc1M8xWZwW5q32gYmdhwC2gJ8K9EAGDX",
+            },
+            {
+              name: "Helius Token #10",
+              type: "Token",
+              owner: "4Pf8q3mHGLdkoc1M8xWZwW5q32gYmdhwC2gJ8K9EAGDX",
+            },
+          ],
+          message: "Successfully fetched assets for the wallet address",
+        },
+        explanation:
+          "Fetches a list of assets from the for the given wallet address with a limit of 10 items.",
+      },
+    ],
+  ],
+  schema: z.object({
+    ownerPublicKey: z.string().describe("Owner's Solana wallet PublicKey"),
+    limit: z
+      .number()
+      .positive()
+      .describe("Number of assets to retrieve per request"),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    try {
+      const assets = await getAssetsByOwner(
+        agent,
+        new PublicKey(input.ownerPublicKey),
+        input.limit,
+      );
+
+      return {
+        status: "success",
+        assets: assets,
+        message: `Successfully fetched assets for the wallet address: ${input.ownerPublicKey}`,
+      };
+    } catch (error: any) {
+      return {
+        status: "error",
+        message: `Failed to fetch assets: ${error.message}`,
+      };
+    }
+  },
+};
+
+export default getAssetsByOwnerAction;

src/actions/helius/getWebhook.ts

@@ -0,0 +1,47 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { getHeliusWebhook } from "../../tools/helius";
+
+const getWebhookAction: Action = {
+  name: "GET_HELIOUS_WEBHOOK",
+  similes: ["fetch webhook details", "retrieve webhook", "get webhook info"],
+  description: "Retrieves details of a Helius webhook by its unique ID",
+  examples: [
+    [
+      {
+        input: {
+          webhookID: "webhook_123",
+        },
+        output: {
+          status: "success",
+          wallet: "WalletPublicKey",
+          webhookURL: "https://yourdomain.com/webhook",
+          transactionTypes: ["Any"],
+          accountAddresses: ["SomePublicKey", "AnotherPublicKey"],
+          webhookType: "enhanced",
+          message: "Webhook details retrieved successfully.",
+        },
+        explanation:
+          "Retrieves detailed information about an existing Helius webhook, including the wallet address it monitors, the types of transactions it tracks, and the specific webhook URL.",
+      },
+    ],
+  ],
+  schema: z.object({
+    webhookID: z
+      .string()
+      .min(1)
+      .describe("The unique identifier of the Helius webhook to retrieve"),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    const webhookDetails = await getHeliusWebhook(agent, input.webhookID);
+
+    return {
+      status: "success",
+      ...webhookDetails,
+      message: "Webhook details retrieved successfully.",
+    };
+  },
+};
+
+export default getWebhookAction;

src/actions/helius/parseTransaction.ts

@@ -0,0 +1,65 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { parseTransaction } from "../../tools/helius";
+
+const parseSolanaTransactionAction: Action = {
+  name: "PARSE_SOLANA_TRANSACTION",
+  similes: [
+    "parse transaction",
+    "analyze transaction",
+    "inspect transaction",
+    "decode transaction",
+  ],
+  description:
+    "Parse a Solana transaction to retrieve detailed information using the Helius Enhanced Transactions API",
+  examples: [
+    [
+      {
+        input: {
+          transactionId:
+            "4zZVvbgzcriyjAeEiK1w7CeDCt7gYThUCZat3ULTNerzKHF4WLfRG2YUjbRovfFJ639TAyARB4oyRDcLVUvrakq7",
+        },
+        output: {
+          status: "success",
+          transaction: {
+            details: "Transaction details...",
+            involvedAccounts: ["Account1", "Account2"],
+            executedOperations: [{ operation: "Transfer", amount: "1000 SOL" }],
+          },
+          message:
+            "Successfully parsed transaction: 4zZVvbgzcriyjAeEiK1w7CeDCt7gYThUCZat3ULTNerzKHF4WLfRG2YUjbRovfFJ639TAyARB4oyRDcLVUvrakq7",
+        },
+        explanation:
+          "Parse a Transaction to transform it into human readable format.",
+      },
+    ],
+  ],
+  schema: z.object({
+    transactionId: z
+      .string()
+      .min(1)
+      .describe("The Solana transaction ID to parse"),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    try {
+      const parsedTransactionData = await parseTransaction(
+        agent,
+        input.transactionId,
+      );
+
+      return {
+        status: "success",
+        transaction: parsedTransactionData,
+        message: `Successfully parsed transaction: ${input.transactionId}`,
+      };
+    } catch (error: any) {
+      return {
+        status: "error",
+        message: `Failed to parse transaction: ${error.message}`,
+      };
+    }
+  },
+};
+
+export default parseSolanaTransactionAction;

src/actions/helius/sendTransactionWithPriority.ts

@@ -0,0 +1,76 @@
+import { Action } from "../../types/action";
+import { SolanaAgentKit } from "../../agent";
+import { z } from "zod";
+import { sendTransactionWithPriorityFee } from "../../tools/helius";
+import { PublicKey } from "@solana/web3.js";
+
+const sendTransactionWithPriorityFeeAction: Action = {
+  name: "SEND_TRANSACTION_WITH_PRIORITY_FEE",
+  similes: [
+    "send SOL with fee",
+    "transfer tokens with priority",
+    "execute priority transaction",
+  ],
+  description:
+    "Sends SOL or SPL tokens from a wallet with an estimated priority fee, ensuring faster processing on the Solana network.",
+  examples: [
+    [
+      {
+        input: {
+          priorityLevel: "High",
+          amount: 2,
+          to: "BVdNLvyG2DNiWAXBE9qAmc4MTQXymd5Bzfo9xrQSUzVP",
+          splmintAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        },
+        output: {
+          status: "success",
+          transactionId: "5Xgq9xVABhwXpNStWpfqxS6Vm5Eau91pjfeHNwJbRgis",
+          fee: 5000,
+          message: "Transaction sent with priority fee successfully.",
+        },
+        explanation:
+          "Sends 2 USDC to BVdNLvyG2DNiWAXBE9qAmc4MTQXymd5Bzfo9xrQSUzVP with High priority fee option.",
+      },
+    ],
+  ],
+  schema: z.object({
+    priorityLevel: z
+      .enum(["Min", "Low", "Medium", "High", "VeryHigh", "UnsafeMax"])
+      .describe("Priority level to determine the urgency of the transaction."),
+    amount: z
+      .number()
+      .positive()
+      .describe("Amount of SOL or SPL tokens to send."),
+    to: z.string().describe("Recipient's PublicKey."),
+    splmintAddress: z
+      .string()
+      .optional()
+      .describe(
+        "Optional SPL token address, if transferring tokens other than SOL.",
+      ),
+  }),
+  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+    const { priorityLevel, amount, to, splmintAddress } = input;
+    const toPublicKey = new PublicKey(to);
+    const splmintPublicKey = splmintAddress
+      ? new PublicKey(splmintAddress)
+      : undefined;
+
+    const result = await sendTransactionWithPriorityFee(
+      agent,
+      priorityLevel,
+      amount,
+      toPublicKey,
+      splmintPublicKey,
+    );
+
+    return {
+      status: "success",
+      transactionId: result.transactionId,
+      fee: result.fee,
+      message: "Transaction sent with priority fee successfully.",
+    };
+  },
+};
+
+export default sendTransactionWithPriorityFeeAction;

src/actions/index.ts

@@ -37,6 +37,12 @@ import depositToMultisigAction from "./squads/depositToMultisigTreasury";
 import executeMultisigProposalAction from "./squads/executeMultisigProposal";
 import rejectMultisigProposalAction from "./squads/rejectMultisigProposal";
 import transferFromMultisigAction from "./squads/transferFromMultisigTreasury";
+import createWebhookAction from "./helius/createWebhook";
+import deleteWebhookAction from "./helius/deleteWebhook";
+import getAssetsByOwnerAction from "./helius/getAssetsbyOwner";
+import getWebhookAction from "./helius/getWebhook";
+import parseSolanaTransactionAction from "./helius/parseTransaction";
+import sendTransactionWithPriorityFeeAction from "./helius/sendTransactionWithPriority";
 
 export const ACTIONS = {
   WALLET_ADDRESS_ACTION: getWalletAddressAction,
@@ -79,6 +85,12 @@ export const ACTIONS = {
   APPROVE_MULTISIG_PROPOSAL_ACTION: approveMultisigProposalAction,
   REJECT_MULTISIG_PROPOSAL_ACTION: rejectMultisigProposalAction,
   EXECUTE_MULTISIG_PROPOSAL_ACTION: executeMultisigProposalAction,
+  CREATE_WEBHOOK_ACTION: createWebhookAction,
+  DELETE_WEBHOOK_ACTION: deleteWebhookAction,
+  GET_ASSETS_BY_OWNER_ACTION: getAssetsByOwnerAction,
+  GET_WEBHOOK_ACTION: getWebhookAction,
+  PARSE_TRANSACTION_ACTION: parseSolanaTransactionAction,
+  SEND_TRANSACTION_WITH_PRIORITY_ACTION: sendTransactionWithPriorityFeeAction,
 };
 
 export type { Action, ActionExample, Handler } from "../types/action";