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

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

// src/actions/createMeteoraDLMMPool.ts
import { PublicKey as PublicKey3 } from "@solana/web3.js";
import BN2 from "bn.js";
import { z } from "zod";

// src/tools/create_meteora_dlmm_pool.ts
import DLMM from "@meteora-ag/dlmm";
import { getMint } from "@solana/spl-token";
import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { signOrSendTX } from "agentix";
async function createMeteoraDlmmPool(agent, binStep, tokenAMint, tokenBMint, initialPrice, priceRoundingUp, feeBps, activationType, hasAlphaVault, activationPoint) {
  const tokenAMintInfo = await getMint(agent.wallet.getConnection(), tokenAMint);
  const tokenBMintInfo = await getMint(agent.wallet.getConnection(), tokenBMint);
  const initPrice = DLMM.getPricePerLamport(
    tokenAMintInfo.decimals,
    tokenBMintInfo.decimals,
    initialPrice
  );
  const activateBinId = DLMM.getBinIdFromPrice(
    initPrice,
    binStep,
    !priceRoundingUp
  );
  const initPoolTx = await DLMM.createCustomizablePermissionlessLbPair(
    agent.wallet.getConnection(),
    new BN(binStep),
    tokenAMint,
    tokenBMint,
    new BN(activateBinId.toString()),
    new BN(feeBps),
    activationType,
    hasAlphaVault,
    new PublicKey(agent.wallet.getAddress()),
    activationPoint,
    {
      cluster: "mainnet-beta"
    }
  );
  const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
  initPoolTx.recentBlockhash = blockhash;
  return signOrSendTX(agent, initPoolTx, void 0, "max");
}

// src/tools/create_meteora_dynamic_amm_pool.ts
import AmmImpl from "@mercurial-finance/dynamic-amm-sdk";
import { PublicKey as PublicKey2 } from "@solana/web3.js";
import { signOrSendTX as signOrSendTX2 } from "agentix";
async function createMeteoraDynamicAMMPool(agent, tokenAMint, tokenBMint, tokenAAmount, tokenBAmount, customizableParams) {
  const initPoolTx = await AmmImpl.createCustomizablePermissionlessConstantProductPool(
    agent.wallet.getConnection(),
    new PublicKey2(agent.wallet.getAddress()),
    tokenAMint,
    tokenBMint,
    tokenAAmount,
    tokenBAmount,
    customizableParams
  );
  const { blockhash } = await agent.wallet.getConnection().getLatestBlockhash();
  initPoolTx.recentBlockhash = blockhash;
  return await signOrSendTX2(agent, initPoolTx, void 0, "max");
}

// src/actions/createMeteoraDLMMPool.ts
var createMeteoraDLMMPoolAction = {
  name: "CREATE_METEORA_DLMM_POOL",
  description: "Create a new Meteora DLMM pool",
  similes: [
    "create Meteora DLMM pool",
    "setup Meteora DLMM pool",
    "new Meteora DLMM pool",
    "create DLMM pool",
    "setup Meteora DLMM pool",
    "new DLMM pool"
  ],
  examples: [
    [
      {
        input: {
          binStep: 100,
          tokenAMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
          tokenBMint: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
          initialPrice: 1,
          priceRoundingUp: false,
          feeBps: 1e3,
          activationType: "Timestamp",
          hasAlphaVault: false,
          activationPoint: 0
        },
        output: {
          status: "success",
          transaction: "78fj2...",
          message: "Successfully created Meteora DLMM pool"
        },
        explanation: "Create a new Meteora DLMM pool for USDC/JUP"
      }
    ]
  ],
  schema: z.object({
    binStep: z.number().positive().describe("DLMM pool bin step"),
    tokenAMint: z.string().min(1).describe("The token A mint address"),
    tokenBMint: z.string().min(1).describe("The token B mint address"),
    initialPrice: z.number().positive().describe("Initial pool price in ratio tokenA / tokenB"),
    priceRoundingUp: z.boolean().describe("Whether to rounding up the initial pool price").optional(),
    feeBps: z.number().positive().describe("Pool trading fee in BPS"),
    activationType: z.enum(["Timestamp", "Slot"]).describe("Pool activation type").optional(),
    hasAlphaVault: z.boolean().describe("Whether the pool has Meteora alpha vault or not").optional().default(false),
    activationPoint: z.number().describe(
      "Activation point depending on activation type, or null if pool doesn't have an activation point"
    ).optional()
  }),
  handler: async (agent, input) => {
    try {
      const tokenAMint = new PublicKey3(input.tokenAMint);
      const tokenBMint = new PublicKey3(input.tokenBMint);
      const binStep = input.binStep;
      const initialPrice = input.initialPrice;
      const feeBps = input.feeBps;
      const priceRoundingUp = input.priceRoundingUp ?? true;
      const activationType = input.activationType ?? 1;
      const activationPoint = input.activationPoint ? new BN2(input.activationPoint) : void 0;
      const hasAlphaVault = input.hasAlphaVault ?? false;
      const transaction = await createMeteoraDlmmPool(
        agent,
        binStep,
        tokenAMint,
        tokenBMint,
        initialPrice,
        priceRoundingUp,
        feeBps,
        activationType,
        hasAlphaVault,
        activationPoint
      );
      return {
        status: "success",
        message: "Meteora DLMM pool created successfully.",
        transaction
      };
    } catch (error) {
      return {
        status: "error",
        message: error.message,
        code: error.code || "UNKNOWN_ERROR"
      };
    }
  }
};
var createMeteoraDLMMPool_default = createMeteoraDLMMPoolAction;

// src/actions/createMeteoraDynamicAMMPool.ts
import { MintLayout } from "@solana/spl-token";
import { PublicKey as PublicKey4 } from "@solana/web3.js";
import BN3 from "bn.js";
import Decimal from "decimal.js";
import { z as z2 } from "zod";
var createMeteoraDynamicAMMPoolAction = {
  name: "CREATE_METEORA_DYNAMIC_AMM_POOL",
  description: "Create a new dynamic AMM pool on Meteora",
  similes: [
    "create dynamic AMM pool",
    "setup AMM pool",
    "new dynamic AMM pool",
    "create AMM pool",
    "setup liquidity pool",
    "new AMM pool"
  ],
  examples: [
    [
      {
        input: {
          tokenAAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
          tokenBAddress: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
          tokenAAmount: 100,
          tokenBAmount: 100,
          tradeFeeNumerator: 1e3,
          activationType: "Timestamp",
          activationPoint: 0,
          hasAlphaVault: false
        },
        output: {
          status: "success",
          transaction: "78fj2...",
          message: "Successfully created Meteora dynamic AMM pool"
        },
        explanation: "Create a new dynamic AMM pool on Meteora for USDC/JUP"
      }
    ]
  ],
  schema: z2.object({
    tokenAAddress: z2.string().min(1).describe("The token A mint address"),
    tokenBAddress: z2.string().min(1).describe("The token B mint address"),
    tokenAAmount: z2.number().positive().describe("The token A amount in lamport units"),
    tokenBAmount: z2.number().positive().describe("The token B amount in lamport units"),
    tradeFeeNumerator: z2.number().positive().describe("Trade fee numerator"),
    activationType: z2.enum(["Timestamp", "Slot"]).describe("Activation type").optional(),
    activationPoint: z2.number().describe("Activation point").optional(),
    hasAlphaVault: z2.boolean().describe("Whether the pool has Meteora alpha vault or not").default(false)
  }),
  handler: async (agent, input) => {
    try {
      const tokenAMint = new PublicKey4(input.tokenAMint);
      const tokenBMint = new PublicKey4(input.tokenBMint);
      const tokenAMintInfo = await agent.wallet.getConnection().getAccountInfo(tokenAMint);
      const tokenBMintInfo = await agent.wallet.getConnection().getAccountInfo(tokenBMint);
      if (!tokenAMintInfo) {
        return {
          status: "error",
          message: "failed to fetch tokenAMint info",
          code: "UNKNOWN_ERROR"
        };
      }
      if (!tokenBMintInfo) {
        return {
          status: "error",
          message: "failed to fetch tokenBMint info",
          code: "UNKNOWN_ERROR"
        };
      }
      const tokenADecimals = MintLayout.decode(tokenAMintInfo.data).decimals;
      const tokenBDecimals = MintLayout.decode(tokenBMintInfo.data).decimals;
      const tokenAAmount = new BN3(
        new Decimal(input.tokenAAmount).mul(10 ** tokenADecimals).toString()
      );
      const tokenBAmount = new BN3(
        new Decimal(input.tokenBAmount).mul(10 ** tokenBDecimals).toString()
      );
      const tradeFeeNumerator = new BN3(
        input.tradeFeeNumerator.toString()
      ).toNumber();
      const activationType = input.activationType ?? 1;
      const activationPoint = input.activationPoint ? new BN3(input.activationPoint) : null;
      const hasAlphaVault = input.hasAlphaVault ?? false;
      const transaction = await createMeteoraDynamicAMMPool(
        agent,
        tokenAMint,
        tokenBMint,
        tokenAAmount,
        tokenBAmount,
        {
          activationPoint,
          activationType,
          hasAlphaVault,
          tradeFeeNumerator,
          padding: Array(90).fill(0)
        }
      );
      return {
        status: "success",
        message: "Meteora Dynamic pool created successfully.",
        transaction
      };
    } catch (error) {
      return {
        status: "error",
        message: error.message,
        code: error.code || "UNKNOWN_ERROR"
      };
    }
  }
};
var createMeteoraDynamicAMMPool_default = createMeteoraDynamicAMMPoolAction;

// src/index.ts
var MeteoraPlugin = class extends PluginBase {
  constructor() {
    const methods = {
      createMeteoraDlmmPool,
      createMeteoraDynamicAMMPool
    };
    const actions = [
      createMeteoraDLMMPool_default,
      createMeteoraDynamicAMMPool_default
    ];
    const supportedChains = [
      {
        type: "solana"
      }
    ];
    super("meteora", methods, actions, supportedChains);
  }
  supportsWallet(wallet) {
    return wallet instanceof SolanaWalletBase;
  }
};
var index_default = MeteoraPlugin;
export {
  index_default as default
};