outsmart 2.0.0-alpha.0

package/dist/dex/meteora-damm-v2.js

@@ -0,0 +1,1146 @@
+"use strict";
+/**
+ * Meteora DAMM v2 (CP AMM) — IDexAdapter Implementation
+ *
+ * Wraps the @meteora-ag/cp-amm-sdk (CpAmm) for buy/sell/snipe/findPool/getPrice
+ * plus LP operations: addLiquidity (create position), removeLiquidity (close
+ * position), and claimFees.
+ *
+ * Source: 100x-algo-bots/trading-modules/meteora-damm-v2/
+ *
+ * SDK pattern:
+ *   const cpAmm = new CpAmm(connection);
+ *   const poolState = await cpAmm.fetchPoolState(poolAddress);
+ *   const swapTx = await cpAmm.swap({ payer, pool, inputTokenMint, ... });
+ *   const addTx = cpAmm.createPositionAndAddLiquidity({ ... });
+ *   const removeTx = cpAmm.removeAllLiquidityAndClosePosition({ ... });
+ *   const claimTx = cpAmm.claimPositionFee2({ ... });
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeteoraDammV2Adapter = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const web3_js_1 = require("@solana/web3.js");
+const cp_amm_sdk_1 = require("@meteora-ag/cp-amm-sdk");
+const spl_token_1 = require("@solana/spl-token");
+const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
+const config_1 = require("../helpers/config");
+const landing_1 = require("../transactions/landing");
+const send_rpc_1 = require("../transactions/send-rpc");
+const types_1 = require("./types");
+const index_1 = require("./index");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DAMM_PROGRAM_ID = new web3_js_1.PublicKey("cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG");
+/** Known stablecoin mints with 6 decimals */
+const SIX_DECIMAL_MINTS = new Set([
+    types_1.USDC_MINT,
+    types_1.USDT_MINT,
+    "USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB", // USD1
+]);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function quoteDecimals(quoteMintStr) {
+    return SIX_DECIMAL_MINTS.has(quoteMintStr) ? 6 : 9;
+}
+function amountToLamports(amount, quoteMintStr) {
+    const decimals = quoteDecimals(quoteMintStr);
+    return new bn_js_1.default(Math.floor(amount * Math.pow(10, decimals)));
+}
+/** Map token flag to token program ID (0=SPL, 1=Token-2022) */
+function getTokenProgram(flag) {
+    return flag === 0 ? spl_token_1.TOKEN_PROGRAM_ID : spl_token_1.TOKEN_2022_PROGRAM_ID;
+}
+/** Convert sqrtPriceX64 to human price */
+function sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
+    return raydium_sdk_v2_1.MathUtil.x64ToDecimal(sqrtPriceX64)
+        .pow(2)
+        .mul(decimal_js_1.default.pow(10, decimalsA - decimalsB));
+}
+/**
+ * Calculate initial sqrt price from reserves and sqrt bounds.
+ * Ported from source: meteora-damm-v2/buy.ts calculateInitSqrtPrice()
+ */
+function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice) {
+    if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
+        throw new Error("Amount cannot be zero");
+    }
+    const amountADecimal = new decimal_js_1.default(tokenAAmount.toString());
+    const amountBDecimal = new decimal_js_1.default(tokenBAmount.toString());
+    const minSqrtPriceDecimal = new decimal_js_1.default(minSqrtPrice.toString()).div(decimal_js_1.default.pow(2, 64));
+    const maxSqrtPriceDecimal = new decimal_js_1.default(maxSqrtPrice.toString()).div(decimal_js_1.default.pow(2, 64));
+    const x = new decimal_js_1.default(1).div(maxSqrtPriceDecimal);
+    const y = amountBDecimal.div(amountADecimal);
+    const xy = x.mul(y);
+    const paMinusXY = minSqrtPriceDecimal.sub(xy);
+    const xyMinusPa = xy.sub(minSqrtPriceDecimal);
+    const fourY = new decimal_js_1.default(4).mul(y);
+    const discriminant = xyMinusPa.mul(xyMinusPa).add(fourY);
+    const sqrtDiscriminant = discriminant.sqrt();
+    const result = paMinusXY
+        .add(sqrtDiscriminant)
+        .div(new decimal_js_1.default(2))
+        .mul(decimal_js_1.default.pow(2, 64));
+    return new bn_js_1.default(result.floor().toFixed());
+}
+// PDA derivation helpers (from source utils/pda.ts)
+function getFirstKey(key1, key2) {
+    const buf1 = key1.toBuffer();
+    const buf2 = key2.toBuffer();
+    return Buffer.compare(buf1, buf2) === 1 ? buf1 : buf2;
+}
+function getSecondKey(key1, key2) {
+    const buf1 = key1.toBuffer();
+    const buf2 = key2.toBuffer();
+    return Buffer.compare(buf1, buf2) === 1 ? buf2 : buf1;
+}
+function deriveCustomizablePoolAddress(tokenAMint, tokenBMint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("cpool"), getFirstKey(tokenAMint, tokenBMint), getSecondKey(tokenAMint, tokenBMint)], DAMM_PROGRAM_ID)[0];
+}
+function derivePoolAddress(config, tokenAMint, tokenBMint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("pool"), config.toBuffer(), getFirstKey(tokenAMint, tokenBMint), getSecondKey(tokenAMint, tokenBMint)], DAMM_PROGRAM_ID)[0];
+}
+function derivePositionAddress(positionNft) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("position"), positionNft.toBuffer()], DAMM_PROGRAM_ID)[0];
+}
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+class MeteoraDammV2Adapter {
+    name = "meteora-damm-v2";
+    protocol = "damm-v2";
+    capabilities = (0, types_1.defaultCapabilities)({
+        canBuy: true,
+        canSell: true,
+        canSnipe: true,
+        canFindPool: true,
+        canGetPrice: true,
+        canAddLiquidity: true,
+        canRemoveLiquidity: true,
+        canClaimFees: true,
+        canListPositions: true,
+        canCreatePool: true,
+    });
+    // ----- Core: buy -----
+    async buy(params) {
+        const tokenMint = (0, types_1.requireTokenMint)(params, this.name);
+        const { amountSol, quoteMint: quoteMintParam, poolAddress, opts } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const quoteMintStr = quoteMintParam ?? types_1.WSOL_MINT;
+        const poolPk = poolAddress
+            ? new web3_js_1.PublicKey(poolAddress)
+            : await this.resolvePool(tokenMint, quoteMintStr);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        const inputAmount = amountToLamports(amountSol, quoteMintStr);
+        const swapParams = {
+            payer: wallet.publicKey,
+            pool: poolPk,
+            inputTokenMint: quoteMintPk,
+            outputTokenMint: baseMintPk,
+            amountIn: inputAmount,
+            minimumAmountOut: new bn_js_1.default(0),
+            tokenAMint: poolState.tokenAMint,
+            tokenBMint: poolState.tokenBMint,
+            tokenAVault: poolState.tokenAVault,
+            tokenBVault: poolState.tokenBVault,
+            tokenAProgram: getTokenProgram(poolState.tokenAFlag),
+            tokenBProgram: getTokenProgram(poolState.tokenBFlag),
+            referralTokenAccount: null,
+        };
+        const swapTx = await cpAmm.swap(swapParams);
+        // Ensure output token ATA exists before swap
+        const baseMintAccInfo = await connection.getAccountInfo(baseMintPk);
+        const baseTokenProgram = baseMintAccInfo?.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        const outputAta = await (0, spl_token_1.getAssociatedTokenAddress)(baseMintPk, wallet.publicKey, false, baseTokenProgram);
+        const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(wallet.publicKey, outputAta, wallet.publicKey, baseMintPk, baseTokenProgram);
+        const computeLimit = opts?.computeUnitLimit ?? types_1.DEFAULT_COMPUTE_UNIT_LIMIT;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            createAtaIx,
+            ...swapTx.instructions,
+        ];
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+        });
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+            amountIn: amountSol,
+            amountInToken: quoteMintStr,
+            dex: this.name,
+            poolAddress: poolPk.toBase58(),
+        };
+    }
+    // ----- Core: sell -----
+    async sell(params) {
+        const tokenMint = (0, types_1.requireTokenMint)(params, this.name);
+        const { percentage, quoteMint: quoteMintParam, poolAddress, opts } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const quoteMintStr = quoteMintParam ?? types_1.WSOL_MINT;
+        const poolPk = poolAddress
+            ? new web3_js_1.PublicKey(poolAddress)
+            : await this.resolvePool(tokenMint, quoteMintStr);
+        const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        // Determine token program for baseMint
+        const baseMintAccInfo = await connection.getAccountInfo(baseMintPk);
+        if (!baseMintAccInfo) {
+            throw new Error(`Token mint not found: ${tokenMint}`);
+        }
+        const baseTokenProgram = baseMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        // Get token balance
+        const ata = await (0, spl_token_1.getAssociatedTokenAddress)(baseMintPk, wallet.publicKey, false, baseTokenProgram);
+        const tokenAccount = await (0, spl_token_1.getAccount)(connection, ata, "confirmed", baseTokenProgram);
+        const balance = tokenAccount.amount;
+        // Calculate sell amount based on percentage
+        const sellAmount = new bn_js_1.default(Math.floor((Number(balance) * percentage) / 100).toString());
+        if (sellAmount.isZero()) {
+            throw new Error(`No balance to sell for ${tokenMint}`);
+        }
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const swapParams = {
+            payer: wallet.publicKey,
+            pool: poolPk,
+            inputTokenMint: baseMintPk,
+            outputTokenMint: quoteMintPk,
+            amountIn: sellAmount,
+            minimumAmountOut: new bn_js_1.default(0),
+            tokenAMint: poolState.tokenAMint,
+            tokenBMint: poolState.tokenBMint,
+            tokenAVault: poolState.tokenAVault,
+            tokenBVault: poolState.tokenBVault,
+            tokenAProgram: getTokenProgram(poolState.tokenAFlag),
+            tokenBProgram: getTokenProgram(poolState.tokenBFlag),
+            referralTokenAccount: null,
+        };
+        const swapTx = await cpAmm.swap(swapParams);
+        const computeLimit = opts?.computeUnitLimit ?? types_1.DEFAULT_COMPUTE_UNIT_LIMIT;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            ...swapTx.instructions,
+        ];
+        const rpcResult = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+        });
+        // Get actual token decimals for human-readable amount
+        let tokenDecimals = 9; // default
+        try {
+            const mintData = await connection.getTokenSupply(baseMintPk);
+            tokenDecimals = mintData.value.decimals;
+        }
+        catch { /* fallback to 9 */ }
+        const humanAmount = Number(sellAmount.toString()) / Math.pow(10, tokenDecimals);
+        return {
+            txSignature: rpcResult.txSignature,
+            confirmed: rpcResult.confirmed,
+            amountIn: humanAmount,
+            amountInToken: tokenMint,
+            dex: this.name,
+            poolAddress: poolPk.toBase58(),
+        };
+    }
+    // ----- Snipe -----
+    async snipe(params) {
+        const { tokenMint, amountSol, poolAddress, quoteMint: quoteMintParam, tipSol, opts } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const quoteMintStr = quoteMintParam ?? types_1.WSOL_MINT;
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        const inputAmount = amountToLamports(amountSol, quoteMintStr);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const swapParams = {
+            payer: wallet.publicKey,
+            pool: poolPk,
+            inputTokenMint: quoteMintPk,
+            outputTokenMint: baseMintPk,
+            amountIn: inputAmount,
+            minimumAmountOut: new bn_js_1.default(0), // unlimited slippage for snipe
+            tokenAMint: poolState.tokenAMint,
+            tokenBMint: poolState.tokenBMint,
+            tokenAVault: poolState.tokenAVault,
+            tokenBVault: poolState.tokenBVault,
+            tokenAProgram: getTokenProgram(poolState.tokenAFlag),
+            tokenBProgram: getTokenProgram(poolState.tokenBFlag),
+            referralTokenAccount: null,
+        };
+        const swapTx = await cpAmm.swap(swapParams);
+        const computeLimit = opts?.computeUnitLimit ?? types_1.DEFAULT_COMPUTE_UNIT_LIMIT;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? 40_000_000; // high priority for snipe
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            ...swapTx.instructions,
+        ];
+        const blockhash = await connection.getLatestBlockhash();
+        const results = await (0, landing_1.landTransaction)(ixs, wallet, blockhash, {
+            dex: this.name,
+            operation: "snipe",
+            tipSol,
+            addressLookupTables: opts?.addressLookupTables,
+        });
+        const accepted = results.find((r) => r.accepted);
+        return {
+            txSignature: accepted?.signature ?? "",
+            confirmed: !!accepted?.accepted,
+            amountIn: amountSol,
+            amountInToken: quoteMintStr,
+            dex: this.name,
+            poolAddress,
+        };
+    }
+    // ----- buildSwapIxs -----
+    async buildSwapIxs(params) {
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        if ("percentage" in params) {
+            // Sell path
+            const sellParams = params;
+            const tokenMint = (0, types_1.requireTokenMint)(sellParams, this.name);
+            const quoteMintStr = sellParams.quoteMint ?? types_1.WSOL_MINT;
+            const poolPk = sellParams.poolAddress
+                ? new web3_js_1.PublicKey(sellParams.poolAddress)
+                : await this.resolvePool(tokenMint, quoteMintStr);
+            const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+            const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+            // Get balance
+            const baseMintAccInfo = await connection.getAccountInfo(baseMintPk);
+            const baseTokenProgram = baseMintAccInfo?.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID) ? spl_token_1.TOKEN_2022_PROGRAM_ID : spl_token_1.TOKEN_PROGRAM_ID;
+            const ata = await (0, spl_token_1.getAssociatedTokenAddress)(baseMintPk, wallet.publicKey, false, baseTokenProgram);
+            const tokenAccount = await (0, spl_token_1.getAccount)(connection, ata, "confirmed", baseTokenProgram);
+            const sellAmount = new bn_js_1.default(Math.floor((Number(tokenAccount.amount) * sellParams.percentage) / 100).toString());
+            const poolState = await cpAmm.fetchPoolState(poolPk);
+            const swapTx = await cpAmm.swap({
+                payer: wallet.publicKey,
+                pool: poolPk,
+                inputTokenMint: baseMintPk,
+                outputTokenMint: quoteMintPk,
+                amountIn: sellAmount,
+                minimumAmountOut: new bn_js_1.default(0),
+                tokenAMint: poolState.tokenAMint,
+                tokenBMint: poolState.tokenBMint,
+                tokenAVault: poolState.tokenAVault,
+                tokenBVault: poolState.tokenBVault,
+                tokenAProgram: getTokenProgram(poolState.tokenAFlag),
+                tokenBProgram: getTokenProgram(poolState.tokenBFlag),
+                referralTokenAccount: null,
+            });
+            return { instructions: swapTx.instructions, signers: [] };
+        }
+        // Buy path
+        const buyParams = params;
+        const tokenMint = (0, types_1.requireTokenMint)(buyParams, this.name);
+        const quoteMintStr = buyParams.quoteMint ?? types_1.WSOL_MINT;
+        const poolPk = buyParams.poolAddress
+            ? new web3_js_1.PublicKey(buyParams.poolAddress)
+            : await this.resolvePool(tokenMint, quoteMintStr);
+        const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        const inputAmount = amountToLamports(buyParams.amountSol, quoteMintStr);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const swapTx = await cpAmm.swap({
+            payer: wallet.publicKey,
+            pool: poolPk,
+            inputTokenMint: quoteMintPk,
+            outputTokenMint: baseMintPk,
+            amountIn: inputAmount,
+            minimumAmountOut: new bn_js_1.default(0),
+            tokenAMint: poolState.tokenAMint,
+            tokenBMint: poolState.tokenBMint,
+            tokenAVault: poolState.tokenAVault,
+            tokenBVault: poolState.tokenBVault,
+            tokenAProgram: getTokenProgram(poolState.tokenAFlag),
+            tokenBProgram: getTokenProgram(poolState.tokenBFlag),
+            referralTokenAccount: null,
+        });
+        return { instructions: swapTx.instructions, signers: [] };
+    }
+    // ----- findPool -----
+    async findPool(baseMint, quoteMint) {
+        const connection = (0, config_1.getConnection)();
+        const baseMintPk = new web3_js_1.PublicKey(baseMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMint ?? types_1.WSOL_MINT);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        // Try customizable pool PDA first (most common)
+        const customPoolAddr = deriveCustomizablePoolAddress(baseMintPk, quoteMintPk);
+        try {
+            const poolState = await cpAmm.fetchPoolState(customPoolAddr);
+            if (poolState) {
+                return {
+                    address: customPoolAddr.toBase58(),
+                    dex: this.name,
+                    protocol: this.protocol,
+                    baseMint,
+                    quoteMint: quoteMint ?? types_1.WSOL_MINT,
+                    baseDecimals: 0, // CpAmm poolState doesn't directly expose decimals
+                    quoteDecimals: 0,
+                };
+            }
+        }
+        catch {
+            // Not found at customizable PDA — fall through
+        }
+        // Could iterate config-based pools but that's expensive (requires getAllConfigs).
+        // For now, return null — callers should provide poolAddress when possible.
+        return null;
+    }
+    // ----- getPrice -----
+    async getPrice(poolAddress) {
+        const connection = (0, config_1.getConnection)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const sqrtMaxPrice = poolState.sqrtMaxPrice;
+        const sqrtMinPrice = poolState.sqrtMinPrice;
+        // Fetch vault balances for price calculation
+        const [balA, balB] = await Promise.all([
+            connection.getTokenAccountBalance(poolState.tokenAVault),
+            connection.getTokenAccountBalance(poolState.tokenBVault),
+        ]);
+        const tokenAAmount = new bn_js_1.default(balA.value.amount);
+        const tokenBAmount = new bn_js_1.default(balB.value.amount);
+        const decimalsA = balA.value.decimals;
+        const decimalsB = balB.value.decimals;
+        let price;
+        if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
+            price = 0;
+        }
+        else {
+            const sqrtPriceX64 = calculateInitSqrtPrice(tokenAAmount, tokenBAmount, sqrtMinPrice, sqrtMaxPrice);
+            const priceDecimal = sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB);
+            price = Number(priceDecimal);
+        }
+        return {
+            price,
+            baseMint: poolState.tokenAMint.toBase58(),
+            quoteMint: poolState.tokenBMint.toBase58(),
+            source: "on-chain",
+            poolAddress,
+            timestamp: Date.now(),
+        };
+    }
+    // ----- LP: addLiquidity -----
+    /**
+     * Add liquidity to an existing DAMM v2 pool by creating a new position.
+     *
+     * DAMM v2 uses full-range positions (MIN_SQRT_PRICE → MAX_SQRT_PRICE).
+     *
+     * The correct pattern (from zodiac/operator meteora-executor.ts):
+     *   1. Read the pool's actual sqrtPrice from on-chain state
+     *   2. Compute both token amounts proportionally from pool vault reserves
+     *   3. Pass both amounts + pool's sqrtPrice to getLiquidityDelta()
+     *
+     * The SDK's getLiquidityDelta is the black box — give it both max amounts
+     * + the current sqrtPrice, it figures out the correct liquidity delta.
+     */
+    async addLiquidity(params) {
+        const { poolAddress, opts } = params;
+        const inputAmountSol = params.amountSol ?? params.amountA;
+        const inputAmountToken = params.amountToken ?? params.amountB;
+        if ((inputAmountSol === undefined || inputAmountSol === 0) &&
+            (inputAmountToken === undefined || inputAmountToken === 0)) {
+            throw new Error("At least one of --amount-sol or --amount-token is required for DAMM v2 addLiquidity");
+        }
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        // Pool's current sqrt price from on-chain state — the ground truth
+        const currentSqrtPrice = poolState.sqrtPrice;
+        // Fetch decimals for both tokens
+        const tokenAMint = poolState.tokenAMint;
+        const tokenBMint = poolState.tokenBMint;
+        const tokenAProgram = (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenAFlag);
+        const tokenBProgram = (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenBFlag);
+        const [tokenAMintInfo, tokenBMintInfo] = await Promise.all([
+            connection.getAccountInfo(tokenAMint),
+            connection.getAccountInfo(tokenBMint),
+        ]);
+        if (!tokenAMintInfo || !tokenBMintInfo) {
+            throw new Error("Failed to fetch mint account info");
+        }
+        const mintA = (0, spl_token_1.unpackMint)(tokenAMint, tokenAMintInfo, tokenAMintInfo.owner);
+        const mintB = (0, spl_token_1.unpackMint)(tokenBMint, tokenBMintInfo, tokenBMintInfo.owner);
+        const decimalsA = mintA.decimals;
+        const decimalsB = mintB.decimals;
+        // Detect Token-2022 transfer fees
+        let tokenAInfo;
+        let tokenBInfo;
+        if (tokenAMintInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            tokenAInfo = { mint: mintA, currentEpoch: epochInfo.epoch };
+        }
+        if (tokenBMintInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            tokenBInfo = { mint: mintB, currentEpoch: epochInfo.epoch };
+        }
+        // Read pool vault balances for proportional calculation
+        const [balA, balB] = await Promise.all([
+            connection.getTokenAccountBalance(poolState.tokenAVault),
+            connection.getTokenAccountBalance(poolState.tokenBVault),
+        ]);
+        const reserveA = new bn_js_1.default(balA.value.amount);
+        const reserveB = new bn_js_1.default(balB.value.amount);
+        // Compute both token amounts. When only one side is given,
+        // derive the other proportionally from pool vault reserves.
+        let tokenAAmount;
+        let tokenBAmount;
+        if (inputAmountSol !== undefined && inputAmountSol > 0 &&
+            inputAmountToken !== undefined && inputAmountToken > 0) {
+            // Both sides provided explicitly
+            tokenAAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountSol).mul(decimal_js_1.default.pow(10, decimalsA)).floor().toFixed());
+            tokenBAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountToken).mul(decimal_js_1.default.pow(10, decimalsB)).floor().toFixed());
+        }
+        else if (inputAmountSol !== undefined && inputAmountSol > 0) {
+            // Only SOL provided — figure out which side SOL is, derive the other
+            const solIsTokenA = tokenAMint.toBase58() === types_1.WSOL_MINT;
+            if (solIsTokenA) {
+                tokenAAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountSol).mul(decimal_js_1.default.pow(10, decimalsA)).floor().toFixed());
+                // Derive B proportionally: tokenBAmount = tokenAAmount * reserveB / reserveA
+                if (reserveA.isZero())
+                    throw new Error("Pool has zero token A reserves");
+                tokenBAmount = tokenAAmount.mul(reserveB).div(reserveA);
+            }
+            else {
+                // SOL is token B
+                tokenBAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountSol).mul(decimal_js_1.default.pow(10, decimalsB)).floor().toFixed());
+                // Derive A proportionally: tokenAAmount = tokenBAmount * reserveA / reserveB
+                if (reserveB.isZero())
+                    throw new Error("Pool has zero token B reserves");
+                tokenAAmount = tokenBAmount.mul(reserveA).div(reserveB);
+            }
+        }
+        else {
+            // Only token amount provided — figure out which side is non-SOL
+            const solIsTokenA = tokenAMint.toBase58() === types_1.WSOL_MINT;
+            if (solIsTokenA) {
+                // Non-SOL token is B side
+                tokenBAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountToken).mul(decimal_js_1.default.pow(10, decimalsB)).floor().toFixed());
+                if (reserveB.isZero())
+                    throw new Error("Pool has zero token B reserves");
+                tokenAAmount = tokenBAmount.mul(reserveA).div(reserveB);
+            }
+            else {
+                // Non-SOL token is A side (or neither is SOL — treat token as A)
+                tokenAAmount = new bn_js_1.default(new decimal_js_1.default(inputAmountToken).mul(decimal_js_1.default.pow(10, decimalsA)).floor().toFixed());
+                if (reserveA.isZero())
+                    throw new Error("Pool has zero token A reserves");
+                tokenBAmount = tokenAAmount.mul(reserveB).div(reserveA);
+            }
+        }
+        // Compute liquidityDelta using the pool's actual on-chain sqrtPrice
+        // This is the same pattern as zodiac/operator meteora-executor.ts
+        const liquidityDelta = cpAmm.getLiquidityDelta({
+            maxAmountTokenA: tokenAAmount,
+            maxAmountTokenB: tokenBAmount,
+            sqrtPrice: currentSqrtPrice,
+            sqrtMinPrice: cp_amm_sdk_1.MIN_SQRT_PRICE,
+            sqrtMaxPrice: cp_amm_sdk_1.MAX_SQRT_PRICE,
+            tokenAInfo,
+            tokenBInfo,
+        });
+        if (liquidityDelta.isZero()) {
+            throw new Error("Computed liquidityDelta is zero — amount too small for this pool");
+        }
+        // Generate a new position NFT keypair
+        const positionNft = web3_js_1.Keypair.generate();
+        // Slippage thresholds
+        const slippageBps = opts?.slippageBps ?? types_1.DEFAULT_SLIPPAGE_BPS;
+        const tokenAThreshold = tokenAAmount.muln(10000 - slippageBps).divn(10000);
+        const tokenBThreshold = tokenBAmount.muln(10000 - slippageBps).divn(10000);
+        console.log(`  tokenA:    ${tokenAAmount.toString()} (${tokenAMint.toBase58().slice(0, 8)}...)`);
+        console.log(`  tokenB:    ${tokenBAmount.toString()} (${tokenBMint.toBase58().slice(0, 8)}...)`);
+        console.log(`  liqDelta:  ${liquidityDelta.toString()}`);
+        const addLiqTx = await cpAmm.createPositionAndAddLiquidity({
+            owner: wallet.publicKey,
+            pool: poolPk,
+            positionNft: positionNft.publicKey,
+            liquidityDelta,
+            maxAmountTokenA: tokenAAmount,
+            maxAmountTokenB: tokenBAmount,
+            tokenAAmountThreshold: tokenAThreshold,
+            tokenBAmountThreshold: tokenBThreshold,
+            tokenAMint,
+            tokenBMint,
+            tokenAProgram,
+            tokenBProgram,
+        });
+        const computeLimit = opts?.computeUnitLimit ?? 400_000;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            ...addLiqTx.instructions,
+        ];
+        // Submit via RPC send+confirm
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+            extraSigners: [positionNft],
+        });
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+        };
+    }
+    // ----- LP: removeLiquidity -----
+    /**
+     * Remove liquidity from all DAMM v2 positions on a pool.
+     *
+     * Uses getPositionsByUser() to discover positions on-chain (no database
+     * dependency), then calls removeAllLiquidityAndClosePosition() for each.
+     *
+     * Params:
+     *   - poolAddress: the pool to remove liquidity from
+     *   - percentage: 100 = remove all, <100 = partial (only full removal
+     *     supported by the SDK's close-position method — partial uses removeLiquidity)
+     *
+     * Ported from: 100x-algo-bots/trading-modules/meteora-damm-v2/pool.ts
+     *   removeAllLiquidityAndCloseAllPositions()
+     */
+    async removeLiquidity(params) {
+        const { poolAddress, percentage, opts } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        // Discover user positions on-chain — no database needed
+        const userPositions = await cpAmm.getPositionsByUser(wallet.publicKey);
+        // Filter to positions belonging to this pool
+        const poolPositions = userPositions.filter((p) => p.positionState.pool.toBase58() === poolAddress);
+        if (poolPositions.length === 0) {
+            throw new Error(`No positions found for pool ${poolAddress}`);
+        }
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        const currentSlot = await connection.getSlot();
+        const currentPoint = new bn_js_1.default(currentSlot);
+        let lastSignature = "";
+        let anyConfirmed = false;
+        for (const pos of poolPositions) {
+            const positionState = await cpAmm.fetchPositionState(pos.position);
+            // Check total liquidity
+            const totalLiquidity = positionState.unlockedLiquidity
+                .add(positionState.vestedLiquidity)
+                .add(positionState.permanentLockedLiquidity);
+            if (totalLiquidity.isZero()) {
+                continue; // skip empty positions
+            }
+            // Skip permanently locked positions — cannot close
+            if (!positionState.permanentLockedLiquidity.isZero()) {
+                console.log(`Skipping position ${pos.position.toBase58()} — has permanent locked liquidity`);
+                continue;
+            }
+            const computeLimit = opts?.computeUnitLimit ?? 400_000;
+            const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+            if (percentage >= 100) {
+                // Full removal + close position
+                const closeTx = await cpAmm.removeAllLiquidityAndClosePosition({
+                    owner: wallet.publicKey,
+                    position: pos.position,
+                    positionNftAccount: pos.positionNftAccount,
+                    positionState,
+                    poolState,
+                    tokenAAmountThreshold: new bn_js_1.default(0),
+                    tokenBAmountThreshold: new bn_js_1.default(0),
+                    currentPoint,
+                    vestings: [],
+                });
+                const ixs = [
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+                    ...closeTx.instructions,
+                ];
+                // Submit via RPC send+confirm
+                const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+                    addressLookupTables: opts?.addressLookupTables,
+                });
+                if (result.txSignature)
+                    lastSignature = result.txSignature;
+                if (result.confirmed)
+                    anyConfirmed = true;
+            }
+            else {
+                // Partial removal — calculate proportional liquidityDelta
+                const removableLiquidity = positionState.unlockedLiquidity.add(positionState.vestedLiquidity);
+                const liquidityDelta = removableLiquidity.muln(percentage).divn(100);
+                if (liquidityDelta.isZero()) {
+                    continue;
+                }
+                const removeTx = await cpAmm.removeLiquidity({
+                    owner: wallet.publicKey,
+                    position: pos.position,
+                    pool: poolPk,
+                    positionNftAccount: pos.positionNftAccount,
+                    liquidityDelta,
+                    tokenAAmountThreshold: new bn_js_1.default(0),
+                    tokenBAmountThreshold: new bn_js_1.default(0),
+                    tokenAMint: poolState.tokenAMint,
+                    tokenBMint: poolState.tokenBMint,
+                    tokenAVault: poolState.tokenAVault,
+                    tokenBVault: poolState.tokenBVault,
+                    tokenAProgram: (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenAFlag),
+                    tokenBProgram: (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenBFlag),
+                    vestings: [],
+                    currentPoint,
+                });
+                const ixs = [
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+                    ...removeTx.instructions,
+                ];
+                // Submit via RPC send+confirm
+                const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+                    addressLookupTables: opts?.addressLookupTables,
+                });
+                if (result.txSignature)
+                    lastSignature = result.txSignature;
+                if (result.confirmed)
+                    anyConfirmed = true;
+            }
+        }
+        return {
+            txSignature: lastSignature,
+            confirmed: anyConfirmed,
+        };
+    }
+    // ----- LP: claimFees -----
+    /**
+     * Claim unclaimed fees from all DAMM v2 positions on a pool.
+     *
+     * Uses getPositionsByUser() + on-chain fee math (no database dependency).
+     * Iterates all positions for the given pool, skips those with zero fees.
+     *
+     * Ported from: 100x-algo-bots/trading-modules/meteora-damm-v2/pool.ts
+     *   claimAllPositionFees() + getUnClaimLpFee()
+     */
+    async claimFees(poolAddress, _positionAddress) {
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const userPositions = await cpAmm.getPositionsByUser(wallet.publicKey);
+        // Filter to positions belonging to this pool
+        const poolPositions = userPositions.filter((p) => p.positionState.pool.toBase58() === poolAddress);
+        if (poolPositions.length === 0) {
+            throw new Error(`No positions found for pool ${poolAddress}`);
+        }
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        let lastSignature = "";
+        let anyConfirmed = false;
+        for (const pos of poolPositions) {
+            const positionState = await cpAmm.fetchPositionState(pos.position);
+            // Calculate unclaimed fees using on-chain math
+            // Ported from source getUnClaimLpFee()
+            const totalPositionLiquidity = positionState.unlockedLiquidity
+                .add(positionState.vestedLiquidity)
+                .add(positionState.permanentLockedLiquidity);
+            const feeAPerTokenStored = new bn_js_1.default(Buffer.from(poolState.feeAPerLiquidity).reverse()).sub(new bn_js_1.default(Buffer.from(positionState.feeAPerTokenCheckpoint).reverse()));
+            const feeBPerTokenStored = new bn_js_1.default(Buffer.from(poolState.feeBPerLiquidity).reverse()).sub(new bn_js_1.default(Buffer.from(positionState.feeBPerTokenCheckpoint).reverse()));
+            const feeA = positionState.feeAPending.add(totalPositionLiquidity.mul(feeAPerTokenStored).shrn(cp_amm_sdk_1.LIQUIDITY_SCALE));
+            const feeB = positionState.feeBPending.add(totalPositionLiquidity.mul(feeBPerTokenStored).shrn(cp_amm_sdk_1.LIQUIDITY_SCALE));
+            // Skip if no fees to claim
+            if (feeA.isZero() && feeB.isZero()) {
+                continue;
+            }
+            const claimTx = await cpAmm.claimPositionFee2({
+                owner: wallet.publicKey,
+                pool: poolPk,
+                position: pos.position,
+                receiver: wallet.publicKey,
+                positionNftAccount: pos.positionNftAccount,
+                tokenAVault: poolState.tokenAVault,
+                tokenBVault: poolState.tokenBVault,
+                tokenAMint: poolState.tokenAMint,
+                tokenBMint: poolState.tokenBMint,
+                tokenAProgram: (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenAFlag),
+                tokenBProgram: (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenBFlag),
+            });
+            const ixs = [
+                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
+                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS }),
+                ...claimTx.instructions,
+            ];
+            // Submit via RPC send+confirm
+            const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet);
+            if (result.txSignature)
+                lastSignature = result.txSignature;
+            if (result.confirmed)
+                anyConfirmed = true;
+        }
+        return {
+            txSignature: lastSignature,
+            confirmed: anyConfirmed,
+        };
+    }
+    // ----- Pool creation: createCustomPool -----
+    /**
+     * Create a DAMM v2 pool with full fee configuration (custom pool).
+     *
+     * Uses `cpAmm.createCustomPool()` — allows setting fee schedule, price range,
+     * activation params, dynamic fee, and collect-fee mode.
+     *
+     * This is the primary method for token launches. Creates a customizable pool
+     * with MIN_SQRT_PRICE → MAX_SQRT_PRICE full-range liquidity.
+     *
+     * Ported from: 100x-algo-bots/trading-modules/meteora-damm-v2/create.ts
+     *   createDammV2BalancedPool()
+     */
+    async createCustomPool(params) {
+        const { baseMint, quoteMint: quoteMintParam, baseAmount, quoteAmount, poolFees, collectFeeMode = 1, activationType = 1, activationPoint = null, hasAlphaVault = false, opts, } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const quoteMintStr = quoteMintParam ?? types_1.WSOL_MINT;
+        const baseMintPk = new web3_js_1.PublicKey(baseMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        // Fetch mint info for both tokens
+        const [baseMintAccInfo, quoteMintAccInfo] = await Promise.all([
+            connection.getAccountInfo(baseMintPk),
+            connection.getAccountInfo(quoteMintPk),
+        ]);
+        if (!baseMintAccInfo)
+            throw new Error(`Base mint not found: ${baseMint}`);
+        if (!quoteMintAccInfo)
+            throw new Error(`Quote mint not found: ${quoteMintStr}`);
+        const baseMintData = (0, spl_token_1.unpackMint)(baseMintPk, baseMintAccInfo, baseMintAccInfo.owner);
+        const quoteMintData = (0, spl_token_1.unpackMint)(quoteMintPk, quoteMintAccInfo, quoteMintAccInfo.owner);
+        const baseDecimals = baseMintData.decimals;
+        const quoteDecimalCount = quoteDecimals(quoteMintStr);
+        const baseTokenProgram = baseMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        const quoteTokenProgram = quoteMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        // Detect Token-2022 transfer fees
+        let baseTokenInfo;
+        let quoteTokenInfo;
+        if (baseMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            baseTokenInfo = { mint: baseMintData, currentEpoch: epochInfo.epoch };
+        }
+        if (quoteMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            quoteTokenInfo = { mint: quoteMintData, currentEpoch: epochInfo.epoch };
+        }
+        // Convert human amounts to lamports
+        let tokenAAmount = new bn_js_1.default(new decimal_js_1.default(baseAmount).mul(decimal_js_1.default.pow(10, baseDecimals)).floor().toFixed());
+        let tokenBAmount = new bn_js_1.default(new decimal_js_1.default(quoteAmount).mul(decimal_js_1.default.pow(10, quoteDecimalCount)).floor().toFixed());
+        // Subtract transfer fees for Token-2022 tokens
+        if (baseTokenInfo) {
+            tokenAAmount = tokenAAmount.sub((0, cp_amm_sdk_1.calculateTransferFeeIncludedAmount)(tokenAAmount, baseTokenInfo.mint, baseTokenInfo.currentEpoch).transferFee);
+        }
+        if (quoteTokenInfo) {
+            tokenBAmount = tokenBAmount.sub((0, cp_amm_sdk_1.calculateTransferFeeIncludedAmount)(tokenBAmount, quoteTokenInfo.mint, quoteTokenInfo.currentEpoch).transferFee);
+        }
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        // Calculate initial sqrt price
+        const initPrice = params.initPrice ?? quoteAmount / baseAmount;
+        const initSqrtPrice = (0, cp_amm_sdk_1.getSqrtPriceFromPrice)(initPrice.toString(), baseDecimals, quoteDecimalCount);
+        // Full-range liquidity
+        const minSqrtPrice = cp_amm_sdk_1.MIN_SQRT_PRICE;
+        const maxSqrtPrice = cp_amm_sdk_1.MAX_SQRT_PRICE;
+        const liquidityDelta = cpAmm.getLiquidityDelta({
+            maxAmountTokenA: tokenAAmount,
+            maxAmountTokenB: tokenBAmount,
+            sqrtPrice: initSqrtPrice,
+            sqrtMinPrice: minSqrtPrice,
+            sqrtMaxPrice: maxSqrtPrice,
+            tokenAInfo: baseTokenInfo,
+        });
+        // Build fee params
+        const { maxBaseFeeBps, minBaseFeeBps, numberOfPeriod, totalDuration, feeSchedulerMode, useDynamicFee, dynamicFeeConfig, } = poolFees;
+        let dynamicFee = null;
+        if (useDynamicFee) {
+            if (dynamicFeeConfig) {
+                dynamicFee = {
+                    binStep: cp_amm_sdk_1.BIN_STEP_BPS_DEFAULT,
+                    binStepU128: cp_amm_sdk_1.BIN_STEP_BPS_U128_DEFAULT,
+                    filterPeriod: dynamicFeeConfig.filterPeriod,
+                    decayPeriod: dynamicFeeConfig.decayPeriod,
+                    reductionFactor: dynamicFeeConfig.reductionFactor,
+                    variableFeeControl: dynamicFeeConfig.variableFeeControl,
+                    maxVolatilityAccumulator: dynamicFeeConfig.maxVolatilityAccumulator,
+                };
+            }
+            else {
+                dynamicFee = (0, cp_amm_sdk_1.getDynamicFeeParams)(minBaseFeeBps);
+            }
+        }
+        const baseFee = (0, cp_amm_sdk_1.getBaseFeeParams)({
+            baseFeeMode: feeSchedulerMode === 0
+                ? cp_amm_sdk_1.BaseFeeMode.FeeTimeSchedulerLinear
+                : cp_amm_sdk_1.BaseFeeMode.FeeTimeSchedulerExponential,
+            feeTimeSchedulerParam: {
+                startingFeeBps: maxBaseFeeBps,
+                endingFeeBps: minBaseFeeBps,
+                numberOfPeriod,
+                totalDuration,
+            },
+        }, quoteDecimalCount, cp_amm_sdk_1.ActivationType.Timestamp);
+        const poolFeesParams = {
+            baseFee,
+            padding: [],
+            dynamicFee,
+        };
+        const positionNft = web3_js_1.Keypair.generate();
+        const { tx: initCustomPoolTx, pool, position, } = await cpAmm.createCustomPool({
+            payer: wallet.publicKey,
+            creator: wallet.publicKey,
+            positionNft: positionNft.publicKey,
+            tokenAMint: baseMintPk,
+            tokenBMint: quoteMintPk,
+            tokenAAmount,
+            tokenBAmount,
+            sqrtMinPrice: minSqrtPrice,
+            sqrtMaxPrice: maxSqrtPrice,
+            liquidityDelta,
+            initSqrtPrice,
+            poolFees: poolFeesParams,
+            hasAlphaVault,
+            activationType,
+            collectFeeMode,
+            activationPoint: activationPoint != null ? new bn_js_1.default(activationPoint) : null,
+            tokenAProgram: baseTokenProgram,
+            tokenBProgram: quoteTokenProgram,
+        });
+        const computeLimit = opts?.computeUnitLimit ?? 400_000;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            ...initCustomPoolTx.instructions,
+        ];
+        console.log(`  pool:      ${pool.toBase58()}`);
+        console.log(`  position:  ${position.toBase58()}`);
+        console.log(`  price:     ${(0, cp_amm_sdk_1.getPriceFromSqrtPrice)(initSqrtPrice, baseDecimals, quoteDecimalCount)}`);
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+            extraSigners: [positionNft],
+        });
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+            poolAddress: pool.toBase58(),
+            positionAddress: position.toBase58(),
+            dex: this.name,
+        };
+    }
+    // ----- Pool creation: createConfigPool -----
+    /**
+     * Create a DAMM v2 pool using a pre-existing on-chain config.
+     *
+     * Uses `cpAmm.createPool()` — simpler, less customizable. The config
+     * determines the fee schedule and price range boundaries.
+     *
+     * Ported from: 100x-algo-bots/trading-modules/meteora-damm-v2/create.ts
+     *   createDammV2Pool()
+     */
+    async createConfigPool(params) {
+        const { baseMint, quoteMint: quoteMintParam, baseAmount, quoteAmount, configAddress, activationPoint = null, lockLiquidity = false, opts, } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const quoteMintStr = quoteMintParam ?? types_1.WSOL_MINT;
+        const baseMintPk = new web3_js_1.PublicKey(baseMint);
+        const quoteMintPk = new web3_js_1.PublicKey(quoteMintStr);
+        const configPk = new web3_js_1.PublicKey(configAddress);
+        // Fetch mint info
+        const [baseMintAccInfo, quoteMintAccInfo] = await Promise.all([
+            connection.getAccountInfo(baseMintPk),
+            connection.getAccountInfo(quoteMintPk),
+        ]);
+        if (!baseMintAccInfo)
+            throw new Error(`Base mint not found: ${baseMint}`);
+        if (!quoteMintAccInfo)
+            throw new Error(`Quote mint not found: ${quoteMintStr}`);
+        const baseMintData = (0, spl_token_1.unpackMint)(baseMintPk, baseMintAccInfo, baseMintAccInfo.owner);
+        const quoteMintData = (0, spl_token_1.unpackMint)(quoteMintPk, quoteMintAccInfo, quoteMintAccInfo.owner);
+        const baseDecimals = baseMintData.decimals;
+        const quoteDecimalCount = quoteDecimals(quoteMintStr);
+        const baseTokenProgram = baseMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        const quoteTokenProgram = quoteMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)
+            ? spl_token_1.TOKEN_2022_PROGRAM_ID
+            : spl_token_1.TOKEN_PROGRAM_ID;
+        // Token-2022 transfer fee detection
+        let baseTokenInfo;
+        let quoteTokenInfo;
+        if (baseMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            baseTokenInfo = { mint: baseMintData, currentEpoch: epochInfo.epoch };
+        }
+        if (quoteMintAccInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+            const epochInfo = await connection.getEpochInfo();
+            quoteTokenInfo = { mint: quoteMintData, currentEpoch: epochInfo.epoch };
+        }
+        let tokenAAmount = new bn_js_1.default(new decimal_js_1.default(baseAmount).mul(decimal_js_1.default.pow(10, baseDecimals)).floor().toFixed());
+        let tokenBAmount = new bn_js_1.default(new decimal_js_1.default(quoteAmount).mul(decimal_js_1.default.pow(10, quoteDecimalCount)).floor().toFixed());
+        if (baseTokenInfo) {
+            tokenAAmount = tokenAAmount.sub((0, cp_amm_sdk_1.calculateTransferFeeIncludedAmount)(tokenAAmount, baseTokenInfo.mint, baseTokenInfo.currentEpoch).transferFee);
+        }
+        if (quoteTokenInfo) {
+            tokenBAmount = tokenBAmount.sub((0, cp_amm_sdk_1.calculateTransferFeeIncludedAmount)(tokenBAmount, quoteTokenInfo.mint, quoteTokenInfo.currentEpoch).transferFee);
+        }
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        // Fetch config state to get its price range
+        const configState = await cpAmm.fetchConfigState(configPk);
+        // Calculate initial sqrt price
+        const initPrice = params.initPrice ?? quoteAmount / baseAmount;
+        const initSqrtPrice = (0, cp_amm_sdk_1.getSqrtPriceFromPrice)(initPrice.toString(), baseDecimals, quoteDecimalCount);
+        // Use config's price range for liquidity delta
+        const liquidityDelta = cpAmm.getLiquidityDelta({
+            maxAmountTokenA: tokenAAmount,
+            maxAmountTokenB: tokenBAmount,
+            sqrtPrice: initSqrtPrice,
+            sqrtMinPrice: configState.sqrtMinPrice,
+            sqrtMaxPrice: configState.sqrtMaxPrice,
+            tokenAInfo: baseTokenInfo,
+        });
+        const positionNft = web3_js_1.Keypair.generate();
+        const initPoolTx = await cpAmm.createPool({
+            payer: wallet.publicKey,
+            creator: wallet.publicKey,
+            config: configPk,
+            positionNft: positionNft.publicKey,
+            tokenAMint: baseMintPk,
+            tokenBMint: quoteMintPk,
+            tokenAAmount,
+            tokenBAmount,
+            liquidityDelta,
+            initSqrtPrice,
+            activationPoint: activationPoint != null ? new bn_js_1.default(activationPoint) : null,
+            tokenAProgram: baseTokenProgram,
+            tokenBProgram: quoteTokenProgram,
+            isLockLiquidity: lockLiquidity,
+        });
+        // Derive addresses for logging
+        const pool = derivePoolAddress(configPk, baseMintPk, quoteMintPk);
+        const position = derivePositionAddress(positionNft.publicKey);
+        const computeLimit = opts?.computeUnitLimit ?? 400_000;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+            ...initPoolTx.instructions,
+        ];
+        console.log(`  pool:      ${pool.toBase58()}`);
+        console.log(`  position:  ${position.toBase58()}`);
+        console.log(`  config:    ${configAddress}`);
+        console.log(`  price:     ${(0, cp_amm_sdk_1.getPriceFromSqrtPrice)(initSqrtPrice, baseDecimals, quoteDecimalCount)}`);
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+            extraSigners: [positionNft],
+        });
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+            poolAddress: pool.toBase58(),
+            positionAddress: position.toBase58(),
+            dex: this.name,
+        };
+    }
+    // ----- LP: listPositions -----
+    /**
+     * List all DAMM v2 positions owned by the user on a specific pool.
+     *
+     * Uses `getPositionsByUser()` to discover positions on-chain, then
+     * calculates unclaimed fees for each position.
+     *
+     * Ported from: 100x-algo-bots/trading-modules/meteora-damm-v2/pool.ts
+     *   fetchPositionsByUser()
+     */
+    async listPositions(poolAddress) {
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const cpAmm = new cp_amm_sdk_1.CpAmm(connection);
+        const userPositions = await cpAmm.getPositionsByUser(wallet.publicKey);
+        // Filter to positions belonging to this pool
+        const poolPositions = userPositions.filter((p) => p.positionState.pool.toBase58() === poolAddress);
+        if (poolPositions.length === 0) {
+            return [];
+        }
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const poolState = await cpAmm.fetchPoolState(poolPk);
+        // Fetch decimals for both tokens
+        const tokenAMint = poolState.tokenAMint;
+        const tokenBMint = poolState.tokenBMint;
+        const tokenAProgram = (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenAFlag);
+        const tokenBProgram = (0, cp_amm_sdk_1.getTokenProgram)(poolState.tokenBFlag);
+        const [tokenAMintInfo, tokenBMintInfo] = await Promise.all([
+            connection.getAccountInfo(tokenAMint),
+            connection.getAccountInfo(tokenBMint),
+        ]);
+        const mintA = (0, spl_token_1.unpackMint)(tokenAMint, tokenAMintInfo, tokenAMintInfo.owner);
+        const mintB = (0, spl_token_1.unpackMint)(tokenBMint, tokenBMintInfo, tokenBMintInfo.owner);
+        const decimalsA = mintA.decimals;
+        const decimalsB = mintB.decimals;
+        const results = [];
+        for (const pos of poolPositions) {
+            const positionState = await cpAmm.fetchPositionState(pos.position);
+            // Calculate unclaimed fees (same math as claimFees)
+            const totalPositionLiquidity = positionState.unlockedLiquidity
+                .add(positionState.vestedLiquidity)
+                .add(positionState.permanentLockedLiquidity);
+            const feeAPerTokenStored = new bn_js_1.default(Buffer.from(poolState.feeAPerLiquidity).reverse()).sub(new bn_js_1.default(Buffer.from(positionState.feeAPerTokenCheckpoint).reverse()));
+            const feeBPerTokenStored = new bn_js_1.default(Buffer.from(poolState.feeBPerLiquidity).reverse()).sub(new bn_js_1.default(Buffer.from(positionState.feeBPerTokenCheckpoint).reverse()));
+            const feeA = positionState.feeAPending.add(totalPositionLiquidity.mul(feeAPerTokenStored).shrn(cp_amm_sdk_1.LIQUIDITY_SCALE));
+            const feeB = positionState.feeBPending.add(totalPositionLiquidity.mul(feeBPerTokenStored).shrn(cp_amm_sdk_1.LIQUIDITY_SCALE));
+            const feeAHuman = Number(feeA.toString()) / Math.pow(10, decimalsA);
+            const feeBHuman = Number(feeB.toString()) / Math.pow(10, decimalsB);
+            // DAMM v2 uses full-range positions — lowerBinId/upperBinId not applicable
+            // but we report liquidity amounts via the vault balances proportionally
+            const hasLiquidity = !totalPositionLiquidity.isZero();
+            results.push({
+                positionAddress: pos.position.toBase58(),
+                poolAddress,
+                dex: this.name,
+                lowerBinId: 0, // full-range — not applicable
+                upperBinId: 0, // full-range — not applicable
+                amountX: 0, // per-position token amounts not directly available from state
+                amountY: 0,
+                tokenXMint: tokenAMint.toBase58(),
+                tokenYMint: tokenBMint.toBase58(),
+                feeX: feeAHuman,
+                feeY: feeBHuman,
+                inRange: hasLiquidity,
+            });
+        }
+        return results;
+    }
+    // ----- Internal helpers -----
+    async resolvePool(baseMint, quoteMint) {
+        const pool = await this.findPool(baseMint, quoteMint);
+        if (!pool) {
+            throw new types_1.PoolNotFoundError(this.name, baseMint, quoteMint);
+        }
+        return new web3_js_1.PublicKey(pool.address);
+    }
+}
+exports.MeteoraDammV2Adapter = MeteoraDammV2Adapter;
+// ---------------------------------------------------------------------------
+// Auto-register
+// ---------------------------------------------------------------------------
+(0, index_1.registerAdapter)(new MeteoraDammV2Adapter());
+//# sourceMappingURL=meteora-damm-v2.js.map