100x-sdk 1.0.1

package/src/modules/param.js

@@ -0,0 +1,171 @@
+const { PublicKey, Transaction, SystemProgram } = require('@solana/web3.js');
+const anchor = require('@coral-xyz/anchor');
+// 统一使用 buffer 包，所有平台一致
+const { Buffer } = require('buffer');
+
+/**
+ * Parameter Module
+ * Handles creation and management of partner parameters
+ */
+class ParamModule {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Create partner parameters
+   * @param {Object} params - Creation parameters
+   * @param {PublicKey} params.partner - Partner public key
+   * @returns {Promise<Object>} Object containing transaction, signers and account info
+   */
+  async createParams({ partner }) {
+    console.log('Param Module - CreateParams:', { 
+      partner: partner.toString()
+    });
+
+    // Calculate Admin account address (globally unique)
+    const [adminAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("admin")],
+      this.sdk.programId
+    );
+
+    // Calculate partner parameters account address (using partner address as seed)
+    const [paramsAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("params"), partner.toBuffer()],
+      this.sdk.programId
+    );
+
+    console.log('Calculated account addresses:');
+    console.log('  Admin account:', adminAccount.toString());
+    console.log('  Partner parameters account:', paramsAccount.toString());
+
+    // Create transaction instructions
+    const createParamsIx = await this.sdk.program.methods
+      .createParams()
+      .accounts({
+        partner: partner,
+        adminAccount: adminAccount,
+        params: paramsAccount,
+        systemProgram: SystemProgram.programId,
+      })
+      .instruction();
+
+    // Create transaction and add instructions
+    const transaction = new Transaction();
+    transaction.add(createParamsIx);
+    
+    console.log('Partner parameters creation transaction built');
+    
+    return {
+      transaction,
+      signers: [], // createParams doesn't need additional signers, only partner signature
+      accounts: {
+        partner,
+        adminAccount,
+        paramsAccount
+      }
+    };
+  }
+
+  /**
+   * Get partner parameters account data
+   * @param {PublicKey} partner - Partner public key
+   * @returns {Promise<Object>} Parameters account data
+   */
+  async getParams(partner) {
+    // 计算合作伙伴参数账户地址
+    const [paramsAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("params"), partner.toBuffer()],
+      this.sdk.programId
+    );
+
+    try {
+      // Check if account exists
+      const accountInfo = await this.sdk.connection.getAccountInfo(paramsAccount);
+      if (!accountInfo) {
+        throw new Error('Partner parameters account does not exist');
+      }
+      
+      // Try to parse data using Anchor
+      if (this.sdk.program.account.params) {
+        const paramsData = await this.sdk.program.account.params.fetch(paramsAccount);
+        return {
+          address: paramsAccount,
+          data: paramsData
+        };
+      } else {
+        // If Anchor is not available, return basic info
+        return {
+          address: paramsAccount,
+          accountInfo: accountInfo
+        };
+      }
+    } catch (error) {
+      throw new Error(`Failed to get partner parameters: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get Admin account data
+   * @returns {Promise<Object>} Admin account data
+   */
+  async getAdmin() {
+    // Calculate Admin account address
+    const [adminAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("admin")],
+      this.sdk.programId
+    );
+
+    try {
+      // 检查账户是否存在
+      const accountInfo = await this.sdk.connection.getAccountInfo(adminAccount);
+      if (!accountInfo) {
+        throw new Error('Admin account does not exist');
+      }
+      
+      // 尝试使用 Anchor 解析数据
+      if (this.sdk.program.account.admin) {
+        const adminData = await this.sdk.program.account.admin.fetch(adminAccount);
+        return {
+          address: adminAccount,
+          data: adminData
+        };
+      } else {
+        // 如果 Anchor 不可用，返回基本信息
+        return {
+          address: adminAccount,
+          accountInfo: accountInfo
+        };
+      }
+    } catch (error) {
+      throw new Error(`Failed to get Admin account: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calculate partner parameters account address
+   * @param {PublicKey} partner - Partner public key
+   * @returns {PublicKey} Parameters account address
+   */
+  getParamsAddress(partner) {
+    const [paramsAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("params"), partner.toBuffer()],
+      this.sdk.programId
+    );
+    return paramsAccount;
+  }
+
+  /**
+   * Calculate Admin account address
+   * @returns {PublicKey} Admin account address
+   */
+  getAdminAddress() {
+    const [adminAccount] = PublicKey.findProgramAddressSync(
+      [Buffer.from("admin")],
+      this.sdk.programId
+    );
+    return adminAccount;
+  }
+}
+
+module.exports = ParamModule;

package/src/modules/simulator/buy_sell_token.js

@@ -0,0 +1,326 @@
+
+
+const { calcLiqTokenBuy, calcLiqTokenSell } = require('./calcLiq');
+
+/**
+ * Simulate token buy transaction - calculate if target token amount can be purchased
+ * 模拟以 Token 数量为目标的买入交易 - 计算是否能买到指定数量的 Token
+ * @param {string} mint - Token address 代币地址
+ * @param {bigint|string|number} buyTokenAmount - Target token amount to buy 目标购买的 Token 数量
+ * @param {string} passOrder - Optional order address to skip (won't be liquidated) 可选的跳过订单地址
+ * @param {Object|null} lastPrice - Token price info, default null
+ * @param {Object|null} ordersData - Orders response object, default null
+ * @returns {Promise<Object>} Token buy simulation result with the following structure:
+ *   - liqResult: {Object} Complete liquidity calculation result from calcLiqTokenBuy, containing:
+ *     - free_lp_sol_amount_sum: {bigint} Total available free liquidity SOL amount
+ *     - free_lp_token_amount_sum: {bigint} Total available free liquidity token amount
+ *     - lock_lp_sol_amount_sum: {bigint} Total locked liquidity SOL amount
+ *     - lock_lp_token_amount_sum: {bigint} Total locked liquidity token amount
+ *     - has_infinite_lp: {boolean} Whether includes infinite liquidity beyond last order
+ *     - pass_order_id: {number} Index of skipped order in array (-1 if none skipped)
+ *     - force_close_num: {number} Number of orders that need force closure for target amount
+ *     - ideal_lp_sol_amount: {bigint} Theoretical minimum SOL required at current price
+ *     - real_lp_sol_amount: {bigint} Actual SOL required considering real liquidity distribution
+ *   - completion: {string} Purchase completion percentage as decimal string (e.g., "85.2", "100.0")
+ *   - slippage: {string} Price slippage percentage as decimal string (e.g., "2.5", "0.8")
+ *   - suggestedTokenAmount: {string} Recommended token amount to buy based on available liquidity
+ *   - suggestedSolAmount: {string} Required SOL amount for suggested token purchase
+ */
+async function simulateTokenBuy(mint, buyTokenAmount, passOrder = null, lastPrice = null, ordersData = null, curveData = null) {
+  // 获取价格和订单数据
+
+  //console.log('simulateTokenBuy', mint, buyTokenAmount, passOrder, lastPrice, ordersData);
+
+  let price = lastPrice;
+  if (!price) {
+    price = await this.sdk.data.price(mint);
+  }
+
+  let orders;
+  if (!ordersData) {
+    const ordersResponse = await this.sdk.data.orders(mint, {
+      type: 'up_orders',
+      limit: this.sdk.MAX_ORDERS_COUNT + 1
+    });
+    // 提取实际的订单数组
+    orders = ordersResponse.data.orders;
+  } else {
+    // 如果传入了 ordersData，从响应对象中提取订单数组并限制长度
+    orders = ordersData.data.orders.slice(0, this.sdk.MAX_ORDERS_COUNT + 1);
+  }
+
+  // 获取动态流动池参数（支持外部传入，避免重复请求）
+  if (!curveData) {
+    try {
+      curveData = await this.sdk.chain.getCurveAccount(mint, { skipBalances: true });
+    } catch (error) {
+      throw new Error(`Failed to get curve account data: ${error.message}`);
+    }
+  }
+
+  // 调用 calcLiqTokenBuy 进行流动性计算（传入动态流动池参数）
+  try {
+    const liqResult = calcLiqTokenBuy(
+      price,
+      buyTokenAmount,
+      orders,
+      this.sdk.MAX_ORDERS_COUNT,
+      passOrder,
+      curveData.initialVirtualSol,
+      curveData.initialVirtualToken
+    );
+
+    // console.log("liqResult:",liqResult);
+
+
+    // console.log('\n=== calcLiqTokenBuy 返回结果 ===');
+    // console.log('自由流动性 SOL 总量:', liqResult.free_lp_sol_amount_sum.toString());
+    // console.log('自由流动性 Token 总量:', liqResult.free_lp_token_amount_sum.toString());
+    // console.log('锁定流动性 SOL 总量:', liqResult.lock_lp_sol_amount_sum.toString());
+    // console.log('锁定流动性 Token 总量:', liqResult.lock_lp_token_amount_sum.toString());
+    // console.log('是否包含无限流动性:', liqResult.has_infinite_lp);
+    // console.log('跳过的订单索引:', liqResult.pass_order_id);
+    // console.log('需要强平的订单数量:', liqResult.force_close_num);
+    // console.log('理想 SOL 使用量:', liqResult.ideal_lp_sol_amount.toString());
+    // console.log('实际 SOL 使用量:', liqResult.real_lp_sol_amount.toString());
+    // console.log('===============================\n');
+
+    // Convert to BigInt for calculations
+    const buyTokenAmountBig = BigInt(buyTokenAmount);
+    const freeTokenAmount = BigInt(liqResult.free_lp_token_amount_sum);
+    const realSolAmount = BigInt(liqResult.real_lp_sol_amount);
+    const idealSolAmount = BigInt(liqResult.ideal_lp_sol_amount);
+
+    // 1. Calculate completion percentage
+    let completionPercentage;
+    if (freeTokenAmount >= buyTokenAmountBig) {
+      completionPercentage = "100.0";
+    } else {
+      const percentage = Math.floor((Number(freeTokenAmount) / Number(buyTokenAmountBig)) * 1000) / 10;
+      completionPercentage = percentage.toFixed(1);
+    }
+
+    // 2. Calculate slippage percentage and get final SOL amount
+    let slippagePercentage;
+    let suggestedLiquidity;
+    let finalRealSolAmount = realSolAmount;
+
+    if (realSolAmount > 0n) {
+      // Normal case: calculate slippage
+      const diff = idealSolAmount > realSolAmount ? idealSolAmount - realSolAmount : realSolAmount - idealSolAmount;
+      const slippage = Math.floor((Number(diff) / Number(idealSolAmount)) * 1000) / 10;
+      slippagePercentage = slippage.toFixed(1);
+    } else {
+      // Special case: real SOL amount is 0, need to recalculate with suggested liquidity
+      const suggestedAmount = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
+
+      const recalcResult = calcLiqTokenBuy(
+        price,
+        suggestedAmount,
+        orders,
+        this.sdk.MAX_ORDERS_COUNT,
+        passOrder,
+        curveData.initialVirtualSol,
+        curveData.initialVirtualToken
+      );
+      
+      const recalcRealSol = BigInt(recalcResult.real_lp_sol_amount);
+      const recalcIdealSol = BigInt(recalcResult.ideal_lp_sol_amount);
+      
+      if (recalcRealSol <= 0n) {
+        throw new Error('Recalculated real SOL amount should be greater than 0');
+      }
+      
+      finalRealSolAmount = recalcRealSol;
+      
+      const diff = recalcIdealSol > recalcRealSol ? recalcIdealSol - recalcRealSol : recalcRealSol - recalcIdealSol;
+      const slippage = Math.floor((Number(diff) / Number(recalcIdealSol)) * 1000) / 10;
+      slippagePercentage = slippage.toFixed(1);
+    }
+
+    // 3. Calculate suggested liquidity
+    if (completionPercentage === "100.0") {
+      suggestedLiquidity = buyTokenAmountBig.toString();
+    } else {
+      const suggested = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
+      suggestedLiquidity = suggested.toString();
+    }
+
+    return {
+      liqResult,
+      completion: completionPercentage,
+      slippage: slippagePercentage,
+      suggestedTokenAmount: suggestedLiquidity,
+      suggestedSolAmount: finalRealSolAmount.toString()
+    };
+  } catch (error) {
+    console.error('calcLiqTokenBuy 调用失败:', error);
+    throw error;
+  }
+}
+
+
+/**
+ * Simulate token sell transaction analysis
+ * @param {string} mint - Token address
+ * @param {bigint|string|number} sellTokenAmount - Token amount to sell (u64 format, precision 10^9)
+ * @param {string} passOrder - Optional order address to skip (won't be liquidated) 可选的跳过订单地址
+ * @param {Object|null} lastPrice - Token price info, default null
+ * @param {Object|null} ordersData - Orders response object, default null
+ * @returns {Promise<Object>} Token sell simulation result with the following structure:
+ *   - liqResult: {Object} Complete liquidity calculation result from calcLiqTokenSell, containing:
+ *     - free_lp_sol_amount_sum: {bigint} Total available free liquidity SOL obtainable from selling
+ *     - free_lp_token_amount_sum: {bigint} Maximum tokens sellable without force closing orders
+ *     - lock_lp_sol_amount_sum: {bigint} Total locked liquidity SOL amount (excluding skipped orders)
+ *     - lock_lp_token_amount_sum: {bigint} Total locked liquidity token amount (excluding skipped orders)
+ *     - has_infinite_lp: {boolean} Whether includes infinite liquidity to minimum price
+ *     - pass_order_id: {number} Index of skipped order in array (-1 if none skipped)
+ *     - force_close_num: {number} Number of orders that need force closure for target sell amount
+ *     - ideal_lp_sol_amount: {bigint} Theoretical maximum SOL obtainable at current price
+ *     - real_lp_sol_amount: {bigint} Actual SOL obtainable considering real liquidity distribution
+ *   - completion: {string} Sell completion percentage as decimal string (e.g., "85.2", "100.0")
+ *   - slippage: {string} Price slippage percentage as decimal string (e.g., "2.5", "0.8")
+ *   - suggestedTokenAmount: {string} Recommended token amount to sell based on available liquidity
+ *   - suggestedSolAmount: {string} Expected SOL amount from suggested token sale
+ */
+async function simulateTokenSell(mint, sellTokenAmount, passOrder = null, lastPrice = null, ordersData = null, curveData = null) {
+  // 获取价格和订单数据
+  let price = lastPrice;
+  if (!price) {
+    price = await this.sdk.data.price(mint);
+  }
+
+  //console.log("price=",price);
+
+  let orders;
+  if (!ordersData) {
+    const ordersResponse = await this.sdk.data.orders(mint, {
+      type: 'down_orders',
+      limit: this.sdk.MAX_ORDERS_COUNT + 1
+    });
+    // 提取实际的订单数组
+    orders = ordersResponse.data.orders;
+  } else {
+    // 如果传入了 ordersData，从响应对象中提取订单数组并限制长度
+    orders = ordersData.data.orders.slice(0, this.sdk.MAX_ORDERS_COUNT + 1);
+  }
+
+  // 获取动态流动池参数（支持外部传入，避免重复请求）
+  if (!curveData) {
+    try {
+      curveData = await this.sdk.chain.getCurveAccount(mint, { skipBalances: true });
+    } catch (error) {
+      throw new Error(`Failed to get curve account data: ${error.message}`);
+    }
+  }
+
+  // console.log('simulateTokenSell 获取的数据:');
+  // console.log('价格:', price);
+  // console.log('订单数量:', orders.length);
+  // orders.forEach((order, i) => console.log(`订单${i}: start=${order.lock_lp_start_price}, end=${order.lock_lp_end_price}, sol=${order.lock_lp_sol_amount}, token=${order.lock_lp_token_amount}`));
+
+  // 调用 calcLiqTokenSell 进行流动性计算（传入动态流动池参数）
+  try {
+    const liqResult = calcLiqTokenSell(
+      price,
+      sellTokenAmount,
+      orders,
+      this.sdk.MAX_ORDERS_COUNT,
+      passOrder,
+      curveData.initialVirtualSol,
+      curveData.initialVirtualToken
+    );
+
+    // console.log('\n=== calcLiqTokenSell 返回结果 ===');
+    // console.log('自由流动性 SOL 总量:', liqResult.free_lp_sol_amount_sum.toString());
+    // console.log('自由流动性 Token 总量:', liqResult.free_lp_token_amount_sum.toString());
+    // console.log('锁定流动性 SOL 总量:', liqResult.lock_lp_sol_amount_sum.toString());
+    // console.log('锁定流动性 Token 总量:', liqResult.lock_lp_token_amount_sum.toString());
+    // console.log('是否包含无限流动性:', liqResult.has_infinite_lp);
+    // console.log('跳过的订单索引:', liqResult.pass_order_id);
+    // console.log('需要强平的订单数量:', liqResult.force_close_num);
+    // console.log('理想 SOL 获得量:', liqResult.ideal_lp_sol_amount.toString());
+    // console.log('实际 SOL 获得量:', liqResult.real_lp_sol_amount.toString());
+    // console.log('===============================\n');
+
+    // Convert to BigInt for calculations
+    const sellTokenAmountBig = BigInt(sellTokenAmount);
+    const freeTokenAmount = BigInt(liqResult.free_lp_token_amount_sum);
+    const realSolAmount = BigInt(liqResult.real_lp_sol_amount);
+    const idealSolAmount = BigInt(liqResult.ideal_lp_sol_amount);
+
+    // 1. Calculate completion percentage
+    let completionPercentage;
+    if (freeTokenAmount >= sellTokenAmountBig) {
+      completionPercentage = "100.0";
+    } else {
+      const percentage = Math.floor((Number(freeTokenAmount) / Number(sellTokenAmountBig)) * 1000) / 10;
+      completionPercentage = percentage.toFixed(1);
+    }
+
+    // 2. Calculate slippage percentage and get final SOL amount
+    let slippagePercentage;
+    let suggestedLiquidity;
+    let finalRealSolAmount = realSolAmount;
+
+    if (realSolAmount > 0n) {
+      // Normal case: calculate slippage
+      const diff = idealSolAmount > realSolAmount ? idealSolAmount - realSolAmount : realSolAmount - idealSolAmount;
+      const slippage = Math.floor((Number(diff) / Number(idealSolAmount)) * 1000) / 10;
+      slippagePercentage = slippage.toFixed(1);
+    } else {
+      // Special case: real SOL amount is 0, need to recalculate with suggested liquidity
+      const suggestedAmount = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
+      
+      const recalcResult = calcLiqTokenSell(
+        price,
+        suggestedAmount,
+        orders,
+        this.sdk.MAX_ORDERS_COUNT,
+        passOrder,
+        curveData.initialVirtualSol,
+        curveData.initialVirtualToken
+      );
+      
+      const recalcRealSol = BigInt(recalcResult.real_lp_sol_amount);
+      const recalcIdealSol = BigInt(recalcResult.ideal_lp_sol_amount);
+      
+      if (recalcRealSol <= 0n) {
+        throw new Error('Recalculated real SOL amount should be greater than 0');
+      }
+      
+      finalRealSolAmount = recalcRealSol;
+      
+      const diff = recalcIdealSol > recalcRealSol ? recalcIdealSol - recalcRealSol : recalcRealSol - recalcIdealSol;
+      const slippage = Math.floor((Number(diff) / Number(recalcIdealSol)) * 1000) / 10;
+      slippagePercentage = slippage.toFixed(1);
+    }
+
+    // 3. Calculate suggested liquidity
+    if (completionPercentage === "100.0") {
+      suggestedLiquidity = sellTokenAmountBig.toString();
+    } else {
+      const suggested = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
+      suggestedLiquidity = suggested.toString();
+    }
+
+    return {
+      liqResult,
+      completion: completionPercentage,
+      slippage: slippagePercentage,
+      suggestedTokenAmount: suggestedLiquidity,
+      suggestedSolAmount: finalRealSolAmount.toString()
+    };
+  } catch (error) {
+    console.error('calcLiqTokenSell 调用失败:', error.message);
+    throw error;
+  }
+}
+
+
+
+module.exports = {
+    simulateTokenBuy,
+    simulateTokenSell
+};
+