@meteora-ag/cp-amm-sdk 1.0.0-rc.3 → 1.0.0-rc.5

package/dist/index.mjs

@@ -6401,7 +6401,6 @@ var SCALE_OFFSET = 64;
 var BASIS_POINT_MAX = 1e4;
 var MAX_FEE_NUMERATOR = 5e8;
 var FEE_DENOMINATOR = 1e9;
-var PRECISION = 1e6;
 var MIN_SQRT_PRICE = new BN("4295048016");
 var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
 var MIN_CU_BUFFER = 5e4;
@@ -6493,12 +6492,6 @@ function derivePositionNftAccount(positionNftMint) {
     CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveTokenBadge(tokenMint) {
-  return PublicKey2.findProgramAddressSync(
-    [Buffer.from("token_badge"), tokenMint.toBuffer()],
-    CP_AMM_PROGRAM_ID
-  )[0];
-}
 
 // src/helpers/token.ts
 import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
@@ -6516,7 +6509,6 @@ import {
   TokenInvalidAccountOwnerError
 } from "@solana/spl-token";
 import {
-  PublicKey as PublicKey3,
   SystemProgram,
   TransactionInstruction
 } from "@solana/web3.js";
@@ -6590,16 +6582,6 @@ var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0,
   }
   return null;
 });
-function getNftOwner(connection, nftMint) {
-  return __async(this, null, function* () {
-    const largesTokenAccount = yield connection.getTokenLargestAccounts(nftMint);
-    const accountInfo = yield connection.getParsedAccountInfo(
-      largesTokenAccount.value[0].address
-    );
-    const owner = new PublicKey3(accountInfo.value.data.parsed.info.owner);
-    return new PublicKey3(owner);
-  });
-}
 function getAllUserPositionNftAccount(connection, user) {
   return __async(this, null, function* () {
     const filters = [
@@ -6634,6 +6616,24 @@ function getAllUserPositionNftAccount(connection, user) {
     return userPositionNftAccount;
   });
 }
+function getAllPositionNftAccountByOwner(connection, user) {
+  return __async(this, null, function* () {
+    const tokenAccounts = yield connection.getTokenAccountsByOwner(user, {
+      programId: TOKEN_2022_PROGRAM_ID
+    });
+    const userPositionNftAccount = [];
+    for (const { account, pubkey } of tokenAccounts.value) {
+      const tokenAccountData = AccountLayout.decode(account.data);
+      if (tokenAccountData.amount.toString() === "1") {
+        userPositionNftAccount.push({
+          positionNft: tokenAccountData.mint,
+          positionNftAccount: pubkey
+        });
+      }
+    }
+    return userPositionNftAccount;
+  });
+}
 
 // src/helpers/fee.ts
 import { BN as BN5 } from "@coral-xyz/anchor";
@@ -6752,12 +6752,6 @@ function mulDiv(x, y, denominator, rounding) {
   }
   return div;
 }
-function divCeil(a, b) {
-  if (a.isZero()) {
-    return new BN3(0);
-  }
-  return a.add(b.sub(new BN3(1))).div(b);
-}
 function q64ToDecimal(num, decimalPlaces) {
   return new Decimal(num.toString()).div(Decimal.pow(2, 64)).toDecimalPlaces(decimalPlaces);
 }
@@ -6772,7 +6766,8 @@ function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
   if (aToB) {
     const product = amount.mul(sqrtPrice);
     const denominator = liquidity.add(product);
-    result = mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */);
+    const numerator = liquidity.mul(sqrtPrice);
+    result = numerator.add(denominator.sub(new BN4(1))).div(denominator);
   } else {
     const quotient = amount.shln(SCALE_OFFSET * 2).div(liquidity);
     result = sqrtPrice.add(quotient);
@@ -6849,7 +6844,7 @@ function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFr
       new BN5(binStep),
       new BN5(variableFeeControl)
     );
-    feeNumerator.add(dynamicFeeNumberator);
+    feeNumerator = feeNumerator.add(dynamicFeeNumberator);
   }
   return feeNumerator.gt(new BN5(MAX_FEE_NUMERATOR)) ? new BN5(MAX_FEE_NUMERATOR) : feeNumerator;
 }
@@ -7164,11 +7159,11 @@ function getAvailableVestingLiquidity(vestingData, currentPoint) {
     numberOfPeriod,
     totalReleasedLiquidity
   } = vestingData;
-  if (currentPoint < cliffPoint) {
+  if (currentPoint.lt(cliffPoint)) {
     return new BN9(0);
   }
   if (periodFrequency.isZero()) {
-    return cliffUnlockLiquidity.sub(totalReleasedLiquidity);
+    return cliffUnlockLiquidity;
   }
   let passedPeriod = new BN9(currentPoint).sub(cliffPoint).div(periodFrequency);
   passedPeriod = min(passedPeriod, new BN9(numberOfPeriod));
@@ -7246,12 +7241,12 @@ var CpAmm = class {
   getTokenBadgeAccounts(tokenAMint, tokenBMint) {
     return [
       {
-        pubkey: deriveTokenBadge(tokenAMint),
+        pubkey: deriveTokenBadgeAddress(tokenAMint),
         isWritable: false,
         isSigner: false
       },
       {
-        pubkey: deriveTokenBadge(tokenBMint),
+        pubkey: deriveTokenBadgeAddress(tokenBMint),
         isWritable: false,
         isSigner: false
       }
@@ -7509,6 +7504,34 @@ var CpAmm = class {
       return instructions;
     });
   }
+  /**
+   * Builds a instruction to create a position.
+   * @param {CreatePositionParams} params - Parameters for position creation.
+   * @returns Transaction instruction.
+   */
+  buildCreatePositionInstruction(params) {
+    return __async(this, null, function* () {
+      const { owner, payer, pool, positionNft } = params;
+      const position = derivePositionAddress(positionNft);
+      const positionNftAccount = derivePositionNftAccount(positionNft);
+      const ix = yield this._program.methods.createPosition().accountsPartial({
+        owner,
+        positionNftMint: positionNft,
+        poolAuthority: this.poolAuthority,
+        positionNftAccount,
+        payer,
+        pool,
+        position,
+        tokenProgram: TOKEN_2022_PROGRAM_ID2,
+        systemProgram: SystemProgram2.programId
+      }).instruction();
+      return {
+        ix,
+        position,
+        positionNftAccount
+      };
+    });
+  }
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7612,7 +7635,7 @@ var CpAmm = class {
    */
   getPositionsByUser(user) {
     return __async(this, null, function* () {
-      const userPositionAccounts = yield getAllUserPositionNftAccount(
+      const userPositionAccounts = yield getAllPositionNftAccountByOwner(
         this._program.provider.connection,
         user
       );
@@ -7700,93 +7723,117 @@ var CpAmm = class {
       return poolState !== null;
     });
   }
+  /**
+   * Computes the liquidity delta based on the provided token amounts and sqrt price
+   *
+   * @param {LiquidityDeltaParams} params - The parameters for liquidity calculation
+   * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
+   */
+  getLiquidityDelta(params) {
+    const {
+      maxAmountTokenA,
+      maxAmountTokenB,
+      sqrtMaxPrice,
+      sqrtMinPrice,
+      sqrtPrice
+    } = params;
+    const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
+      maxAmountTokenA,
+      sqrtPrice,
+      sqrtMaxPrice
+    );
+    const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
+      maxAmountTokenB,
+      sqrtMinPrice,
+      sqrtPrice
+    );
+    return min2(liquidityDeltaFromAmountA, liquidityDeltaFromAmountB);
+  }
   /**
    * Calculates swap quote based on input amount and pool state.
    * @param params - Swap parameters including input amount, pool state, slippage, etc.
    * @returns Swap quote including expected output amount, fee, and price impact.
    */
   getQuote(params) {
-    return __async(this, null, function* () {
-      const {
+    const {
+      inAmount,
+      inputTokenMint,
+      slippage,
+      poolState,
+      currentTime,
+      currentSlot,
+      inputTokenInfo,
+      outputTokenInfo
+    } = params;
+    const {
+      sqrtPrice: sqrtPriceQ64,
+      liquidity: liquidityQ64,
+      activationType,
+      activationPoint,
+      collectFeeMode,
+      poolFees
+    } = poolState;
+    const {
+      feeSchedulerMode,
+      cliffFeeNumerator,
+      numberOfPeriod,
+      reductionFactor,
+      periodFrequency
+    } = poolFees.baseFee;
+    const dynamicFee = poolFees.dynamicFee;
+    let actualAmountIn = inAmount;
+    if (inputTokenInfo) {
+      actualAmountIn = calculateTransferFeeExcludedAmount(
         inAmount,
-        inputTokenMint,
-        slippage,
-        poolState,
-        currentTime,
-        currentSlot,
-        inputTokenInfo,
-        outputTokenInfo
-      } = params;
-      const {
-        sqrtPrice: sqrtPriceQ64,
-        liquidity: liquidityQ64,
-        activationType,
-        activationPoint,
-        collectFeeMode,
-        poolFees
-      } = poolState;
-      const {
-        feeSchedulerMode,
-        cliffFeeNumerator,
-        numberOfPeriod,
-        reductionFactor,
-        periodFrequency
-      } = poolFees.baseFee;
-      const dynamicFee = poolFees.dynamicFee;
-      let actualAmountIn = inAmount;
-      if (inputTokenInfo) {
-        actualAmountIn = calculateTransferFeeExcludedAmount(
-          inAmount,
-          inputTokenInfo.mint,
-          inputTokenInfo.currentEpoch
-        ).amount;
-      }
-      const aToB = poolState.tokenAMint.equals(inputTokenMint);
-      const currentPoint = activationType ? currentTime : currentSlot;
-      let dynamicFeeParams;
-      if (dynamicFee.initialized) {
-        const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
-        dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
-      }
-      const tradeFeeNumerator = getFeeNumerator(
-        currentPoint,
-        activationPoint,
-        numberOfPeriod,
-        periodFrequency,
-        feeSchedulerMode,
-        cliffFeeNumerator,
-        reductionFactor,
-        dynamicFeeParams
-      );
-      const { amountOut, totalFee } = getSwapAmount(
-        actualAmountIn,
-        sqrtPriceQ64,
-        liquidityQ64,
-        tradeFeeNumerator,
-        aToB,
-        collectFeeMode
-      );
-      let actualAmountOut = amountOut;
-      if (outputTokenInfo) {
-        actualAmountOut = calculateTransferFeeExcludedAmount(
-          amountOut,
-          outputTokenInfo.mint,
-          outputTokenInfo.currentEpoch
-        ).amount;
-      }
-      const minSwapOutAmount = getMinAmountWithSlippage(
-        actualAmountOut,
-        slippage
-      );
-      return {
-        swapInAmount: inAmount,
-        consumedInAmount: actualAmountIn,
-        swapOutAmount: actualAmountOut,
-        minSwapOutAmount,
-        totalFee,
-        priceImpact: getPriceImpact(minSwapOutAmount, actualAmountOut)
-      };
-    });
+        inputTokenInfo.mint,
+        inputTokenInfo.currentEpoch
+      ).amount;
+    }
+    const aToB = poolState.tokenAMint.equals(inputTokenMint);
+    const currentPoint = activationType ? currentTime : currentSlot;
+    let dynamicFeeParams;
+    if (dynamicFee.initialized) {
+      const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
+      dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
+    }
+    const tradeFeeNumerator = getFeeNumerator(
+      currentPoint,
+      activationPoint,
+      numberOfPeriod,
+      periodFrequency,
+      feeSchedulerMode,
+      cliffFeeNumerator,
+      reductionFactor,
+      dynamicFeeParams
+    );
+    const { amountOut, totalFee } = getSwapAmount(
+      actualAmountIn,
+      sqrtPriceQ64,
+      liquidityQ64,
+      tradeFeeNumerator,
+      aToB,
+      collectFeeMode
+    );
+    let actualAmountOut = amountOut;
+    if (outputTokenInfo) {
+      actualAmountOut = calculateTransferFeeExcludedAmount(
+        amountOut,
+        outputTokenInfo.mint,
+        outputTokenInfo.currentEpoch
+      ).amount;
+    }
+    const minSwapOutAmount = getMinAmountWithSlippage(
+      actualAmountOut,
+      slippage
+    );
+    return {
+      swapInAmount: inAmount,
+      consumedInAmount: actualAmountIn,
+      swapOutAmount: actualAmountOut,
+      minSwapOutAmount,
+      totalFee,
+      priceImpact: getPriceImpact(minSwapOutAmount, actualAmountOut)
+    };
   }
   /**
    * Calculates the deposit quote for liquidity pool.
@@ -7799,61 +7846,59 @@ var CpAmm = class {
    * @returns {BN} returns.liquidityDelta - The amount of liquidity that will be added to the pool.
    */
   getDepositQuote(params) {
-    return __async(this, null, function* () {
-      const {
+    const {
+      inAmount,
+      isTokenA,
+      inputTokenInfo,
+      outputTokenInfo,
+      minSqrtPrice,
+      maxSqrtPrice,
+      sqrtPrice
+    } = params;
+    const actualAmountIn = inputTokenInfo ? inAmount.sub(
+      calculateTransferFeeIncludedAmount(
         inAmount,
-        isTokenA,
-        inputTokenInfo,
-        outputTokenInfo,
+        inputTokenInfo.mint,
+        inputTokenInfo.currentEpoch
+      ).transferFee
+    ) : inAmount;
+    const { liquidityDelta, rawAmount } = isTokenA ? {
+      liquidityDelta: getLiquidityDeltaFromAmountA(
+        actualAmountIn,
+        sqrtPrice,
+        maxSqrtPrice
+      ),
+      rawAmount: (delta) => getAmountBFromLiquidityDelta(
+        delta,
+        sqrtPrice,
+        minSqrtPrice,
+        0 /* Up */
+      )
+    } : {
+      liquidityDelta: getLiquidityDeltaFromAmountB(
+        actualAmountIn,
         minSqrtPrice,
-        maxSqrtPrice,
         sqrtPrice
-      } = params;
-      const actualAmountIn = inputTokenInfo ? inAmount.sub(
-        calculateTransferFeeIncludedAmount(
-          inAmount,
-          inputTokenInfo.mint,
-          inputTokenInfo.currentEpoch
-        ).transferFee
-      ) : inAmount;
-      const { liquidityDelta, rawAmount } = isTokenA ? {
-        liquidityDelta: getLiquidityDeltaFromAmountA(
-          actualAmountIn,
-          sqrtPrice,
-          maxSqrtPrice
-        ),
-        rawAmount: (delta) => getAmountBFromLiquidityDelta(
-          delta,
-          sqrtPrice,
-          minSqrtPrice,
-          0 /* Up */
-        )
-      } : {
-        liquidityDelta: getLiquidityDeltaFromAmountB(
-          actualAmountIn,
-          minSqrtPrice,
-          sqrtPrice
-        ),
-        rawAmount: (delta) => getAmountAFromLiquidityDelta(
-          delta,
-          sqrtPrice,
-          maxSqrtPrice,
-          0 /* Up */
-        )
-      };
-      const rawOutputAmount = new BN10(rawAmount(liquidityDelta));
-      const outputAmount = outputTokenInfo ? calculateTransferFeeIncludedAmount(
-        rawOutputAmount,
-        outputTokenInfo.mint,
-        outputTokenInfo.currentEpoch
-      ).amount : rawOutputAmount;
-      return {
-        actualInputAmount: actualAmountIn,
-        consumedInputAmount: inAmount,
-        liquidityDelta,
-        outputAmount
-      };
-    });
+      ),
+      rawAmount: (delta) => getAmountAFromLiquidityDelta(
+        delta,
+        sqrtPrice,
+        maxSqrtPrice,
+        0 /* Up */
+      )
+    };
+    const rawOutputAmount = new BN10(rawAmount(liquidityDelta));
+    const outputAmount = outputTokenInfo ? calculateTransferFeeIncludedAmount(
+      rawOutputAmount,
+      outputTokenInfo.mint,
+      outputTokenInfo.currentEpoch
+    ).amount : rawOutputAmount;
+    return {
+      actualInputAmount: actualAmountIn,
+      consumedInputAmount: inAmount,
+      liquidityDelta,
+      outputAmount
+    };
   }
   /**
    * Calculates the withdrawal quote for removing liquidity from a concentrated liquidity pool.
@@ -7869,41 +7914,39 @@ var CpAmm = class {
    * @returns {BN} returns.outAmountB - The calculated amount of token B to be received (after deducting transfer fees)
    */
   getWithdrawQuote(params) {
-    return __async(this, null, function* () {
-      const {
-        liquidityDelta,
-        sqrtPrice,
-        maxSqrtPrice,
-        minSqrtPrice,
-        tokenATokenInfo,
-        tokenBTokenInfo
-      } = params;
-      const amountA = getAmountAFromLiquidityDelta(
-        liquidityDelta,
-        sqrtPrice,
-        maxSqrtPrice,
-        1 /* Down */
-      );
-      const amountB = getAmountBFromLiquidityDelta(
-        liquidityDelta,
-        sqrtPrice,
-        minSqrtPrice,
-        1 /* Down */
-      );
-      return {
-        liquidityDelta,
-        outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
-          amountA,
-          tokenATokenInfo.mint,
-          tokenATokenInfo.currentEpoch
-        ).amount : amountA,
-        outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
-          amountB,
-          tokenBTokenInfo.mint,
-          tokenBTokenInfo.currentEpoch
-        ).amount : amountB
-      };
-    });
+    const {
+      liquidityDelta,
+      sqrtPrice,
+      maxSqrtPrice,
+      minSqrtPrice,
+      tokenATokenInfo,
+      tokenBTokenInfo
+    } = params;
+    const amountA = getAmountAFromLiquidityDelta(
+      liquidityDelta,
+      sqrtPrice,
+      maxSqrtPrice,
+      1 /* Down */
+    );
+    const amountB = getAmountBFromLiquidityDelta(
+      liquidityDelta,
+      sqrtPrice,
+      minSqrtPrice,
+      1 /* Down */
+    );
+    return {
+      liquidityDelta,
+      outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
+        amountA,
+        tokenATokenInfo.mint,
+        tokenATokenInfo.currentEpoch
+      ).amount : amountA,
+      outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
+        amountB,
+        tokenBTokenInfo.mint,
+        tokenBTokenInfo.currentEpoch
+      ).amount : amountB
+    };
   }
   /**
    * Calculates liquidity and corresponding token amounts for token A single-sided pool creation
@@ -8181,20 +8224,8 @@ var CpAmm = class {
    */
   createPosition(params) {
     return __async(this, null, function* () {
-      const { owner, payer, pool, positionNft } = params;
-      const position = derivePositionAddress(positionNft);
-      const positionNftAccount = derivePositionNftAccount(positionNft);
-      return yield this._program.methods.createPosition().accountsPartial({
-        owner,
-        positionNftMint: positionNft,
-        poolAuthority: this.poolAuthority,
-        positionNftAccount,
-        payer,
-        pool,
-        position,
-        tokenProgram: TOKEN_2022_PROGRAM_ID2,
-        systemProgram: SystemProgram2.programId
-      }).transaction();
+      const { ix } = yield this.buildCreatePositionInstruction(params);
+      return new Transaction().add(ix);
     });
   }
   /**
@@ -8281,6 +8312,104 @@ var CpAmm = class {
       return transaction;
     });
   }
+  /**
+   * Creates a new position and add liquidity to position it in a single transaction.
+   * Handles both native SOL and other tokens, automatically wrapping/unwrapping SOL as needed.
+   *
+   * @param {CreatePositionAndAddLiquidity} params - Parameters for creating position and adding liquidity
+   *
+   * @returns {Transaction} A transaction that creates a position and adds liquidity
+   *
+   **/
+  createPositionAndAddLiquidity(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        pool,
+        positionNft,
+        liquidityDelta,
+        maxAmountTokenA,
+        maxAmountTokenB,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
+      if (tokenAMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          tokenAAccount,
+          BigInt(maxAmountTokenA.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (tokenBMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          tokenBAccount,
+          BigInt(maxAmountTokenB.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const {
+        ix: createPositionIx,
+        position,
+        positionNftAccount
+      } = yield this.buildCreatePositionInstruction({
+        owner,
+        payer: owner,
+        pool,
+        positionNft
+      });
+      const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram,
+        liquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      });
+      const transaction = new Transaction();
+      transaction.add(createPositionIx);
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        addLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
+    });
+  }
   /**
    * Builds a transaction to remove liquidity from a position.
    * @param {RemoveLiquidityParams} params - Parameters for removing liquidity.
@@ -9072,7 +9201,6 @@ export {
   MIN_CU_BUFFER,
   MIN_SQRT_PRICE,
   ONE,
-  PRECISION,
   Rounding,
   SCALE_OFFSET,
   TradeDirection,
@@ -9089,10 +9217,9 @@ export {
   derivePositionAddress,
   derivePositionNftAccount,
   deriveRewardVaultAddress,
-  deriveTokenBadge,
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
-  divCeil,
+  getAllPositionNftAccountByOwner,
   getAllUserPositionNftAccount,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
@@ -9108,7 +9235,6 @@ export {
   getMaxAmountWithSlippage,
   getMinAmountWithSlippage,
   getNextSqrtPrice,
-  getNftOwner,
   getOrCreateATAInstruction,
   getPriceFromSqrtPrice,
   getPriceImpact,