outsmart 2.0.0-alpha.0

package/dist/dex/meteora-dlmm.js

@@ -0,0 +1,735 @@
+"use strict";
+/**
+ * Meteora DLMM (Dynamic Liquidity Market Maker) — IDexAdapter Implementation
+ *
+ * Wraps the @meteora-ag/dlmm SDK for buy/sell/snipe/findPool/getPrice
+ * plus LP operations: addLiquidity, removeLiquidity, claimFees, listPositions.
+ *
+ * Source: 100x-algo-bots/trading-modules/meteora-dlmm/
+ *
+ * IMPORTANT BUG FIX: Source code hardcodes `swapYtoX = true` which only works
+ * when the user is buying (spending Y/quote to get X/base). This adapter
+ * dynamically computes the swap direction based on which token is the quote.
+ *
+ * SDK patterns:
+ *   // Swaps
+ *   const dlmmPool = await DLMM.create(connection, poolAddress);
+ *   const binArrays = await dlmmPool.getBinArrayForSwap(swapYtoX);
+ *   const quote = await dlmmPool.swapQuote(amount, swapYtoX, slippage, binArrays);
+ *   const swapTx = await dlmmPool.swap({ inToken, outToken, ... });
+ *
+ *   // LP operations
+ *   const createTx = await dlmmPool.initializePositionAndAddLiquidityByStrategy({...});
+ *   const removeTxs = await dlmmPool.removeLiquidity({...});
+ *   const claimTxs  = await dlmmPool.claimSwapFee({...});
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeteoraDlmmAdapter = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+const dlmm_1 = __importStar(require("@meteora-ag/dlmm"));
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+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
+// ---------------------------------------------------------------------------
+/** Known stablecoin mints with 6 decimals */
+const SIX_DECIMAL_MINTS = new Set([
+    types_1.USDC_MINT,
+    types_1.USDT_MINT,
+    "USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB",
+]);
+const WSOL_PK = new web3_js_1.PublicKey(types_1.WSOL_MINT);
+/** Default number of bins for LP positions */
+const DEFAULT_NUM_BINS = 50;
+/** Maximum bins allowed by the DLMM SDK per position */
+const MAX_BINS = 70;
+// ---------------------------------------------------------------------------
+// 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)));
+}
+/**
+ * Determine swap direction for DLMM pool.
+ *
+ * DLMM pools have tokenX and tokenY. swapYtoX=true means spending Y to get X.
+ * For a buy (spending quote to get base):
+ *   - If quote == tokenY → swapYtoX = true  (spend Y, get X)
+ *   - If quote == tokenX → swapYtoX = false (spend X, get Y)
+ *
+ * The source code HARDCODES swapYtoX=true which is WRONG when the quote
+ * token is tokenX. This adapter fixes that bug.
+ */
+function determineSwapDirection(quoteMintStr, tokenX, tokenY) {
+    const quotePk = new web3_js_1.PublicKey(quoteMintStr);
+    if (quotePk.equals(tokenY)) {
+        // Quote is tokenY → spend Y, get X
+        return { swapYtoX: true, inToken: tokenY, outToken: tokenX };
+    }
+    else if (quotePk.equals(tokenX)) {
+        // Quote is tokenX → spend X, get Y
+        return { swapYtoX: false, inToken: tokenX, outToken: tokenY };
+    }
+    else {
+        // Fallback: assume tokenY is quote (matches most SOL-paired pools)
+        return { swapYtoX: true, inToken: tokenY, outToken: tokenX };
+    }
+}
+/**
+ * Map our LpStrategy string to the SDK's StrategyType enum.
+ * The SDK has: Spot=0, Curve=1, BidAsk=2.
+ * One-sided behavior is controlled via the bin range (not a separate enum).
+ */
+function toSdkStrategy(strategy) {
+    switch (strategy) {
+        case "spot":
+            return dlmm_1.StrategyType.Spot;
+        case "curve":
+            return dlmm_1.StrategyType.Curve;
+        case "bid-ask":
+            return dlmm_1.StrategyType.BidAsk;
+        default:
+            return dlmm_1.StrategyType.Spot;
+    }
+}
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+class MeteoraDlmmAdapter {
+    name = "meteora-dlmm";
+    protocol = "dlmm";
+    capabilities = (0, types_1.defaultCapabilities)({
+        canBuy: true,
+        canSell: true,
+        canSnipe: true,
+        canFindPool: false, // DLMM has no simple PDA derivation
+        canGetPrice: true,
+        canAddLiquidity: true,
+        canRemoveLiquidity: true,
+        canClaimFees: true,
+        canListPositions: 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 dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const inputAmount = amountToLamports(amountSol, quoteMintStr);
+        // Dynamically determine swap direction (fixes source bug)
+        const { swapYtoX, inToken, outToken } = determineSwapDirection(quoteMintStr, dlmmPool.tokenX.publicKey, dlmmPool.tokenY.publicKey);
+        const binArrays = await dlmmPool.getBinArrayForSwap(swapYtoX);
+        const slippageBps = opts?.slippageBps ?? types_1.DEFAULT_SLIPPAGE_BPS;
+        const swapQuote = await dlmmPool.swapQuote(inputAmount, swapYtoX, new bn_js_1.default(slippageBps), binArrays);
+        const swapTx = await dlmmPool.swap({
+            inToken,
+            binArraysPubkey: swapQuote.binArraysPubkey,
+            inAmount: inputAmount,
+            lbPair: dlmmPool.pubkey,
+            user: wallet.publicKey,
+            minOutAmount: new bn_js_1.default(0),
+            outToken,
+        });
+        // DLMM SDK already includes ComputeBudget + ATA creation in swapTx.instructions
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, swapTx.instructions, 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 dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const baseMintPk = new web3_js_1.PublicKey(tokenMint);
+        // Detect base token program
+        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}`);
+        }
+        // Determine swap direction using the base token (being sold) as input
+        const { swapYtoX, inToken, outToken } = determineSwapDirection(tokenMint, dlmmPool.tokenX.publicKey, dlmmPool.tokenY.publicKey);
+        const binArrays = await dlmmPool.getBinArrayForSwap(swapYtoX);
+        const slippageBps = opts?.slippageBps ?? types_1.DEFAULT_SLIPPAGE_BPS;
+        const swapQuote = await dlmmPool.swapQuote(sellAmount, swapYtoX, new bn_js_1.default(slippageBps), binArrays);
+        const swapTx = await dlmmPool.swap({
+            inToken,
+            binArraysPubkey: swapQuote.binArraysPubkey,
+            inAmount: sellAmount,
+            lbPair: dlmmPool.pubkey,
+            user: wallet.publicKey,
+            minOutAmount: new bn_js_1.default(0),
+            outToken,
+        });
+        // DLMM SDK already includes ComputeBudget + ATA creation in swapTx.instructions
+        const rpcResult = await (0, send_rpc_1.sendAndConfirmVtx)(connection, swapTx.instructions, wallet, {
+            addressLookupTables: opts?.addressLookupTables,
+        });
+        // Human-readable sell amount
+        let tokenDecimals = 9;
+        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 inputAmount = amountToLamports(amountSol, quoteMintStr);
+        const dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        // Dynamically determine swap direction (fixes source bug)
+        const { swapYtoX, inToken, outToken } = determineSwapDirection(quoteMintStr, dlmmPool.tokenX.publicKey, dlmmPool.tokenY.publicKey);
+        const binArrays = await dlmmPool.getBinArrayForSwap(swapYtoX);
+        const swapQuote = await dlmmPool.swapQuote(inputAmount, swapYtoX, new bn_js_1.default(15 * 100), // 15% slippage for snipe (matches source)
+        binArrays);
+        const swapTx = await dlmmPool.swap({
+            inToken,
+            binArraysPubkey: swapQuote.binArraysPubkey,
+            inAmount: inputAmount,
+            lbPair: dlmmPool.pubkey,
+            user: wallet.publicKey,
+            minOutAmount: new bn_js_1.default(0), // unlimited slippage for snipe
+            outToken,
+        });
+        const computeLimit = opts?.computeUnitLimit ?? types_1.DEFAULT_COMPUTE_UNIT_LIMIT;
+        const priorityFee = opts?.priorityFeeMicroLamports ?? 40_000_000;
+        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) {
+        if ("percentage" in params) {
+            throw new types_1.UnsupportedOperationError(this.name, "buildSwapIxs(sell)");
+        }
+        const buyParams = params;
+        const tokenMint = (0, types_1.requireTokenMint)(buyParams, this.name);
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        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 dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const inputAmount = amountToLamports(buyParams.amountSol, quoteMintStr);
+        const { swapYtoX, inToken, outToken } = determineSwapDirection(quoteMintStr, dlmmPool.tokenX.publicKey, dlmmPool.tokenY.publicKey);
+        const binArrays = await dlmmPool.getBinArrayForSwap(swapYtoX);
+        const swapQuote = await dlmmPool.swapQuote(inputAmount, swapYtoX, new bn_js_1.default(15 * 100), binArrays);
+        const swapTx = await dlmmPool.swap({
+            inToken,
+            binArraysPubkey: swapQuote.binArraysPubkey,
+            inAmount: inputAmount,
+            lbPair: dlmmPool.pubkey,
+            user: wallet.publicKey,
+            minOutAmount: new bn_js_1.default(0),
+            outToken,
+        });
+        return {
+            instructions: swapTx.instructions,
+            signers: [],
+        };
+    }
+    // ----- findPool -----
+    async findPool(baseMint, quoteMint) {
+        const connection = (0, config_1.getConnection)();
+        const poolPk = new web3_js_1.PublicKey(baseMint); // For DLMM, baseMint is often used to search
+        const quoteMintStr = quoteMint ?? types_1.WSOL_MINT;
+        // DLMM doesn't have a simple PDA derivation like DAMM.
+        // The SDK's DLMM.create() requires a known pool address.
+        // For pool discovery, we'd need to use the DLMM program's getLbPairs() which
+        // requires anchor setup. Return null — callers should provide poolAddress.
+        return null;
+    }
+    // ----- getPrice -----
+    async getPrice(poolAddress) {
+        const connection = (0, config_1.getConnection)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const { binId, price: rawPrice } = await dlmmPool.getActiveBin();
+        const tokenXDecimals = Number(dlmmPool.tokenX.mint.decimals);
+        const tokenYDecimals = Number(dlmmPool.tokenY.mint.decimals);
+        const priceFactor = Math.pow(10, tokenYDecimals - tokenXDecimals);
+        const adjustedPrice = Number(rawPrice) / priceFactor;
+        const price = adjustedPrice;
+        return {
+            price,
+            baseMint: dlmmPool.tokenX.publicKey.toBase58(),
+            quoteMint: dlmmPool.tokenY.publicKey.toBase58(),
+            source: "on-chain",
+            poolAddress,
+            timestamp: Date.now(),
+        };
+    }
+    // ----- addLiquidity -----
+    /**
+     * Add liquidity to a Meteora DLMM pool.
+     *
+     * Three modes (determined by which amounts are provided):
+     *
+     * 1. One-sided SOL (amountSol > 0, no amountToken):
+     *    Bins below active bin, filled with SOL. Most common use case.
+     *
+     * 2. One-sided token (amountToken > 0, no amountSol):
+     *    Bins above active bin, filled with the non-SOL token.
+     *    Useful for DCA-out strategies.
+     *
+     * 3. Balanced (both amountSol and amountToken > 0):
+     *    Bins centered around active bin with both tokens.
+     *
+     * @returns TxResult with positionAddress for the created position.
+     */
+    async addLiquidity(params) {
+        const { poolAddress, opts } = params;
+        const strategy = params.strategy ?? "spot";
+        const numBins = Math.min(Math.max(params.bins ?? DEFAULT_NUM_BINS, 1), MAX_BINS);
+        // Resolve amounts: prefer new fields, fall back to legacy amountA/amountB
+        const amountSol = params.amountSol ?? params.amountA ?? 0;
+        const amountToken = params.amountToken ?? params.amountB ?? 0;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const activeBin = await dlmmPool.getActiveBin();
+        // Determine which token is SOL
+        const tokenXMint = dlmmPool.tokenX.publicKey;
+        const tokenYMint = dlmmPool.tokenY.publicKey;
+        const tokenXDecimals = Number(dlmmPool.tokenX.mint.decimals);
+        const tokenYDecimals = Number(dlmmPool.tokenY.mint.decimals);
+        const xIsSOL = tokenXMint.equals(WSOL_PK);
+        const yIsSOL = tokenYMint.equals(WSOL_PK);
+        // Calculate amounts in native units
+        // SOL goes into whichever side is WSOL; token goes into the other
+        let totalXAmount;
+        let totalYAmount;
+        if (xIsSOL) {
+            totalXAmount = new bn_js_1.default(Math.floor(amountSol * 10 ** tokenXDecimals));
+            totalYAmount = new bn_js_1.default(Math.floor(amountToken * 10 ** tokenYDecimals));
+        }
+        else if (yIsSOL) {
+            totalXAmount = new bn_js_1.default(Math.floor(amountToken * 10 ** tokenXDecimals));
+            totalYAmount = new bn_js_1.default(Math.floor(amountSol * 10 ** tokenYDecimals));
+        }
+        else {
+            // Neither side is SOL — unusual, but handle gracefully
+            totalXAmount = new bn_js_1.default(Math.floor(amountSol * 10 ** tokenXDecimals));
+            totalYAmount = new bn_js_1.default(Math.floor(amountToken * 10 ** tokenYDecimals));
+        }
+        const isOneSidedSol = amountSol > 0 && amountToken === 0;
+        const isOneSidedToken = amountToken > 0 && amountSol === 0;
+        let minBinId;
+        let maxBinId;
+        let strategyType;
+        if (isOneSidedSol) {
+            // SOL-only: bins below active bin
+            minBinId = activeBin.binId - numBins;
+            maxBinId = activeBin.binId;
+            strategyType = toSdkStrategy(strategy);
+        }
+        else if (isOneSidedToken) {
+            // Token-only: bins above active bin
+            minBinId = activeBin.binId;
+            maxBinId = activeBin.binId + numBins;
+            strategyType = toSdkStrategy(strategy);
+        }
+        else {
+            // Balanced: center around active bin
+            const halfBins = Math.floor(numBins / 2);
+            minBinId = activeBin.binId - halfBins;
+            maxBinId = activeBin.binId + halfBins;
+            strategyType = toSdkStrategy(strategy);
+        }
+        const newPosition = new web3_js_1.Keypair();
+        // Create position and add liquidity in one call
+        const createPositionTx = await dlmmPool.initializePositionAndAddLiquidityByStrategy({
+            positionPubKey: newPosition.publicKey,
+            user: wallet.publicKey,
+            totalXAmount,
+            totalYAmount,
+            strategy: {
+                maxBinId,
+                minBinId,
+                strategyType,
+            },
+        });
+        // Send the SDK's legacy Transaction directly with a fresh blockhash.
+        // The SDK call above can take 10-30s, so we must NOT use a stale blockhash.
+        try {
+            const result = await (0, send_rpc_1.sendAndConfirmLegacyTx)(connection, createPositionTx, wallet, {
+                extraSigners: [newPosition],
+            });
+            return {
+                txSignature: result.txSignature,
+                confirmed: result.confirmed,
+                error: result.error,
+                positionAddress: newPosition.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        catch (error) {
+            return {
+                txSignature: "",
+                confirmed: false,
+                error: error instanceof Error ? error.message : String(error),
+                positionAddress: newPosition.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+    }
+    // ----- removeLiquidity -----
+    /**
+     * Remove liquidity from a Meteora DLMM pool position.
+     *
+     * If positionAddress is provided, removes from that specific position.
+     * Otherwise, removes from the first position found in the pool.
+     *
+     * If percentage is 100, also claims fees and closes the position.
+     */
+    async removeLiquidity(params) {
+        const { poolAddress, percentage, positionAddress } = params;
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        // Find user's position in this pool
+        const { userPositions } = await dlmmPool.getPositionsByUserAndLbPair(wallet.publicKey);
+        if (userPositions.length === 0) {
+            return {
+                txSignature: "",
+                confirmed: false,
+                error: `No positions found for user in pool ${poolAddress}`,
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        // Select position: by address if given, otherwise first found
+        let position;
+        if (positionAddress) {
+            const targetPk = new web3_js_1.PublicKey(positionAddress);
+            position = userPositions.find((p) => p.publicKey.equals(targetPk));
+            if (!position) {
+                return {
+                    txSignature: "",
+                    confirmed: false,
+                    error: `Position ${positionAddress} not found in pool ${poolAddress}`,
+                    poolAddress,
+                    dex: this.name,
+                };
+            }
+        }
+        else {
+            position = userPositions[0];
+        }
+        // Calculate BPS: 100% = 10000 bps
+        const bps = new bn_js_1.default(Math.floor((percentage / 100) * 10000));
+        const shouldClaimAndClose = percentage >= 100;
+        const removeTxs = await dlmmPool.removeLiquidity({
+            position: position.publicKey,
+            user: wallet.publicKey,
+            fromBinId: position.positionData.lowerBinId,
+            toBinId: position.positionData.upperBinId,
+            bps,
+            shouldClaimAndClose,
+        });
+        // removeLiquidity returns Transaction | Transaction[], normalize to array
+        const txArray = Array.isArray(removeTxs) ? removeTxs : [removeTxs];
+        let lastSignature = "";
+        try {
+            for (const removeTx of txArray) {
+                const result = await (0, send_rpc_1.sendAndConfirmLegacyTx)(connection, removeTx, wallet);
+                lastSignature = result.txSignature;
+                if (!result.confirmed) {
+                    return {
+                        txSignature: lastSignature,
+                        confirmed: false,
+                        error: result.error,
+                        positionAddress: position.publicKey.toBase58(),
+                        poolAddress,
+                        dex: this.name,
+                    };
+                }
+            }
+            return {
+                txSignature: lastSignature,
+                confirmed: true,
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        catch (error) {
+            return {
+                txSignature: lastSignature,
+                confirmed: false,
+                error: error instanceof Error ? error.message : String(error),
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+    }
+    // ----- claimFees -----
+    /**
+     * Claim accumulated swap fees from a DLMM LP position.
+     *
+     * If positionAddress is provided, claims from that specific position.
+     * Otherwise, claims from the first position found in the pool.
+     */
+    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 dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const { userPositions } = await dlmmPool.getPositionsByUserAndLbPair(wallet.publicKey);
+        if (userPositions.length === 0) {
+            return {
+                txSignature: "",
+                confirmed: false,
+                error: `No positions found for user in pool ${poolAddress}`,
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        // Select position
+        let position;
+        if (positionAddress) {
+            const targetPk = new web3_js_1.PublicKey(positionAddress);
+            position = userPositions.find((p) => p.publicKey.equals(targetPk));
+            if (!position) {
+                return {
+                    txSignature: "",
+                    confirmed: false,
+                    error: `Position ${positionAddress} not found in pool ${poolAddress}`,
+                    poolAddress,
+                    dex: this.name,
+                };
+            }
+        }
+        else {
+            position = userPositions[0];
+        }
+        // claimSwapFee may return null or throw "No fee to claim"
+        let claimFeeTx;
+        try {
+            claimFeeTx = await dlmmPool.claimSwapFee({
+                owner: wallet.publicKey,
+                position,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // "No fee to claim" is expected for fresh positions — not a real error
+            return {
+                txSignature: "",
+                confirmed: true,
+                error: msg,
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        if (!claimFeeTx) {
+            return {
+                txSignature: "",
+                confirmed: true,
+                error: "No fees to claim",
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        try {
+            const result = await (0, send_rpc_1.sendAndConfirmLegacyTx)(connection, claimFeeTx, wallet);
+            return {
+                txSignature: result.txSignature,
+                confirmed: result.confirmed,
+                error: result.error,
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+        catch (error) {
+            return {
+                txSignature: "",
+                confirmed: false,
+                error: error instanceof Error ? error.message : String(error),
+                positionAddress: position.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+            };
+        }
+    }
+    // ----- listPositions -----
+    /**
+     * List user's LP positions in a DLMM pool.
+     *
+     * Returns position details including bin range, token amounts,
+     * unclaimed fees, and whether the position is in range.
+     */
+    async listPositions(poolAddress) {
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const poolPk = new web3_js_1.PublicKey(poolAddress);
+        const dlmmPool = await dlmm_1.default.create(connection, poolPk);
+        const activeBin = await dlmmPool.getActiveBin();
+        const tokenXMint = dlmmPool.tokenX.publicKey;
+        const tokenYMint = dlmmPool.tokenY.publicKey;
+        const tokenXDecimals = Number(dlmmPool.tokenX.mint.decimals);
+        const tokenYDecimals = Number(dlmmPool.tokenY.mint.decimals);
+        const { userPositions } = await dlmmPool.getPositionsByUserAndLbPair(wallet.publicKey);
+        return userPositions.map((pos) => {
+            const binData = pos.positionData.positionBinData;
+            // Sum amounts and fees across all bins
+            let totalX = 0;
+            let totalY = 0;
+            let feeX = 0;
+            let feeY = 0;
+            for (const bin of binData) {
+                totalX += Number(bin.positionXAmount);
+                totalY += Number(bin.positionYAmount);
+                feeX += Number(bin.positionFeeXAmount);
+                feeY += Number(bin.positionFeeYAmount);
+            }
+            const lowerBinId = pos.positionData.lowerBinId;
+            const upperBinId = pos.positionData.upperBinId;
+            const inRange = activeBin.binId >= lowerBinId && activeBin.binId <= upperBinId;
+            return {
+                positionAddress: pos.publicKey.toBase58(),
+                poolAddress,
+                dex: this.name,
+                lowerBinId,
+                upperBinId,
+                amountX: totalX / 10 ** tokenXDecimals,
+                amountY: totalY / 10 ** tokenYDecimals,
+                tokenXMint: tokenXMint.toBase58(),
+                tokenYMint: tokenYMint.toBase58(),
+                feeX: feeX / 10 ** tokenXDecimals,
+                feeY: feeY / 10 ** tokenYDecimals,
+                inRange,
+            };
+        });
+    }
+    // ----- 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.MeteoraDlmmAdapter = MeteoraDlmmAdapter;
+// ---------------------------------------------------------------------------
+// Auto-register
+// ---------------------------------------------------------------------------
+(0, index_1.registerAdapter)(new MeteoraDlmmAdapter());
+//# sourceMappingURL=meteora-dlmm.js.map