fix: damm v2 zap in to single sided pool

Author: bangyro

CHANGELOG.md

@@ -21,6 +21,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking Changes
 
+## zap [0.2.2] [PR #46](https://github.com/MeteoraAg/zap-program/pull/46)
+
+### Fixed
+
+- Fix `zap_in_damm_v2` endpoint when the damm-v2 pool is single-sided, meaning it only has token A or only has token B
+
 ## zap [0.2.1] [PR #41](https://github.com/MeteoraAg/zap-program/pull/41)
 
 ### Fixed

programs/zap/src/utils/damm_v2_utils.rs

@@ -459,6 +459,10 @@ pub fn get_liquidity_from_amount_a(
     sqrt_max_price: u128,
     sqrt_price: u128,
 ) -> Result<u128> {
+    if sqrt_price == sqrt_max_price {
+        // Single-sided B position: no token A needed, return max so A is always surplus
+        return Ok(u128::MAX);
+    }
     let price_delta = U512::from(sqrt_max_price.safe_sub(sqrt_price)?);
     let prod = U512::from(amount_a)
         .safe_mul(U512::from(sqrt_price))?
@@ -473,6 +477,10 @@ pub fn get_liquidity_from_amount_b(
     sqrt_min_price: u128,
     sqrt_price: u128,
 ) -> Result<u128> {
+    if sqrt_price == sqrt_min_price {
+        // Single-sided A position: no token B needed, return max so B is always surplus
+        return Ok(u128::MAX);
+    }
     let price_delta = U256::from(sqrt_price.safe_sub(sqrt_min_price)?);
     let quote_amount = U256::from(amount_b).safe_shl(128)?;
     let liquidity = quote_amount.safe_div(price_delta)?; // round down

tests/common/damm_v2.ts

@@ -169,10 +169,15 @@ export async function createDammV2Pool(
   tokenBMint: PublicKey,
   amountA?: BN,
   amountB?: BN,
-  baseFeeParams?: Buffer
+  baseFeeParams?: Buffer,
+  customInitSqrtPrice?: BN
 ): Promise<PublicKey> {
   const program = createDammV2Program();
 
+  const sqrtMinPrice = MIN_SQRT_PRICE;
+  const sqrtMaxPrice = MAX_SQRT_PRICE;
+  const sqrtPrice = customInitSqrtPrice ?? INIT_PRICE;
+
   const poolAuthority = deriveDammV2PoolAuthority();
   const pool = deriveDammV2CustomizablePoolAddress(tokenAMint, tokenBMint);
 
@@ -205,17 +210,29 @@ export async function createDammV2Pool(
   if (amountA && amountB) {
     const liquidityFromA = getLiquidityDeltaFromAmountA(
       amountA,
-      INIT_PRICE,
-      MAX_SQRT_PRICE
+      sqrtPrice,
+      sqrtMaxPrice
     );
-
     const liquidityFromB = getLiquidityDeltaFromAmountB(
       amountB,
-      MIN_SQRT_PRICE,
-      INIT_PRICE
+      sqrtMinPrice,
+      sqrtPrice
     );
-
     liquidityDelta = BN.min(liquidityFromA, liquidityFromB);
+  } else if (amountA) {
+    // one sided pool A
+    liquidityDelta = getLiquidityDeltaFromAmountA(
+      amountA,
+      sqrtPrice,
+      sqrtMaxPrice
+    );
+  } else if (amountB) {
+    // one sided pool B
+    liquidityDelta = getLiquidityDeltaFromAmountB(
+      amountB,
+      sqrtMinPrice,
+      sqrtPrice
+    );
   }
 
   const baseFee = {
@@ -237,11 +254,11 @@ export async function createDammV2Pool(
         baseFee,
         dynamicFee: null,
       },
-      sqrtMinPrice: MIN_SQRT_PRICE,
-      sqrtMaxPrice: MAX_SQRT_PRICE,
+      sqrtMinPrice,
+      sqrtMaxPrice,
       hasAlphaVault: false,
       liquidity: liquidityDelta,
-      sqrtPrice: INIT_PRICE,
+      sqrtPrice,
       activationType: 0,
       collectFeeMode: 1,
       activationPoint: null,
@@ -280,8 +297,12 @@ export async function createDammV2Pool(
 
   const vaultBBalance = Number(AccountLayout.decode(tokenBVaultData).amount);
 
-  expect(vaultABalance).greaterThan(0);
-  expect(vaultBBalance).greaterThan(0);
+  if (!sqrtPrice.eq(sqrtMaxPrice)) {
+    expect(vaultABalance).greaterThan(0);
+  }
+  if (!sqrtPrice.eq(sqrtMinPrice)) {
+    expect(vaultBBalance).greaterThan(0);
+  }
 
   return pool;
 }

tests/test_zapin/zapin_dammv2.test.ts

@@ -24,6 +24,8 @@ import {
   TOKEN_DECIMALS,
   U64_MAX,
   U32_MAX,
+  MIN_SQRT_PRICE,
+  MAX_SQRT_PRICE,
 } from "../common";
 
 import ZapIDL from "../../target/idl/zap.json";
@@ -409,6 +411,151 @@ describe("Zap In damm V2", () => {
     expect(result).instanceOf(TransactionMetadata);
   });
 
+  it("zap in when sqrt_price is at sqrt_min_price (single-sided A)", async () => {
+    const pool = await createDammV2Pool(
+      svm,
+      admin,
+      tokenAMint,
+      tokenBMint,
+      new BN(LAMPORTS_PER_SOL),
+      undefined,
+      undefined,
+      MIN_SQRT_PRICE
+    );
+
+    const poolState = getDammV2Pool(svm, pool);
+
+    expect(poolState.sqrtPrice.eq(MIN_SQRT_PRICE)).to.be.true;
+
+    const { position, positionNftAccount } = await createDammV2Position(
+      svm,
+      user,
+      pool
+    );
+
+    const initializeLedgerTx = await initializeLedgerAccount(user.publicKey);
+
+    const totalAmountA = new BN(LAMPORTS_PER_SOL / 2);
+    const setLedgerBalanceTx = await setLedgerBalance(
+      user.publicKey,
+      totalAmountA,
+      true
+    );
+
+    const tokenBAccount = getAssociatedTokenAddressSync(
+      tokenBMint,
+      user.publicKey
+    );
+    const preTokenBBalance = getTokenBalance(svm, tokenBAccount);
+    const updateLedgerBalanceAfterSwapTx = await updateLedgerBalanceAfterSwap(
+      user.publicKey,
+      tokenBAccount,
+      preTokenBBalance,
+      U64_MAX,
+      false
+    );
+
+    const zapInTx = await zapInDammv2({
+      svm,
+      user: user.publicKey,
+      pool,
+      position,
+      positionNftAccount,
+      preSqrtPrice: poolState.sqrtPrice,
+      maxSqrtPriceChangeBps: U32_MAX.toNumber(),
+    });
+
+    const closeLedgerTx = await closeLedgerAccount(user.publicKey);
+
+    const finalTx = new Transaction()
+      .add(initializeLedgerTx)
+      .add(setLedgerBalanceTx)
+      .add(updateLedgerBalanceAfterSwapTx)
+      .add(zapInTx)
+      .add(closeLedgerTx);
+    finalTx.recentBlockhash = svm.latestBlockhash();
+    finalTx.sign(user);
+
+    const result = svm.sendTransaction(finalTx);
+    if (result instanceof FailedTransactionMetadata) {
+      console.log(result.meta().logs());
+    }
+    expect(result).instanceOf(TransactionMetadata);
+  });
+
+  it("zap in when sqrt_price is at sqrt_max_price (single-sided B)", async () => {
+    const pool = await createDammV2Pool(
+      svm,
+      admin,
+      tokenAMint,
+      tokenBMint,
+      undefined,
+      new BN(LAMPORTS_PER_SOL),
+      undefined,
+      MAX_SQRT_PRICE
+    );
+
+    const poolState = getDammV2Pool(svm, pool);
+
+    expect(poolState.sqrtPrice.eq(MAX_SQRT_PRICE)).to.be.true;
+
+    const { position, positionNftAccount } = await createDammV2Position(
+      svm,
+      user,
+      pool
+    );
+
+    const initializeLedgerTx = await initializeLedgerAccount(user.publicKey);
+
+    const totalAmountB = new BN(LAMPORTS_PER_SOL / 2);
+    const setLedgerBalanceTx = await setLedgerBalance(
+      user.publicKey,
+      totalAmountB,
+      false
+    );
+
+    const tokenAAccount = getAssociatedTokenAddressSync(
+      tokenAMint,
+      user.publicKey
+    );
+    const preTokenABalance = getTokenBalance(svm, tokenAAccount);
+    const updateLedgerBalanceAfterSwapTx = await updateLedgerBalanceAfterSwap(
+      user.publicKey,
+      tokenAAccount,
+      preTokenABalance,
+      U64_MAX,
+      true
+    );
+
+    const zapInTx = await zapInDammv2({
+      svm,
+      user: user.publicKey,
+      pool,
+      position,
+      positionNftAccount,
+      preSqrtPrice: poolState.sqrtPrice,
+      maxSqrtPriceChangeBps: U32_MAX.toNumber(),
+    });
+
+    const closeLedgerTx = await closeLedgerAccount(user.publicKey);
+
+    const finalTx = new Transaction()
+      .add(initializeLedgerTx)
+      .add(setLedgerBalanceTx)
+      .add(updateLedgerBalanceAfterSwapTx)
+      .add(zapInTx)
+      .add(closeLedgerTx);
+
+    finalTx.recentBlockhash = svm.latestBlockhash();
+    finalTx.sign(user);
+
+    const result = svm.sendTransaction(finalTx);
+    if (result instanceof FailedTransactionMetadata) {
+      console.log(result.meta().logs());
+    }
+    expect(result).instanceOf(TransactionMetadata);
+  });
+
   it("zap in without external swap with rate limiter and remaining accounts", async () => {
     const baseFee = encodeFeeRateLimiterParams(
       new BN(10_000_00), // 1% cliff fee