pinpet-sdk 2.1.7 → 2.1.8

package/dist/pinpet-sdk.cjs.js

@@ -16490,28 +16490,86 @@ class TokenModule$1 {
   }
 
   /**
-   * Create new token
-   * @param {Object} params - Creation parameters
-   * @param {Keypair} params.mint - Token mint keypair
-   * @param {string} params.name - Token name
-   * @param {string} params.symbol - Token symbol
-   * @param {string} params.uri - Metadata URI
-   * @param {PublicKey} params.payer - Creator public key (payer)
-   * @returns {Promise<Object>} Object containing transaction, signers and account info
+   * 创建新代币
+   * @param {Object} params - 创建参数
+   * @param {Keypair} params.mint - 代币mint keypair
+   * @param {string} params.name - 代币名称
+   * @param {string} params.symbol - 代币符号
+   * @param {string} params.uri - 元数据URI
+   * @param {PublicKey} params.payer - 创建者公钥（付款方）
+   *
+   * === 第二阶段新增：高级版池子可选参数 ===
+   * @param {anchor.BN} [params.customLpSol] - 自定义流动池SOL数量（lamports，9位精度）
+   *   - 不传或传null：创建普通版池子，使用默认值30 SOL
+   *   - 传入值：创建高级版池子，需在 10 SOL ~ 1000 SOL 范围内
+   *   - ⚠️ 必须与 customLpToken, customBorrowRatio, customBorrowDuration 同时提供
+   *
+   * @param {anchor.BN} [params.customLpToken] - 自定义流动池Token数量（最小单位，9位精度）
+   *   - 不传或传null：使用默认值10.73亿 Token
+   *   - 传入值：需在 1亿 ~ 100亿 Token 范围内
+   *
+   * @param {number} [params.customBorrowRatio] - 自定义借贷池代币占比（5-30表示5%-30%）
+   *   - 不传或传null：使用默认值20%
+   *   - 传入值：需在 5 ~ 30 范围内
+   *
+   * @param {number} [params.customBorrowDuration] - 自定义借贷时长（秒）
+   *   - 不传或传null：使用Params账户配置的默认值
+   *   - 传入值：需在 3天(259200秒) ~ 6个月(15552000秒) 范围内
+   *
+   * @returns {Promise<Object>} 包含transaction、signers和账户信息的对象
+   *
+   * @example
+   * // 创建普通版代币（使用默认参数）
+   * const result = await sdk.token.create({
+   *   mint: mintKeypair,
+   *   name: "My Token",
+   *   symbol: "MTK",
+   *   uri: "https://example.com/metadata.json",
+   *   payer: wallet.publicKey
+   * });
+   *
+   * @example
+   * // 创建高级版代币（自定义流动池参数）
+   * const anchor = require('@coral-xyz/anchor');
+   * const result = await sdk.token.create({
+   *   mint: mintKeypair,
+   *   name: "Advanced Token",
+   *   symbol: "ADV",
+   *   uri: "https://example.com/metadata.json",
+   *   payer: wallet.publicKey,
+   *   customLpSol: new anchor.BN('60000000000'),              // 60 SOL
+   *   customLpToken: new anchor.BN('1073000000000000000'),    // 10.73亿 Token
+   *   customBorrowRatio: 15,                                   // 15%
+   *   customBorrowDuration: 7 * 24 * 3600                      // 7天
+   * });
    */
   async create({
     mint,
     name,
     symbol,
     uri,
-    payer
+    payer,
+    // 新增参数
+    customLpSol = null,
+    customLpToken = null,
+    customBorrowRatio = null,
+    customBorrowDuration = null
   }) {
     console.log('Token Module - Create:', {
       mint: mint.publicKey.toString(),
       name,
       symbol,
       uri,
-      payer: payer.toString()
+      payer: payer.toString(),
+      // 新增参数日志
+      poolType: (customLpSol === null && customLpToken === null &&
+                 customBorrowRatio === null && customBorrowDuration === null)
+                ? 'Standard (default params)'
+                : 'Advanced (custom params)',
+      customLpSol: customLpSol?.toString() || 'null',
+      customLpToken: customLpToken?.toString() || 'null',
+      customBorrowRatio: customBorrowRatio ?? 'null',
+      customBorrowDuration: customBorrowDuration ?? 'null'
     });
 
     // Calculate borrowing liquidity pool account address (borrowing_curve)
@@ -16587,9 +16645,17 @@ class TokenModule$1 {
       units: 400000
     });
 
-    // Create transaction instructions
+    // 构建创建代币指令（传入自定义参数）
     const createIx = await this.sdk.program.methods
-      .create(name, symbol, uri)
+      .createToken(
+        name,
+        symbol,
+        uri,
+        customLpSol,           // Option<u64>
+        customLpToken,         // Option<u64>
+        customBorrowRatio,     // Option<u8>
+        customBorrowDuration   // Option<u32>
+      )
       .accounts({
         payer: payer,
         mintAccount: mint.publicKey,
@@ -41822,8 +41888,10 @@ var decimalExports = decimal.exports;
 
 const Decimal = decimalExports;
 
-// Configure Decimal.js to use 28-bit precision to match rust_decimal
-Decimal.set({ precision: 28 }); 
+// Configure Decimal.js to use 50-bit precision for better accuracy with tiny prices
+// Increased from 28 to 50 to handle extremely small prices (e.g., 0.000000041571)
+// ROUND_HALF_UP ensures consistent rounding behavior
+Decimal.set({ precision: 50, rounding: Decimal.ROUND_HALF_UP }); 
 
 
 /**
@@ -42104,36 +42172,70 @@ class CurveAMM$7 {
     }
 
     /**
-     * Calculate initial k value
-     * 
+     * 根据自定义初始储备量计算 k 值
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量（实际值，非lamports）
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量（实际值，非最小单位）
+     * @returns {Decimal} k值
+     *
+     * @example
+     * // 使用默认参数（30 SOL, 10.73亿 Token）
+     * const k1 = CurveAMM.calculateK(30, 1073000000);
+     *
+     * // 使用自定义参数（60 SOL, 10.73亿 Token）
+     * const k2 = CurveAMM.calculateK(60, 1073000000);
+     */
+    static calculateK(initialVirtualSol, initialVirtualToken) {
+        const sol = new Decimal(initialVirtualSol);
+        const token = new Decimal(initialVirtualToken);
+        return sol.mul(token);
+    }
+
+    /**
+     * 使用默认参数计算初始k值（向后兼容）
      * @returns {Decimal} Product k value of initial reserves
      */
     static calculateInitialK() {
-        return this.INITIAL_SOL_RESERVE_DECIMAL.mul(this.INITIAL_TOKEN_RESERVE_DECIMAL);
+        return this.calculateK(
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
+
+    /**
+     * 根据自定义初始储备量获取初始价格
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {bigint|null} u128格式的初始价格
+     */
+    static getInitialPriceWithParams(initialVirtualSol, initialVirtualToken) {
+        const sol = new Decimal(initialVirtualSol);
+        const token = new Decimal(initialVirtualToken);
+        const initialPrice = sol.div(token);
+        return this.decimalToU128(initialPrice);
     }
 
     /**
+     * 使用默认参数获取初始价格（向后兼容）
      * Get initial price (SOL amount for 1 token)
-     * 
+     *
      * @returns {bigint|null} Initial price in u128 format, returns null if calculation fails
      */
     static getInitialPrice() {
-        // Calculate initial price = initial SOL reserve / initial Token reserve
-        const initialPrice = this.INITIAL_SOL_RESERVE_DECIMAL.div(this.INITIAL_TOKEN_RESERVE_DECIMAL);
-
-        // Convert to u128 format
-        return this.decimalToU128(initialPrice);
+        return this.getInitialPriceWithParams(
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
     }
 
     /**
-     * Calculate SOL required and token amount obtained when buying tokens from low to high price
-     * 
-     * @param {bigint|string|number} startLowPrice - Starting price (lower)
-     * @param {bigint|string|number} endHighPrice - Target price (higher)
-     * @returns {[bigint, bigint]|null} Returns [SOL amount to invest, token amount to obtain] on success, null on failure
-     * SOL amount in 9-digit precision rounded up; token amount in 9-digit precision rounded down 
+     * 根据自定义初始储备量计算从低价买入到高价所需的SOL和获得的Token
+     * @param {bigint|string|number} startLowPrice - 起始价格（较低）
+     * @param {bigint|string|number} endHighPrice - 目标价格（较高）
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {[bigint, bigint]|null} 成功返回 [需投入SOL数量, 获得token数量], 失败返回null
      */
-    static buyFromPriceToPrice(startLowPrice, endHighPrice) {
+    static buyFromPriceToPriceWithParams(startLowPrice, endHighPrice, initialVirtualSol, initialVirtualToken) {
         // Convert to Decimal for calculation
         const startPriceDec = this.u128ToDecimal(startLowPrice);
         const endPriceDec = this.u128ToDecimal(endHighPrice);
@@ -42143,8 +42245,8 @@ class CurveAMM$7 {
             return null;
         }
 
-        // Use initial k value
-        const k = this.calculateInitialK();
+        // Use custom k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
 
         // Calculate reserves for starting and ending states
         const startReserves = this.calculateReservesByPrice(startPriceDec, k);
@@ -42181,77 +42283,63 @@ class CurveAMM$7 {
     }
 
     /**
-     * Calculate SOL amount obtained when selling tokens from high to low price
-     * 
-     * @param {bigint|string|number} startHighPrice - Starting price (higher)
-     * @param {bigint|string|number} endLowPrice - Target price (lower)
-     * @returns {[bigint, bigint]|null} Returns [token amount to sell, SOL amount to obtain] on success, null on failure
-     * token amount in 9-digit precision rounded up; SOL amount in 9-digit precision rounded down
+     * 使用默认参数计算从低价买入到高价（向后兼容）
+     * Calculate SOL required and token amount obtained when buying tokens from low to high price
+     *
+     * @param {bigint|string|number} startLowPrice - Starting price (lower)
+     * @param {bigint|string|number} endHighPrice - Target price (higher)
+     * @returns {[bigint, bigint]|null} Returns [SOL amount to invest, token amount to obtain] on success, null on failure
+     * SOL amount in 9-digit precision rounded up; token amount in 9-digit precision rounded down
      */
-    static sellFromPriceToPrice(startHighPrice, endLowPrice) {
-        // console.log('\n=== sellFromPriceToPrice debug info ===');
-        // console.log('Input parameters:');
-        // console.log('  startHighPrice:', startHighPrice);
-        // console.log('  endLowPrice:', endLowPrice);
+    static buyFromPriceToPrice(startLowPrice, endHighPrice) {
+        return this.buyFromPriceToPriceWithParams(
+            startLowPrice,
+            endHighPrice,
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
 
+    /**
+     * 根据自定义初始储备量计算从高价卖出到低价所需的Token和获得的SOL
+     * @param {bigint|string|number} startHighPrice - 起始价格（较高）
+     * @param {bigint|string|number} endLowPrice - 目标价格（较低）
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {[bigint, bigint]|null} 成功返回 [需卖出token数量, 获得SOL数量], 失败返回null
+     */
+    static sellFromPriceToPriceWithParams(startHighPrice, endLowPrice, initialVirtualSol, initialVirtualToken) {
         // Convert to Decimal for calculation
         const startPriceDec = this.u128ToDecimal(startHighPrice);
         const endPriceDec = this.u128ToDecimal(endLowPrice);
 
-        // console.log('Price conversion results:');
-        // console.log('  startPriceDec:', startPriceDec.toString());
-        // console.log('  endPriceDec:', endPriceDec.toString());
-
         // Ensure starting price is higher than ending price
         if (startPriceDec.lte(endPriceDec)) {
-            // console.log('❌ Failure reason: starting price is lower than or equal to ending price');
-            // console.log('  startPriceDec.lte(endPriceDec):', startPriceDec.lte(endPriceDec));
             return null;
         }
 
-        // Use initial k value
-        const k = this.calculateInitialK();
-        //console.log('k value:', k.toString());
+        // Use custom k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
 
         // Calculate reserves for starting and ending states
         const startReserves = this.calculateReservesByPrice(startPriceDec, k);
         const endReserves = this.calculateReservesByPrice(endPriceDec, k);
 
-        // console.log('Reserve calculation results:');
-        // console.log('  startReserves:', startReserves ? [startReserves[0].toString(), startReserves[1].toString()] : null);
-        // console.log('  endReserves:', endReserves ? [endReserves[0].toString(), endReserves[1].toString()] : null);
-
-        // if (!startReserves || !endReserves) {
-        //     console.log('❌ Failure reason: reserve calculation failed');
-        //     console.log('  startReserves:', startReserves);
-        //     console.log('  endReserves:', endReserves);
-        //     return null;
-        // }
+        if (!startReserves || !endReserves) {
+            return null;
+        }
 
         const [startSolReserve, startTokenReserve] = startReserves;
         const [endSolReserve, endTokenReserve] = endReserves;
 
-        // console.log('Detailed reserves:');
-        // console.log('  Starting state - SOL reserve:', startSolReserve.toString());
-        // console.log('  Starting state - Token reserve:', startTokenReserve.toString());
-        // console.log('  Ending state - SOL reserve:', endSolReserve.toString());
-        // console.log('  Ending state - Token reserve:', endTokenReserve.toString());
-
         // Calculate token amount to sell (increase in token reserves)
         const tokenInputAmount = endTokenReserve.sub(startTokenReserve);
 
         // Calculate SOL amount to obtain (decrease in SOL reserves)
         const solOutputAmount = startSolReserve.sub(endSolReserve);
 
-        // console.log('Transaction calculation results:');
-        // console.log('  Token amount to sell (tokenInputAmount):', tokenInputAmount.toString());
-        // console.log('  SOL amount to obtain (solOutputAmount):', solOutputAmount.toString());
-
         // Check if calculation results are valid
         if (tokenInputAmount.lte(0) || solOutputAmount.lte(0)) {
-            // console.log('❌ Failure reason: invalid transaction amount calculation results');
-            // console.log('  tokenInputAmount.lte(0):', tokenInputAmount.lte(0));
-            // console.log('  solOutputAmount.lte(0):', solOutputAmount.lte(0));
             return null;
         }
 
@@ -42260,28 +42348,94 @@ class CurveAMM$7 {
         const tokenAmountU64 = this.tokenDecimalToU64Ceil(tokenInputAmount);
         const solAmountU64 = this.solDecimalToU64(solOutputAmount);
 
-        // console.log('u64 conversion results:');
-        // console.log('  tokenAmountU64:', tokenAmountU64);
-        // console.log('  solAmountU64:', solAmountU64);
-
         if (tokenAmountU64 === null || solAmountU64 === null) {
-            // console.log('❌ Failure reason: u64 conversion failed');
-            // console.log('  tokenAmountU64 === null:', tokenAmountU64 === null);
-            // console.log('  solAmountU64 === null:', solAmountU64 === null);
             return null;
         }
 
-        // console.log('✅ Success! Return results:');
-        // console.log('  Token amount to sell:', tokenAmountU64.toString());
-        // console.log('  SOL amount to obtain:', solAmountU64.toString());
-        // console.log('=== sellFromPriceToPrice debug end ===\n');
-
         return [tokenAmountU64, solAmountU64];
     }
 
+    /**
+     * 使用默认参数计算从高价卖出到低价（向后兼容）
+     * Calculate SOL amount obtained when selling tokens from high to low price
+     *
+     * @param {bigint|string|number} startHighPrice - Starting price (higher)
+     * @param {bigint|string|number} endLowPrice - Target price (lower)
+     * @returns {[bigint, bigint]|null} Returns [token amount to sell, SOL amount to obtain] on success, null on failure
+     * token amount in 9-digit precision rounded up; SOL amount in 9-digit precision rounded down
+     */
+    static sellFromPriceToPrice(startHighPrice, endLowPrice) {
+        return this.sellFromPriceToPriceWithParams(
+            startHighPrice,
+            endLowPrice,
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
+
+    /**
+     * 根据价格和自定义k值计算储备量
+     * @param {bigint|string} price - u128格式价格
+     * @param {Decimal} k - 自定义k值
+     * @returns {{solReserve: Decimal, tokenReserve: Decimal}|null}
+     */
+    static priceToReservesWithK(price, k) {
+        const priceDecimal = this.u128ToDecimal(price);
+
+        // Check if input parameters are valid
+        if (priceDecimal.lte(0) || k.lte(0)) {
+            return null;
+        }
+
+        // Minimum price check to prevent overflow
+        if (priceDecimal.lt(this.INITIAL_MIN_PRICE_DECIMAL)) {
+            return null;
+        }
+
+        // token_reserve = sqrt(k / price)
+        const tokenReserve = k.div(priceDecimal).sqrt();
+
+        // sol_reserve = k / token_reserve
+        const solReserve = k.div(tokenReserve);
+
+        if (tokenReserve.isNaN() || solReserve.isNaN()) {
+            return null;
+        }
+
+        return {
+            solReserve,
+            tokenReserve
+        };
+    }
+
+    /**
+     * 根据价格和自定义初始储备量计算储备量
+     * @param {bigint|string} price - u128格式价格
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {{solReserve: Decimal, tokenReserve: Decimal}|null}
+     */
+    static priceToReservesWithParams(price, initialVirtualSol, initialVirtualToken) {
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
+        return this.priceToReservesWithK(price, k);
+    }
+
+    /**
+     * 使用默认参数根据价格计算储备量（向后兼容）
+     * @param {bigint|string} price - u128格式价格
+     * @returns {{solReserve: Decimal, tokenReserve: Decimal}|null}
+     */
+    static priceToReserves(price) {
+        return this.priceToReservesWithParams(
+            price,
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
+
     /**
      * Calculate reserves given a price
-     * 
+     *
      * @param {Decimal} price - Price, representing SOL amount for 1 token
      * @param {Decimal} k - Constant product
      * @returns {[Decimal, Decimal]|null} Returns [SOL reserve, token reserve] on success, null on failure
@@ -42297,6 +42451,19 @@ class CurveAMM$7 {
             return null;
         }
 
+        // Warning for extremely small prices that may have precision issues
+        const warningPrice = new Decimal('0.0000001'); // 10^-7
+        if (price.lt(warningPrice)) {
+            // Only log once per execution to avoid spam (use a static flag)
+            if (!this._tinyPriceWarningShown) {
+                console.warn(
+                    `[CurveAMM] 警告: 价格非常小 (${price.toString()})，` +
+                    `计算精度可能受影响。建议验证结果。`
+                );
+                this._tinyPriceWarningShown = true;
+            }
+        }
+
         // According to AMM formula: k = sol_reserve * token_reserve
         // and price = sol_reserve / token_reserve
         // We get: sol_reserve = price * token_reserve
@@ -42317,18 +42484,33 @@ class CurveAMM$7 {
             return null;
         }
 
+        // Verify calculation accuracy by checking if k is preserved (optional but recommended)
+        // Only check for tiny prices to minimize performance impact
+        if (price.lt(warningPrice)) {
+            const verifyK = solReserve.mul(tokenReserve);
+            const kDiff = verifyK.sub(k).abs().div(k);
+
+            // If k value deviation exceeds 0.1%, log a warning
+            if (kDiff.gt('0.001')) {
+                console.warn(
+                    `[CurveAMM] 储备量计算精度偏差: ${kDiff.mul(100).toFixed(4)}%，` +
+                    `价格=${price.toString()}`
+                );
+            }
+        }
+
         return [solReserve, tokenReserve];
     }
 
     /**
-     * Calculate token output amount and ending price based on starting price and SOL input amount
-     * 
-     * @param {bigint|string|number} startLowPrice - Starting price
-     * @param {bigint|string|number} solInputAmount - SOL amount for buying
-     * @returns {[bigint, bigint]|null} Returns [price after transaction, token amount obtained] on success, null on failure
-     * Price rounded down, token amount rounded down
+     * 根据自定义初始储备量，基于起始价格和SOL输入量计算token输出量和结束价格
+     * @param {bigint|string|number} startLowPrice - 起始价格
+     * @param {bigint|string|number} solInputAmount - 用于买入的SOL数量
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {[bigint, bigint]|null} 成功返回 [交易后价格, 获得的token数量], 失败返回null
      */
-    static buyFromPriceWithSolInput(startLowPrice, solInputAmount) {
+    static buyFromPriceWithSolInputWithParams(startLowPrice, solInputAmount, initialVirtualSol, initialVirtualToken) {
         // Convert to Decimal for calculation
         const startPriceDec = this.u128ToDecimal(startLowPrice);
         const solInputDec = this.u64ToSolDecimal(solInputAmount);
@@ -42337,20 +42519,20 @@ class CurveAMM$7 {
         if (startPriceDec.lte(0)) {
             return null;
         }
-        
+
         // If SOL input amount is 0, return unchanged price and token output of 0
         if (solInputDec.eq(0)) {
             const endPriceU128 = this.decimalToU128(startPriceDec);
             if (endPriceU128 === null) return null;
             return [endPriceU128, 0n];
         }
-        
+
         if (solInputDec.lt(0)) {
             return null;
         }
 
-        // Use initial k value
-        const k = this.calculateInitialK();
+        // Use custom k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
 
         // Calculate reserves for starting state
         const startReserves = this.calculateReservesByPrice(startPriceDec, k);
@@ -42387,37 +42569,54 @@ class CurveAMM$7 {
     }
 
     /**
-     * Calculate SOL output amount and ending price based on starting price and token input amount
-     * 
-     * @param {bigint|string|number} startHighPrice - Starting price
-     * @param {bigint|string|number} tokenInputAmount - Token amount to sell
-     * @returns {[bigint, bigint]|null} Returns [price after transaction, SOL amount obtained] on success, null on failure
-     * Price rounded down, SOL amount rounded down
+     * 使用默认参数计算token输出量和结束价格（向后兼容）
+     * Calculate token output amount and ending price based on starting price and SOL input amount
+     *
+     * @param {bigint|string|number} startLowPrice - Starting price
+     * @param {bigint|string|number} solInputAmount - SOL amount for buying
+     * @returns {[bigint, bigint]|null} Returns [price after transaction, token amount obtained] on success, null on failure
+     * Price rounded down, token amount rounded down
      */
-    static sellFromPriceWithTokenInput(startHighPrice, tokenInputAmount) {
+    static buyFromPriceWithSolInput(startLowPrice, solInputAmount) {
+        return this.buyFromPriceWithSolInputWithParams(
+            startLowPrice,
+            solInputAmount,
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
+
+    /**
+     * 根据自定义初始储备量，基于起始价格和token输入量计算SOL输出量和结束价格
+     * @param {bigint|string|number} startHighPrice - 起始价格
+     * @param {bigint|string|number} tokenInputAmount - 要卖出的token数量
+     * @param {string|number|Decimal} initialVirtualSol - 初始虚拟SOL储备量
+     * @param {string|number|Decimal} initialVirtualToken - 初始虚拟Token储备量
+     * @returns {[bigint, bigint]|null} 成功返回 [交易后价格, 获得的SOL数量], 失败返回null
+     */
+    static sellFromPriceWithTokenInputWithParams(startHighPrice, tokenInputAmount, initialVirtualSol, initialVirtualToken) {
         // Convert to Decimal for calculation
         const startPriceDec = this.u128ToDecimal(startHighPrice);
         const tokenInputDec = this.u64ToTokenDecimal(tokenInputAmount);
 
-        //console.log("startHighPrice, tokenInputAmount",startHighPrice, tokenInputAmount)
         // Check if input parameters are valid
         if (startPriceDec.lte(0)) {
             return null;
         }
-        
+
         // If token input amount is 0, return unchanged price and SOL output of 0
         if (tokenInputDec.eq(0)) {
             const endPriceU128 = this.decimalToU128(startPriceDec);
             if (endPriceU128 === null) return null;
             return [endPriceU128, 0n];
         }
-        
+
         if (tokenInputDec.lt(0)) {
             return null;
         }
 
-        // Use initial k value
-        const k = this.calculateInitialK();
+        // Use custom k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
 
         // Calculate reserves for starting state
         const startReserves = this.calculateReservesByPrice(startPriceDec, k);
@@ -42453,6 +42652,24 @@ class CurveAMM$7 {
         return [endPriceU128, solAmountU64];
     }
 
+    /**
+     * 使用默认参数计算SOL输出量和结束价格（向后兼容）
+     * Calculate SOL output amount and ending price based on starting price and token input amount
+     *
+     * @param {bigint|string|number} startHighPrice - Starting price
+     * @param {bigint|string|number} tokenInputAmount - Token amount to sell
+     * @returns {[bigint, bigint]|null} Returns [price after transaction, SOL amount obtained] on success, null on failure
+     * Price rounded down, SOL amount rounded down
+     */
+    static sellFromPriceWithTokenInput(startHighPrice, tokenInputAmount) {
+        return this.sellFromPriceWithTokenInputWithParams(
+            startHighPrice,
+            tokenInputAmount,
+            this.INITIAL_SOL_RESERVE_DECIMAL,
+            this.INITIAL_TOKEN_RESERVE_DECIMAL
+        );
+    }
+
     /**
      * Calculate required SOL input amount and ending price based on starting price and expected token output amount
      * 
@@ -47474,6 +47691,14 @@ class ChainModule$1 {
         // Creator address
         creator: decodedData.creator.toString(),
 
+        // === 第一阶段新增字段：动态流动池参数 ===
+        initialVirtualSol: BigInt(decodedData.initialVirtualSol.toString()),        // u64, lamports
+        initialVirtualToken: BigInt(decodedData.initialVirtualToken.toString()),    // u64, 最小单位
+
+        // === 第二阶段新增字段：高级版池子参数 ===
+        poolType: decodedData.poolType,                           // u8, 0=普通版, 1=高级版
+        borrowPoolRatio: decodedData.borrowPoolRatio,            // u8, 5-30表示5%-30%
+
         // SOL balance information
         baseFeeRecipientBalance: baseFeeRecipientBalance,  // Unit: lamports
         feeRecipientBalance: feeRecipientBalance,          // Unit: lamports
@@ -48917,8 +49142,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account"
@@ -49409,8 +49633,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account",
@@ -49621,8 +49844,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account",
@@ -49833,8 +50055,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account"
@@ -50182,6 +50403,30 @@ var instructions = [
 			{
 				name: "uri",
 				type: "string"
+			},
+			{
+				name: "custom_lp_sol",
+				type: {
+					option: "u64"
+				}
+			},
+			{
+				name: "custom_lp_token",
+				type: {
+					option: "u64"
+				}
+			},
+			{
+				name: "custom_borrow_ratio",
+				type: {
+					option: "u8"
+				}
+			},
+			{
+				name: "custom_borrow_duration",
+				type: {
+					option: "u32"
+				}
 			}
 		]
 	},
@@ -50454,6 +50699,30 @@ var instructions = [
 			{
 				name: "uri",
 				type: "string"
+			},
+			{
+				name: "custom_lp_sol",
+				type: {
+					option: "u64"
+				}
+			},
+			{
+				name: "custom_lp_token",
+				type: {
+					option: "u64"
+				}
+			},
+			{
+				name: "custom_borrow_ratio",
+				type: {
+					option: "u8"
+				}
+			},
+			{
+				name: "custom_borrow_duration",
+				type: {
+					option: "u32"
+				}
 			}
 		]
 	},
@@ -50472,8 +50741,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account",
@@ -51011,8 +51279,7 @@ var instructions = [
 		accounts: [
 			{
 				name: "payer",
-				writable: true,
-				signer: true
+				writable: true
 			},
 			{
 				name: "mint_account",
@@ -51780,7 +52047,7 @@ var errors = [
 	{
 		code: 6048,
 		name: "ExceedsMaxSolAmount",
-		msg: "User-set max SOL amount insufficient"
+		msg: "Required SOL amount exceeds user-set maximum"
 	},
 	{
 		code: 6049,
@@ -51790,12 +52057,12 @@ var errors = [
 	{
 		code: 6050,
 		name: "InsufficientRepayment",
-		msg: "Close proceeds insufficient to repay loan"
+		msg: "Insufficient proceeds to repay loan"
 	},
 	{
 		code: 6051,
 		name: "InsufficientBorrowingReserve",
-		msg: "Borrow request exceeds available reserve"
+		msg: "Insufficient borrowing reserve"
 	},
 	{
 		code: 6052,
@@ -51805,7 +52072,7 @@ var errors = [
 	{
 		code: 6053,
 		name: "InsufficientLiquidity",
-		msg: "Insufficient liquidity available in current order"
+		msg: "Insufficient liquidity in current order"
 	},
 	{
 		code: 6054,
@@ -51815,12 +52082,12 @@ var errors = [
 	{
 		code: 6055,
 		name: "TokenAmountDifferenceOutOfRange",
-		msg: "Range calculation error too large in margin trade"
+		msg: "Token amount difference exceeds valid range in margin trade"
 	},
 	{
 		code: 6056,
 		name: "BorrowAmountMismatch",
-		msg: "Borrow amount does not match locked token amount"
+		msg: "Borrow amount mismatch with locked tokens"
 	},
 	{
 		code: 6057,
@@ -51869,188 +52136,228 @@ var errors = [
 	},
 	{
 		code: 6066,
+		name: "SolAmountTooLarge",
+		msg: "SOL amount exceeds maximum limit (10000000 SOL per transaction)"
+	},
+	{
+		code: 6067,
+		name: "RemainingTokenAmountTooSmall",
+		msg: "Remaining token amount below minimum trade requirement"
+	},
+	{
+		code: 6068,
 		name: "TradeCooldownNotExpired",
 		msg: "Trade cooldown period not expired, please try again later"
 	},
 	{
-		code: 6067,
+		code: 6069,
 		name: "ExceedApprovalAmount",
 		msg: "Sell amount exceeds approved amount, please call approval function first"
 	},
 	{
-		code: 6068,
+		code: 6070,
 		name: "CooldownNotInitialized",
 		msg: "Sell trade requires calling approval or buy function first to initialize cooldown PDA"
 	},
 	{
-		code: 6069,
+		code: 6071,
 		name: "CannotCloseCooldownWithBalance",
 		msg: "Cannot close cooldown PDA with non-zero token balance"
 	},
 	{
-		code: 6070,
-		name: "RemainingTokenAmountTooSmall",
-		msg: "Remaining token amount below minimum trade requirement"
-	},
-	{
-		code: 6071,
+		code: 6072,
 		name: "PriceCalculationError",
 		msg: "Price calculation error"
 	},
 	{
-		code: 6072,
+		code: 6073,
 		name: "InvalidFeeRecipientAccount",
-		msg: "Fee recipient account address mismatch"
+		msg: "Invalid fee recipient account"
 	},
 	{
-		code: 6073,
+		code: 6074,
 		name: "InvalidOrderMintAddress",
 		msg: "Order mint address does not match curve account mint"
 	},
 	{
-		code: 6074,
+		code: 6075,
 		name: "InvalidFeePercentage",
 		msg: "Fee percentage must be between 0-100"
 	},
 	{
-		code: 6075,
+		code: 6076,
 		name: "InvalidFeeRate",
 		msg: "Fee rate exceeds maximum limit (10%)"
 	},
 	{
-		code: 6076,
+		code: 6077,
+		name: "InvalidBorrowDuration",
+		msg: "Borrow duration out of valid range (3-30 days)"
+	},
+	{
+		code: 6078,
 		name: "InvalidStopLossPrice",
 		msg: "Stop loss price does not meet minimum interval requirement"
 	},
 	{
-		code: 6077,
+		code: 6079,
 		name: "NoProfitableFunds",
 		msg: "No profitable funds to transfer"
 	},
 	{
-		code: 6078,
+		code: 6080,
 		name: "InsufficientPoolFunds",
 		msg: "Insufficient pool funds"
 	},
 	{
-		code: 6079,
+		code: 6081,
 		name: "OrderBookManagerOverflow",
 		msg: "Math operation overflow"
 	},
 	{
-		code: 6080,
+		code: 6082,
 		name: "OrderBookManagerInvalidSlotIndex",
 		msg: "Invalid slot index"
 	},
 	{
-		code: 6081,
+		code: 6083,
 		name: "OrderBookManagerInvalidAccountData",
 		msg: "Invalid account data"
 	},
 	{
-		code: 6082,
+		code: 6084,
 		name: "OrderBookManagerExceedsMaxCapacity",
 		msg: "New capacity exceeds maximum limit"
 	},
 	{
-		code: 6083,
+		code: 6085,
 		name: "OrderBookManagerExceedsAccountSizeLimit",
 		msg: "Account size exceeds 10MB limit"
 	},
 	{
-		code: 6084,
+		code: 6086,
 		name: "OrderBookManagerOrderIdMismatch",
 		msg: "Order ID mismatch"
 	},
 	{
-		code: 6085,
+		code: 6087,
 		name: "OrderBookManagerEmptyOrderBook",
 		msg: "Order book is empty"
 	},
 	{
-		code: 6086,
+		code: 6088,
 		name: "OrderBookManagerAccountNotWritable",
 		msg: "Account is not writable"
 	},
 	{
-		code: 6087,
+		code: 6089,
 		name: "OrderBookManagerNotRentExempt",
 		msg: "Account not rent-exempt"
 	},
 	{
-		code: 6088,
+		code: 6090,
 		name: "OrderBookManagerInvalidRentBalance",
 		msg: "Invalid rent balance"
 	},
 	{
-		code: 6089,
+		code: 6091,
 		name: "OrderBookManagerInsufficientFunds",
 		msg: "Insufficient funds"
 	},
 	{
-		code: 6090,
+		code: 6092,
 		name: "OrderBookManagerInvalidAccountOwner",
-		msg: "Invalid account owner"
+		msg: "OrderBook account owner mismatch"
 	},
 	{
-		code: 6091,
+		code: 6093,
 		name: "OrderBookManagerDataOutOfBounds",
 		msg: "Data access out of bounds"
 	},
 	{
-		code: 6092,
+		code: 6094,
 		name: "NoValidInsertPosition",
 		msg: "Cannot find valid insert position, all candidates failed due to price range overlap"
 	},
 	{
-		code: 6093,
+		code: 6095,
 		name: "EmptyCloseInsertIndices",
 		msg: "close_insert_indices array cannot be empty"
 	},
 	{
-		code: 6094,
+		code: 6096,
 		name: "TooManyCloseInsertIndices",
 		msg: "close_insert_indices array cannot exceed 20 elements"
 	},
 	{
-		code: 6095,
+		code: 6097,
 		name: "CloseOrderNotFound",
 		msg: "Specified close order not found"
 	},
 	{
-		code: 6096,
+		code: 6098,
 		name: "LinkedListDeleteCountMismatch",
 		msg: "Linked list delete count mismatch: count inconsistent before/after deletion"
 	},
 	{
-		code: 6097,
+		code: 6099,
 		name: "NameTooLong",
 		msg: "Token name too long, max 32 bytes"
 	},
 	{
-		code: 6098,
+		code: 6100,
 		name: "NameEmpty",
 		msg: "Token name cannot be empty"
 	},
 	{
-		code: 6099,
+		code: 6101,
 		name: "SymbolTooLong",
 		msg: "Token symbol too long, max 10 bytes"
 	},
 	{
-		code: 6100,
+		code: 6102,
 		name: "SymbolEmpty",
 		msg: "Token symbol cannot be empty"
 	},
 	{
-		code: 6101,
+		code: 6103,
 		name: "UriTooLong",
 		msg: "URI too long, max 200 bytes"
 	},
 	{
-		code: 6102,
+		code: 6104,
 		name: "UriEmpty",
 		msg: "URI cannot be empty"
+	},
+	{
+		code: 6105,
+		name: "IncompleteAdvancedPoolParams",
+		msg: "高级版池子参数不完整：custom_lp_sol, custom_lp_token, custom_borrow_ratio, custom_borrow_duration 必须同时提供"
+	},
+	{
+		code: 6106,
+		name: "InvalidInitialVirtualSol",
+		msg: "初始虚拟SOL超出有效范围（10 SOL ~ 1,000 SOL）"
+	},
+	{
+		code: 6107,
+		name: "InvalidInitialVirtualToken",
+		msg: "初始虚拟Token超出有效范围（1亿 ~ 100亿 Token）"
+	},
+	{
+		code: 6108,
+		name: "InvalidBorrowPoolRatio",
+		msg: "借贷池占比超出有效范围（5% ~ 30%）"
+	},
+	{
+		code: 6109,
+		name: "BorrowTokenCalculationOverflow",
+		msg: "借贷池代币数量计算溢出"
+	},
+	{
+		code: 6110,
+		name: "BorrowTokenAmountZero",
+		msg: "借贷池代币数量不能为0"
 	}
 ];
 var types = [
@@ -52162,6 +52469,42 @@ var types = [
 				{
 					name: "bump",
 					type: "u8"
+				},
+				{
+					name: "initial_virtual_sol",
+					docs: [
+						"初始虚拟SOL储备量 (lamports, 9位精度)",
+						"用于计算 k 值和价格曲线",
+						"默认值: 30_000_000_000 (30 SOL)"
+					],
+					type: "u64"
+				},
+				{
+					name: "initial_virtual_token",
+					docs: [
+						"初始虚拟Token储备量 (最小单位, 9位精度)",
+						"用于计算 k 值和价格曲线",
+						"默认值: 1_073_000_000_000_000_000 (10.73亿 Token)"
+					],
+					type: "u64"
+				},
+				{
+					name: "pool_type",
+					docs: [
+						"池子类型",
+						"0 = 普通版（使用默认参数，支持手续费减半）",
+						"1 = 高级版（自定义参数，手续费永不减半）"
+					],
+					type: "u8"
+				},
+				{
+					name: "borrow_pool_ratio",
+					docs: [
+						"借贷池代币占比（仅记录，用于信息展示）",
+						"实际数值范围：5-30（代表 5%-30%）",
+						"普通版固定为 20"
+					],
+					type: "u8"
 				}
 			]
 		}
@@ -52664,6 +53007,22 @@ var types = [
 				{
 					name: "latest_price",
 					type: "u128"
+				},
+				{
+					name: "initial_virtual_sol",
+					type: "u64"
+				},
+				{
+					name: "initial_virtual_token",
+					type: "u64"
+				},
+				{
+					name: "pool_type",
+					type: "u8"
+				},
+				{
+					name: "borrow_pool_ratio",
+					type: "u8"
 				}
 			]
 		}