@agentix/plugin-solana-solutiofi/dist/index.js

// src/index.ts
import { PluginBase, SolanaWalletBase as SolanaWalletBase2 } from "agentix";

// src/actions/burnTokens.ts
import { z } from "zod";

// src/tools/solutiofi.ts
import SolutioFi from "@solutiofi/sdk";
import { signOrSendTX } from "agentix";
var solutiofiClient = null;
async function initClient(agent) {
  if (!agent.config?.SOLUTIOFI_API_KEY) {
    throw new Error("SolutioFi API key not found in config");
  }
  if (!solutiofiClient) {
    solutiofiClient = new SolutioFi({
      apiKey: agent.config?.SOLUTIOFI_API_KEY
    });
    await solutiofiClient.authenticate();
  }
  return solutiofiClient;
}
async function closeAccounts(agent, mints) {
  try {
    const client = await initClient(agent);
    const signaturesOrTxs = [];
    const versionedTxns = await client.close(
      agent.wallet.getAddress(),
      mints
    );
    for (const transaction of versionedTxns) {
      try {
        const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
        transaction.message.recentBlockhash = blockhash;
        const signatureOrTx = await signOrSendTX(agent, transaction);
        signaturesOrTxs.push(signatureOrTx);
      } catch (_error) {
        continue;
      }
    }
    return signaturesOrTxs;
  } catch (e) {
    throw new Error(`Failed to close accounts: ${e}`);
  }
}
async function burnTokens(agent, mints) {
  try {
    const client = await initClient(agent);
    const signaturesOrTxs = [];
    const versionedTxns = await client.burn(
      agent.wallet.getAddress(),
      mints
    );
    for (const transaction of versionedTxns) {
      try {
        const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
        transaction.message.recentBlockhash = blockhash;
        const signatureOrTx = await signOrSendTX(agent, transaction);
        signaturesOrTxs.push(signatureOrTx);
      } catch (_error) {
        continue;
      }
    }
    return signaturesOrTxs;
  } catch (e) {
    throw new Error(`Failed to burn tokens: ${e}`);
  }
}
async function mergeTokens(agent, inputAssets, outputMint, priorityFee) {
  try {
    const client = await initClient(agent);
    const signaturesOrTxs = [];
    const swapData = await client.merge(
      agent.wallet.getAddress(),
      inputAssets,
      outputMint,
      priorityFee
    );
    for (const txn of swapData.transactions) {
      try {
        const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
        txn.transaction.message.recentBlockhash = blockhash;
        const signatureOrTx = await signOrSendTX(agent, txn.transaction);
        signaturesOrTxs.push(signatureOrTx);
      } catch (_error) {
        continue;
      }
    }
    return signaturesOrTxs;
  } catch (e) {
    throw new Error(`Failed to merge tokens: ${e}`);
  }
}
async function spreadToken(agent, inputAsset, targetTokens, priorityFee) {
  try {
    const client = await initClient(agent);
    const signaturesOrTxs = [];
    const swapData = await client.spread(
      agent.wallet.getAddress(),
      inputAsset,
      targetTokens,
      priorityFee
    );
    for (const txn of swapData.transactions) {
      try {
        const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
        txn.transaction.message.recentBlockhash = blockhash;
        const signatureOrTx = await signOrSendTX(agent, txn.transaction);
        signaturesOrTxs.push(signatureOrTx);
      } catch (_error) {
        continue;
      }
    }
    return signaturesOrTxs;
  } catch (e) {
    throw new Error(`Failed to spread token: ${e}`);
  }
}

// src/actions/burnTokens.ts
var burnTokensAction = {
  name: "SOLUTIOFI_BURN_TOKENS",
  description: "Burn tokens using SolutioFi",
  similes: [
    "burn tokens",
    "burn spl tokens",
    "burn spl-token",
    "destroy tokens",
    "burn assets",
    "burn nfts",
    "burn an nft",
    "permanently delete an nft or a token",
    "remove tokens from circulation",
    "delete my tokens",
    "permanently remove my tokens",
    "burn tokens with solutiofi",
    "burn nfts with solutiofi"
  ],
  examples: [
    [
      {
        input: {
          mints: ["tokenMint123", "tokenMint456"]
        },
        output: {
          status: "success",
          message: "Successfully burnt tokens",
          transactions: ["tx_signature"]
        },
        explanation: "Burn specified tokens"
      }
    ]
  ],
  schema: z.object({
    mints: z.array(z.string()).describe("Array of mint addresses to burn")
  }),
  handler: async (agent, input) => {
    try {
      const { mints } = input;
      const transactions = await burnTokens(agent, mints);
      return {
        status: "success",
        transactions,
        message: "Successfully burned tokens"
      };
    } catch (error) {
      return {
        status: "error",
        message: `Failed to burn tokens: ${error.message}`,
        code: error.code || "BURN_TOKENS_ERROR"
      };
    }
  }
};
var burnTokens_default = burnTokensAction;

// src/actions/closeAccounts.ts
import { z as z2 } from "zod";
var closeAccountsAction = {
  name: "SOLUTIOFI_CLOSE_ACCOUNTS",
  description: "Close specific token accounts using SolutioFi",
  similes: [
    "close token accounts",
    "close accounts with solutiofi",
    "close specific token accounts",
    "close specific spl token account",
    "remove empty accounts",
    "clean up token accounts",
    "close SPL token accounts",
    "delete my empty token accounts",
    "remove unused accounts",
    "disable token accounts",
    "deactivate empty token accounts",
    "clear empty token accounts",
    "reclaim SOL by closing accounts",
    "reclaim rent by closing empty accounts",
    "purge my wallet of empty accounts",
    "I want to close some accounts",
    "help me remove empty token accounts",
    "delete unnecessary accounts",
    "get rid of my empty accounts",
    "close down specific Solana token accounts",
    "remove all zero-balance tokens from my wallet",
    "I want to remove some token accounts"
  ],
  examples: [
    [
      {
        input: {
          mints: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"]
        },
        output: {
          status: "success",
          message: "Successfully closed accounts",
          transactions: ["tx_signature"]
        },
        explanation: "Close specified token accounts"
      }
    ]
  ],
  schema: z2.object({
    mints: z2.array(z2.string()).describe("Array of mint addresses to close")
  }),
  handler: async (agent, input) => {
    try {
      const { mints } = input;
      const transactions = await closeAccounts(agent, mints);
      return {
        status: "success",
        transactions,
        message: `Successfully closed ${mints.length} accounts`
      };
    } catch (error) {
      return {
        status: "error",
        message: `Failed to close accounts: ${error.message}`,
        code: error.code || "CLOSE_ACCOUNTS_ERROR"
      };
    }
  }
};
var closeAccounts_default = closeAccountsAction;

// src/actions/mergeTokens.ts
import { z as z3 } from "zod";
var mergeTokensAction = {
  name: "SOLUTIOFI_MERGE_TOKENS",
  description: "Merge multiple tokens into one using SolutioFi",
  similes: [
    "merge tokens",
    "combine tokens",
    "swap tokens",
    "merge tokens with solutiofi",
    "swap multiple tokens for one",
    "convert tokens into a single asset",
    "merge SPL tokens",
    "swap tokens into one",
    "combine assets into one token",
    "convert multiple tokens into one",
    "swap multiple assets into a single token",
    "combine token holdings",
    "exchange tokens for a unified asset",
    "aggregate tokens into one"
  ],
  examples: [
    [
      {
        input: {
          inputAssets: [
            { mint: "mint1", amount: "100" },
            { mint: "mint2", amount: "200" }
          ],
          outputMint: "outputMint123",
          priorityFee: "fast"
        },
        output: {
          status: "success",
          message: "Successfully merged tokens",
          result: { transaction: "tx_signature" }
        },
        explanation: "Merge multiple tokens into one output token"
      }
    ]
  ],
  schema: z3.object({
    inputAssets: z3.array(
      z3.object({
        mint: z3.string(),
        amount: z3.string()
      })
    ).describe("Array of input assets to merge"),
    outputMint: z3.string().describe("Output token mint address"),
    priorityFee: z3.enum(["fast", "turbo", "ultra"]).describe("Transaction priority level")
  }),
  handler: async (agent, input) => {
    try {
      const { inputAssets, outputMint, priorityFee } = input;
      const transactions = await mergeTokens(
        agent,
        inputAssets,
        outputMint,
        priorityFee
      );
      return {
        status: "success",
        transactions,
        message: "Successfully merged tokens"
      };
    } catch (error) {
      return {
        status: "error",
        message: `Failed to merge tokens: ${error.message}`,
        code: error.code || "MERGE_TOKENS_ERROR"
      };
    }
  }
};
var mergeTokens_default = mergeTokensAction;

// src/actions/spreadToken.ts
import { z as z4 } from "zod";
var spreadTokenAction = {
  name: "SOLUTIOFI_SPREAD_TOKEN",
  description: "Split a token into multiple tokens using SolutioFi",
  similes: [
    "spread token",
    "split token",
    "swap token",
    "spread tokens with solutiofi",
    "swap one token for multiple",
    "buy multiple tokens at once",
    "break token into parts",
    "split token into multiple assets",
    "convert one token into many",
    "swap token into different tokens",
    "allocate token to multiple assets",
    "spread token balance across multiple tokens",
    "swap and distribute token",
    "convert token into smaller portions",
    "exchange one token for multiple",
    "redistribute token into other tokens",
    "convert and spread token balance",
    "swap one asset for multiple tokens"
  ],
  examples: [
    [
      {
        input: {
          inputAsset: { mint: "inputMint", amount: "1000" },
          targetTokens: [
            { mint: "targetMint1", percentage: 60 },
            { mint: "targetMint2", percentage: 40 }
          ],
          priorityFee: "fast"
        },
        output: {
          status: "success",
          message: "Successfully spread token",
          result: { transaction: "tx_signature" }
        },
        explanation: "Split one token into multiple target tokens"
      }
    ]
  ],
  schema: z4.object({
    inputAsset: z4.object({
      mint: z4.string(),
      amount: z4.string()
    }).describe("Input asset to spread"),
    targetTokens: z4.array(
      z4.object({
        mint: z4.string(),
        percentage: z4.number()
      })
    ).describe("Target tokens with allocation percentages"),
    priorityFee: z4.enum(["fast", "turbo", "ultra"]).describe("Transaction priority level")
  }),
  handler: async (agent, input) => {
    try {
      const { inputAsset, targetTokens, priorityFee } = input;
      const result = await spreadToken(
        agent,
        inputAsset,
        targetTokens,
        priorityFee
      );
      return {
        status: "success",
        transactions: result,
        message: "Successfully spread token"
      };
    } catch (error) {
      return {
        status: "error",
        message: `Failed to spread token: ${error.message}`,
        code: error.code || "SPREAD_TOKEN_ERROR"
      };
    }
  }
};
var spreadToken_default = spreadTokenAction;

// src/index.ts
var SolutiofiPlugin = class extends PluginBase {
  constructor() {
    const methods = {
      burnTokens,
      closeAccounts,
      mergeTokens,
      spreadToken
    };
    const actions = [
      burnTokens_default,
      closeAccounts_default,
      mergeTokens_default,
      spreadToken_default
    ];
    const supportedChains = [
      {
        type: "solana"
      }
    ];
    super("solutiofi", methods, actions, supportedChains);
  }
  supportsWallet(wallet) {
    return wallet instanceof SolanaWalletBase2;
  }
};
var index_default = SolutiofiPlugin;
export {
  index_default as default
};