outsmart 2.0.0-alpha.0

package/dist/dex/raydium-clmm.js

@@ -0,0 +1,675 @@
+"use strict";
+/**
+ * Raydium CLMM (Concentrated Liquidity Market Maker) DEX Adapter
+ *
+ * Implements IDexAdapter for Raydium's CLMM program (CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK).
+ * Supports buy, sell, snipe, findPool, getPrice, and buildSwapIxs.
+ *
+ * Uses the native IX path (buy-v2.ts) for snipe and the SDK path for regular buy/sell.
+ *
+ * Ported from: 100x-algo-bots/trading-modules/raydium-clmm/
+ */
+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 });
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const types_1 = require("./types");
+const index_1 = require("./index");
+const config_1 = require("../helpers/config");
+const landing_1 = require("../transactions/landing");
+const send_rpc_1 = require("../transactions/send-rpc");
+// ---------------------------------------------------------------------------
+// Program constants
+// ---------------------------------------------------------------------------
+const RAYDIUM_CLMM_PROGRAM_ID = new web3_js_1.PublicKey("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK");
+const TOKEN_PROGRAM_ID_PK = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const MEMO_PROGRAM_ID = new web3_js_1.PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+const WSOL_MINT_PK = new web3_js_1.PublicKey(types_1.WSOL_MINT);
+const USDC_MINT_PK = new web3_js_1.PublicKey(types_1.USDC_MINT);
+const USDT_MINT_PK = new web3_js_1.PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB");
+const USD1_MINT_PK = new web3_js_1.PublicKey("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB");
+// Swap V2 discriminator
+const SWAP_V2_DISCRIMINATOR = Buffer.from([43, 4, 237, 11, 26, 201, 30, 98]);
+// Tick array constants
+const TICK_ARRAY_SIZE = 60;
+const MIN_SQRT_PRICE_X64 = new bn_js_1.default("4295048016");
+const MAX_SQRT_PRICE_X64 = new bn_js_1.default("79226673515401279992447579055");
+// PDA seeds
+const POOL_SEED = Buffer.from("pool", "utf8");
+const POOL_VAULT_SEED = Buffer.from("pool_vault", "utf8");
+const OBSERVATION_SEED = Buffer.from("observation", "utf8");
+const TICK_ARRAY_SEED = Buffer.from("tick_array", "utf8");
+const POOL_TICK_ARRAY_BITMAP_SEED = Buffer.from("pool_tick_array_bitmap_extension", "utf8");
+const AMM_CONFIG_SEED = Buffer.from("amm_config", "utf8");
+// ---------------------------------------------------------------------------
+// PDA helpers (ported from raydium-clmm/utils/pda-native.ts)
+// ---------------------------------------------------------------------------
+function i32ToBytes(value) {
+    const buf = Buffer.alloc(4);
+    buf.writeInt32BE(value, 0);
+    return buf;
+}
+function u16ToBytes(value) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16LE(value, 0);
+    return buf;
+}
+function derivePda(seeds) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync(seeds, RAYDIUM_CLMM_PROGRAM_ID);
+    return pda;
+}
+function derivePoolVault(poolId, vaultMint) {
+    return derivePda([POOL_VAULT_SEED, poolId.toBuffer(), vaultMint.toBuffer()]);
+}
+function deriveObservationState(poolId) {
+    return derivePda([OBSERVATION_SEED, poolId.toBuffer()]);
+}
+function deriveTickArray(poolId, startIndex) {
+    return derivePda([TICK_ARRAY_SEED, poolId.toBuffer(), i32ToBytes(startIndex)]);
+}
+function deriveTickArrayBitmapExtension(poolId) {
+    return derivePda([POOL_TICK_ARRAY_BITMAP_SEED, poolId.toBuffer()]);
+}
+function deriveAmmConfig(index) {
+    return derivePda([AMM_CONFIG_SEED, u16ToBytes(index)]);
+}
+function derivePoolId(ammConfig, mintA, mintB) {
+    return derivePda([POOL_SEED, ammConfig.toBuffer(), mintA.toBuffer(), mintB.toBuffer()]);
+}
+function decodeClmmPoolState(data) {
+    let offset = 8; // skip discriminator
+    const bump = data.readUInt8(offset);
+    offset += 1;
+    const ammConfig = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const owner = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const tokenMint0 = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const tokenMint1 = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const tokenVault0 = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const tokenVault1 = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const observationKey = new web3_js_1.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const mintDecimals0 = data.readUInt8(offset);
+    offset += 1;
+    const mintDecimals1 = data.readUInt8(offset);
+    offset += 1;
+    const tickSpacing = data.readUInt16LE(offset);
+    offset += 2;
+    const liquidity = new bn_js_1.default(data.slice(offset, offset + 16), "le");
+    offset += 16;
+    const sqrtPriceX64 = new bn_js_1.default(data.slice(offset, offset + 16), "le");
+    offset += 16;
+    const tickCurrent = data.readInt32LE(offset);
+    offset += 4;
+    // Skip padding3 (u16), padding4 (u16)
+    offset += 4;
+    // Skip fee_growth_global_0_x64 (u128), fee_growth_global_1_x64 (u128)
+    offset += 32;
+    // Skip protocol_fees_token_0 (u64), protocol_fees_token_1 (u64)
+    offset += 16;
+    // Skip swap_in_amount_token_0 (u128), swap_out_amount_token_1 (u128), swap_in_amount_token_1 (u128), swap_out_amount_token_0 (u128)
+    offset += 64;
+    const status = data.readUInt8(offset);
+    offset += 1;
+    // Skip padding (7 bytes)
+    offset += 7;
+    // Skip rewardInfos: 3 * 169 = 507 bytes
+    offset += 507;
+    // tickArrayBitmap: 16 u64 values
+    const tickArrayBitmap = [];
+    for (let i = 0; i < 16; i++) {
+        tickArrayBitmap.push(new bn_js_1.default(data.slice(offset, offset + 8), "le"));
+        offset += 8;
+    }
+    return {
+        bump, ammConfig, owner, tokenMint0, tokenMint1, tokenVault0, tokenVault1,
+        observationKey, mintDecimals0, mintDecimals1, tickSpacing, liquidity,
+        sqrtPriceX64, tickCurrent, status, tickArrayBitmap,
+    };
+}
+async function fetchClmmPoolState(connection, poolId) {
+    const accountInfo = await connection.getAccountInfo(poolId);
+    if (!accountInfo)
+        throw new Error(`Pool state account not found: ${poolId.toBase58()}`);
+    if (!accountInfo.owner.equals(RAYDIUM_CLMM_PROGRAM_ID)) {
+        throw new Error(`Invalid account owner for pool state: ${accountInfo.owner.toBase58()}`);
+    }
+    return decodeClmmPoolState(accountInfo.data);
+}
+// ---------------------------------------------------------------------------
+// Tick array helpers
+// ---------------------------------------------------------------------------
+function tickToStartIndex(tick, tickSpacing) {
+    const ticksInArray = tickSpacing * TICK_ARRAY_SIZE;
+    // For both positive and negative ticks, floor division gives the correct start index.
+    // Math.floor(-20456 / 600) = -35, so startIndex = -35 * 600 = -21000.
+    // The tick -20456 is in range [-21000, -20400), which is correct.
+    // No special negative handling needed — Math.floor already rounds toward -∞.
+    return Math.floor(tick / ticksInArray) * ticksInArray;
+}
+function getNextTickArrayStartIndex(currentStartIndex, tickSpacing, zeroForOne) {
+    const ticksInArray = tickSpacing * TICK_ARRAY_SIZE;
+    return zeroForOne ? currentStartIndex - ticksInArray : currentStartIndex + ticksInArray;
+}
+async function getTickArraysForSwap(connection, poolId, tickCurrent, tickSpacing, zeroForOne, maxArrays = 3) {
+    const startIndex = tickToStartIndex(tickCurrent, tickSpacing);
+    const tickArrays = [];
+    let currentStart = startIndex;
+    for (let i = 0; i < maxArrays; i++) {
+        const tickArrayAddress = deriveTickArray(poolId, currentStart);
+        try {
+            const info = await connection.getAccountInfo(tickArrayAddress);
+            if (info && info.owner.equals(RAYDIUM_CLMM_PROGRAM_ID)) {
+                tickArrays.push(tickArrayAddress);
+            }
+        }
+        catch {
+            // Skip
+        }
+        currentStart = getNextTickArrayStartIndex(currentStart, tickSpacing, zeroForOne);
+    }
+    // Must have at least one tick array
+    if (tickArrays.length === 0) {
+        // Use the start index tick array anyway (it may get created)
+        tickArrays.push(deriveTickArray(poolId, startIndex));
+    }
+    return tickArrays;
+}
+// ---------------------------------------------------------------------------
+// Token program detection
+// ---------------------------------------------------------------------------
+async function getTokenProgramForMint(connection, mint) {
+    const mintInfo = await connection.getAccountInfo(mint);
+    if (!mintInfo)
+        throw new Error(`Mint account not found: ${mint.toBase58()}`);
+    if (mintInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID))
+        return spl_token_1.TOKEN_2022_PROGRAM_ID;
+    return TOKEN_PROGRAM_ID_PK;
+}
+function isStablecoin(mint) {
+    return mint.equals(USDC_MINT_PK) || mint.equals(USDT_MINT_PK) || mint.equals(USD1_MINT_PK);
+}
+// ---------------------------------------------------------------------------
+// Price calculation
+// ---------------------------------------------------------------------------
+function sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
+    try {
+        const { MathUtil } = require("@raydium-io/raydium-sdk-v2");
+        const price = MathUtil.x64ToDecimal(sqrtPriceX64)
+            .pow(2)
+            .mul(new decimal_js_1.default(10).pow(decimalsA - decimalsB));
+        return Number(price.toString());
+    }
+    catch {
+        // Fallback manual calculation
+        const sqrtPrice = Number(sqrtPriceX64.toString()) / 2 ** 64;
+        const price = sqrtPrice * sqrtPrice;
+        const decimalAdj = 10 ** (decimalsA - decimalsB);
+        return price * decimalAdj;
+    }
+}
+function createClmmSwapV2Ix(poolParams, payer, inputTokenAccount, outputTokenAccount, amount, otherAmountThreshold, sqrtPriceLimitX64, isBaseInput, tickArrays, inputVaultMint, outputVaultMint, tickArrayBitmapExtension, zeroForOne) {
+    // Use zeroForOne for vault direction (falls back to isBaseInput for backward compat)
+    const directionZeroForOne = zeroForOne ?? isBaseInput;
+    const inputVault = directionZeroForOne ? poolParams.tokenVault0 : poolParams.tokenVault1;
+    const outputVault = directionZeroForOne ? poolParams.tokenVault1 : poolParams.tokenVault0;
+    const accounts = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: poolParams.ammConfig, isSigner: false, isWritable: false },
+        { pubkey: poolParams.poolId, isSigner: false, isWritable: true },
+        { pubkey: inputTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: outputTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: inputVault, isSigner: false, isWritable: true },
+        { pubkey: outputVault, isSigner: false, isWritable: true },
+        { pubkey: poolParams.observationState, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID_PK, isSigner: false, isWritable: false },
+        { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: MEMO_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: inputVaultMint, isSigner: false, isWritable: false },
+        { pubkey: outputVaultMint, isSigner: false, isWritable: false },
+        { pubkey: tickArrayBitmapExtension, isSigner: false, isWritable: true },
+        { pubkey: tickArrays[0], isSigner: false, isWritable: true },
+    ];
+    // Additional tick arrays as remaining accounts
+    const remainingAccounts = tickArrays.slice(1).map((ta) => ({
+        pubkey: ta,
+        isSigner: false,
+        isWritable: true,
+    }));
+    // Data: discriminator (8) + amount (8) + threshold (8) + sqrtPriceLimit (16) + isBaseInput (1) = 41 bytes
+    const data = Buffer.alloc(41);
+    let offset = 0;
+    SWAP_V2_DISCRIMINATOR.copy(data, offset);
+    offset += 8;
+    data.writeBigUInt64LE(amount, offset);
+    offset += 8;
+    data.writeBigUInt64LE(otherAmountThreshold, offset);
+    offset += 8;
+    const sqrtPriceBytes = sqrtPriceLimitX64.toArrayLike(Buffer, "le", 16);
+    sqrtPriceBytes.copy(data, offset);
+    offset += 16;
+    data.writeUInt8(isBaseInput ? 1 : 0, offset);
+    return new web3_js_1.TransactionInstruction({
+        keys: [...accounts, ...remainingAccounts],
+        programId: RAYDIUM_CLMM_PROGRAM_ID,
+        data,
+    });
+}
+// ---------------------------------------------------------------------------
+// Pool discovery
+// ---------------------------------------------------------------------------
+const COMMON_AMM_CONFIG = new web3_js_1.PublicKey("E64NGkDLLCdQ2yFNPcavaKptrEgmiQaNykUuLC1Qgwyp");
+async function discoverClmmPool(connection, baseMint, quoteMint) {
+    // Try the common AMM config with both mint orderings
+    const candidates = [
+        derivePoolId(COMMON_AMM_CONFIG, baseMint, quoteMint),
+        derivePoolId(COMMON_AMM_CONFIG, quoteMint, baseMint),
+    ];
+    for (const poolId of candidates) {
+        try {
+            const info = await connection.getAccountInfo(poolId);
+            if (info && info.owner.equals(RAYDIUM_CLMM_PROGRAM_ID)) {
+                return poolId;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    // Try via Raydium API as fallback
+    try {
+        const { Raydium } = await Promise.resolve().then(() => __importStar(require("@raydium-io/raydium-sdk-v2")));
+        const raydium = await Raydium.load({
+            connection,
+            disableLoadToken: true,
+        });
+        const pools = await raydium.api.fetchPoolByMints({
+            mint1: quoteMint.toBase58(),
+            mint2: baseMint.toBase58(),
+        });
+        for (const obj of pools) {
+            if (obj.type === "Concentrated") {
+                return new web3_js_1.PublicKey(obj.id);
+            }
+        }
+    }
+    catch {
+        // API unavailable
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Token balance helper
+// ---------------------------------------------------------------------------
+async function getTokenBalance(connection, mint, owner) {
+    const tokenProgram = await getTokenProgramForMint(connection, mint);
+    const ata = await (0, spl_token_1.getAssociatedTokenAddress)(mint, owner, tokenProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID), tokenProgram);
+    try {
+        const res = await connection.getTokenAccountBalance(ata);
+        return { amount: BigInt(res.value.amount), decimals: res.value.decimals };
+    }
+    catch {
+        return { amount: 0n, decimals: 0 };
+    }
+}
+// ---------------------------------------------------------------------------
+// Build swap instructions (shared between snipe and buildSwapIxs)
+// ---------------------------------------------------------------------------
+async function buildClmmSwapInstructions(connection, wallet, tokenMint, quoteMintPk, poolId, amountIn, minOut, priorityFee, includeComputeBudget) {
+    const poolState = await fetchClmmPoolState(connection, poolId);
+    // Detect base token program
+    const baseTokenProgram = await getTokenProgramForMint(connection, tokenMint);
+    // Determine swap direction
+    // We're buying tokenMint with quoteMint, so input is quoteMint
+    const isBaseInput = poolState.tokenMint0.equals(quoteMintPk);
+    const zeroForOne = isBaseInput;
+    // Calculate sqrt price limit
+    let sqrtPriceLimitX64;
+    if (isBaseInput) {
+        sqrtPriceLimitX64 = MIN_SQRT_PRICE_X64.add(new bn_js_1.default(1));
+    }
+    else {
+        sqrtPriceLimitX64 = MAX_SQRT_PRICE_X64.sub(new bn_js_1.default(1));
+    }
+    // Get tick arrays
+    const tickArrays = await getTickArraysForSwap(connection, poolId, poolState.tickCurrent, poolState.tickSpacing, zeroForOne);
+    // Build ATAs
+    const inputMintTokenProgram = await getTokenProgramForMint(connection, quoteMintPk);
+    const inputAta = await (0, spl_token_1.getAssociatedTokenAddress)(quoteMintPk, wallet.publicKey, inputMintTokenProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID), inputMintTokenProgram);
+    const outputAta = await (0, spl_token_1.getAssociatedTokenAddress)(tokenMint, wallet.publicKey, baseTokenProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID), baseTokenProgram);
+    const tickArrayBitmapExt = deriveTickArrayBitmapExtension(poolId);
+    // Determine input/output vault mints
+    const inputVaultMint = isBaseInput ? poolState.tokenMint0 : poolState.tokenMint1;
+    const outputVaultMint = isBaseInput ? poolState.tokenMint1 : poolState.tokenMint0;
+    const poolParams = {
+        poolId,
+        ammConfig: poolState.ammConfig,
+        observationState: poolState.observationKey,
+        tokenVault0: poolState.tokenVault0,
+        tokenVault1: poolState.tokenVault1,
+        tokenMint0: poolState.tokenMint0,
+        tokenMint1: poolState.tokenMint1,
+    };
+    const swapIx = createClmmSwapV2Ix(poolParams, wallet.publicKey, inputAta, outputAta, amountIn, minOut, sqrtPriceLimitX64, true, // isBaseInput — always exact input swap
+    tickArrays, inputVaultMint, outputVaultMint, tickArrayBitmapExt, zeroForOne);
+    // Build instruction list
+    const ixs = [];
+    if (includeComputeBudget) {
+        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
+    }
+    ixs.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(wallet.publicKey, inputAta, wallet.publicKey, quoteMintPk, inputMintTokenProgram), (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(wallet.publicKey, outputAta, wallet.publicKey, tokenMint, baseTokenProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID) ? spl_token_1.TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID_PK));
+    // WSOL wrapping
+    if (quoteMintPk.equals(WSOL_MINT_PK)) {
+        const lamports = Number(amountIn);
+        ixs.push(web3_js_1.SystemProgram.transfer({ fromPubkey: wallet.publicKey, toPubkey: inputAta, lamports }), (0, spl_token_1.createSyncNativeInstruction)(inputAta, TOKEN_PROGRAM_ID_PK));
+    }
+    ixs.push(swapIx);
+    // Close WSOL ATA
+    if (quoteMintPk.equals(WSOL_MINT_PK)) {
+        ixs.push((0, spl_token_1.createCloseAccountInstruction)(inputAta, wallet.publicKey, wallet.publicKey, [], TOKEN_PROGRAM_ID_PK));
+    }
+    return ixs;
+}
+// ---------------------------------------------------------------------------
+// Build sell instructions
+// ---------------------------------------------------------------------------
+async function buildClmmSellInstructions(connection, wallet, tokenMint, quoteMintPk, poolId, sellAmount, minOut, priorityFee, includeComputeBudget) {
+    const poolState = await fetchClmmPoolState(connection, poolId);
+    const baseTokenProgram = await getTokenProgramForMint(connection, tokenMint);
+    // For sell: input is tokenMint, output is quoteMint.
+    // zeroForOne = true if tokenMint is token0 (selling token0 for token1).
+    // isBaseInput is ALWAYS true — we specify exact input amount, not exact output.
+    const zeroForOne = poolState.tokenMint0.equals(tokenMint);
+    let sqrtPriceLimitX64;
+    if (zeroForOne) {
+        sqrtPriceLimitX64 = MIN_SQRT_PRICE_X64.add(new bn_js_1.default(1));
+    }
+    else {
+        sqrtPriceLimitX64 = MAX_SQRT_PRICE_X64.sub(new bn_js_1.default(1));
+    }
+    const tickArrays = await getTickArraysForSwap(connection, poolId, poolState.tickCurrent, poolState.tickSpacing, zeroForOne);
+    const inputAta = await (0, spl_token_1.getAssociatedTokenAddress)(tokenMint, wallet.publicKey, baseTokenProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID), baseTokenProgram);
+    const quoteMintTokenProgram = await getTokenProgramForMint(connection, quoteMintPk);
+    const outputAta = await (0, spl_token_1.getAssociatedTokenAddress)(quoteMintPk, wallet.publicKey);
+    const tickArrayBitmapExt = deriveTickArrayBitmapExtension(poolId);
+    const inputVaultMint = zeroForOne ? poolState.tokenMint0 : poolState.tokenMint1;
+    const outputVaultMint = zeroForOne ? poolState.tokenMint1 : poolState.tokenMint0;
+    const poolParams = {
+        poolId,
+        ammConfig: poolState.ammConfig,
+        observationState: poolState.observationKey,
+        tokenVault0: poolState.tokenVault0,
+        tokenVault1: poolState.tokenVault1,
+        tokenMint0: poolState.tokenMint0,
+        tokenMint1: poolState.tokenMint1,
+    };
+    // isBaseInput = true: we always specify exact input amount
+    // zeroForOne: direction flag for vault selection
+    const swapIx = createClmmSwapV2Ix(poolParams, wallet.publicKey, inputAta, outputAta, sellAmount, minOut, sqrtPriceLimitX64, true, // isBaseInput — exact input swap
+    tickArrays, inputVaultMint, outputVaultMint, tickArrayBitmapExt, zeroForOne);
+    const ixs = [];
+    if (includeComputeBudget) {
+        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
+    }
+    // Create output ATA (WSOL) and ensure input ATA exists
+    ixs.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(wallet.publicKey, outputAta, wallet.publicKey, quoteMintPk), swapIx);
+    // Close WSOL ATA to unwrap SOL proceeds
+    if (quoteMintPk.equals(WSOL_MINT_PK)) {
+        ixs.push((0, spl_token_1.createCloseAccountInstruction)(outputAta, wallet.publicKey, wallet.publicKey, [], TOKEN_PROGRAM_ID_PK));
+    }
+    return ixs;
+}
+// ---------------------------------------------------------------------------
+// Adapter class
+// ---------------------------------------------------------------------------
+class RaydiumClmmAdapter {
+    name = "raydium-clmm";
+    protocol = "clmm";
+    capabilities = (0, types_1.defaultCapabilities)({
+        canBuy: true,
+        canSell: true,
+        canSnipe: true,
+        canFindPool: true,
+        canGetPrice: true,
+    });
+    // ----- Core: buy -----
+    async buy(params) {
+        const tokenMint = (0, types_1.requireTokenMint)(params, this.name);
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const tokenMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = params.quoteMint ? new web3_js_1.PublicKey(params.quoteMint) : WSOL_MINT_PK;
+        const priorityFee = params.opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const computeUnits = params.opts?.computeUnitLimit ?? 300_000;
+        // Discover or use provided pool
+        let poolId;
+        if (params.poolAddress) {
+            poolId = new web3_js_1.PublicKey(params.poolAddress);
+        }
+        else {
+            const found = await discoverClmmPool(connection, tokenMintPk, quoteMintPk);
+            if (!found)
+                throw new types_1.PoolNotFoundError(this.name, tokenMint, params.quoteMint);
+            poolId = found;
+        }
+        // Calculate amounts
+        const quoteDecimals = quoteMintPk.equals(WSOL_MINT_PK) ? 9 : 6;
+        const amountIn = BigInt(Math.floor(params.amountSol * 10 ** quoteDecimals));
+        const ixs = await buildClmmSwapInstructions(connection, wallet, tokenMintPk, quoteMintPk, poolId, amountIn, 0n, priorityFee, true);
+        // Prepend compute unit limit
+        ixs.unshift(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits }));
+        // Submit via RPC send+confirm
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet);
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+            amountIn: params.amountSol,
+            amountInToken: quoteMintPk.equals(WSOL_MINT_PK) ? "SOL" : quoteMintPk.toBase58(),
+            dex: this.name,
+            poolAddress: poolId.toBase58(),
+        };
+    }
+    // ----- Core: sell -----
+    async sell(params) {
+        const tokenMint = (0, types_1.requireTokenMint)(params, this.name);
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const tokenMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = params.quoteMint ? new web3_js_1.PublicKey(params.quoteMint) : WSOL_MINT_PK;
+        const priorityFee = params.opts?.priorityFeeMicroLamports ?? types_1.DEFAULT_PRIORITY_FEE_MICRO_LAMPORTS;
+        const computeUnits = params.opts?.computeUnitLimit ?? 300_000;
+        // Discover pool
+        let poolId;
+        if (params.poolAddress) {
+            poolId = new web3_js_1.PublicKey(params.poolAddress);
+        }
+        else {
+            const found = await discoverClmmPool(connection, tokenMintPk, quoteMintPk);
+            if (!found)
+                throw new types_1.PoolNotFoundError(this.name, tokenMint, params.quoteMint);
+            poolId = found;
+        }
+        // Get token balance
+        const balance = await getTokenBalance(connection, tokenMintPk, wallet.publicKey);
+        const sellAmount = (balance.amount * BigInt(Math.floor(params.percentage))) / 100n;
+        if (sellAmount === 0n) {
+            return {
+                txSignature: "",
+                confirmed: false,
+                amountIn: 0,
+                amountInToken: tokenMint,
+                dex: this.name,
+                poolAddress: poolId.toBase58(),
+            };
+        }
+        const ixs = await buildClmmSellInstructions(connection, wallet, tokenMintPk, quoteMintPk, poolId, sellAmount, 0n, priorityFee, true);
+        ixs.unshift(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits }));
+        // Submit via RPC send+confirm
+        const result = await (0, send_rpc_1.sendAndConfirmVtx)(connection, ixs, wallet);
+        const humanSellAmount = Number(sellAmount) / 10 ** balance.decimals;
+        return {
+            txSignature: result.txSignature,
+            confirmed: result.confirmed,
+            amountIn: humanSellAmount,
+            amountInToken: tokenMint,
+            dex: this.name,
+            poolAddress: poolId.toBase58(),
+        };
+    }
+    // ----- Snipe (uses native IX path from buy-v2.ts) -----
+    async snipe(params) {
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const tokenMint = new web3_js_1.PublicKey(params.tokenMint);
+        const quoteMintPk = params.quoteMint ? new web3_js_1.PublicKey(params.quoteMint) : WSOL_MINT_PK;
+        const poolId = new web3_js_1.PublicKey(params.poolAddress);
+        const priorityFee = params.opts?.priorityFeeMicroLamports ?? 1_000_000;
+        const quoteDecimals = quoteMintPk.equals(WSOL_MINT_PK) ? 9 : 6;
+        const amountIn = BigInt(Math.floor(params.amountSol * 10 ** quoteDecimals));
+        const ixs = await buildClmmSwapInstructions(connection, wallet, tokenMint, quoteMintPk, poolId, amountIn, 0n, priorityFee, true);
+        const { blockhash } = await connection.getLatestBlockhash();
+        const results = await (0, landing_1.landTransaction)(ixs, wallet, blockhash, {
+            dex: this.name,
+            operation: "snipe",
+            tipSol: params.tipSol,
+        });
+        const firstAccepted = results.find((r) => r.accepted);
+        return {
+            txSignature: firstAccepted?.signature ?? "",
+            confirmed: !!firstAccepted?.accepted,
+            amountIn: params.amountSol,
+            amountInToken: quoteMintPk.equals(WSOL_MINT_PK) ? "SOL" : quoteMintPk.toBase58(),
+            dex: this.name,
+            poolAddress: poolId.toBase58(),
+        };
+    }
+    // ----- Build swap IXs -----
+    async buildSwapIxs(params) {
+        const tokenMint = (0, types_1.requireTokenMint)(params, this.name);
+        const connection = (0, config_1.getConnection)();
+        const wallet = (0, config_1.getWallet)();
+        const isBuy = "amountSol" in params;
+        const tokenMintPk = new web3_js_1.PublicKey(tokenMint);
+        const quoteMintPk = params.quoteMint ? new web3_js_1.PublicKey(params.quoteMint) : WSOL_MINT_PK;
+        let poolId;
+        if (params.poolAddress) {
+            poolId = new web3_js_1.PublicKey(params.poolAddress);
+        }
+        else {
+            const found = await discoverClmmPool(connection, tokenMintPk, quoteMintPk);
+            if (!found)
+                throw new types_1.PoolNotFoundError(this.name, tokenMint, params.quoteMint);
+            poolId = found;
+        }
+        let instructions;
+        if (isBuy) {
+            const buyParams = params;
+            const quoteDecimals = quoteMintPk.equals(WSOL_MINT_PK) ? 9 : 6;
+            const amountIn = BigInt(Math.floor(buyParams.amountSol * 10 ** quoteDecimals));
+            instructions = await buildClmmSwapInstructions(connection, wallet, tokenMintPk, quoteMintPk, poolId, amountIn, 0n, 0, false);
+        }
+        else {
+            const sellParams = params;
+            const balance = await getTokenBalance(connection, tokenMintPk, wallet.publicKey);
+            const sellAmount = (balance.amount * BigInt(Math.floor(sellParams.percentage))) / 100n;
+            instructions = await buildClmmSellInstructions(connection, wallet, tokenMintPk, quoteMintPk, poolId, sellAmount, 0n, 0, false);
+        }
+        return { instructions, signers: [] };
+    }
+    // ----- Pool discovery -----
+    async findPool(baseMint, quoteMint) {
+        const connection = (0, config_1.getConnection)();
+        const baseMintPk = new web3_js_1.PublicKey(baseMint);
+        const quoteMintPk = quoteMint ? new web3_js_1.PublicKey(quoteMint) : WSOL_MINT_PK;
+        const poolId = await discoverClmmPool(connection, baseMintPk, quoteMintPk);
+        if (!poolId)
+            return null;
+        try {
+            const poolState = await fetchClmmPoolState(connection, poolId);
+            const price = sqrtPriceX64ToPrice(poolState.sqrtPriceX64, poolState.mintDecimals0, poolState.mintDecimals1);
+            return {
+                address: poolId.toBase58(),
+                dex: this.name,
+                protocol: this.protocol,
+                baseMint: poolState.tokenMint0.toBase58(),
+                quoteMint: poolState.tokenMint1.toBase58(),
+                baseDecimals: poolState.mintDecimals0,
+                quoteDecimals: poolState.mintDecimals1,
+                price,
+            };
+        }
+        catch {
+            return {
+                address: poolId.toBase58(),
+                dex: this.name,
+                protocol: this.protocol,
+                baseMint,
+                quoteMint: quoteMintPk.toBase58(),
+                baseDecimals: 6,
+                quoteDecimals: quoteMintPk.equals(WSOL_MINT_PK) ? 9 : 6,
+            };
+        }
+    }
+    // ----- Price -----
+    async getPrice(poolAddress) {
+        const connection = (0, config_1.getConnection)();
+        const poolId = new web3_js_1.PublicKey(poolAddress);
+        const poolState = await fetchClmmPoolState(connection, poolId);
+        let price = sqrtPriceX64ToPrice(poolState.sqrtPriceX64, poolState.mintDecimals0, poolState.mintDecimals1);
+        return {
+            price,
+            baseMint: poolState.tokenMint0.toBase58(),
+            quoteMint: poolState.tokenMint1.toBase58(),
+            source: "on-chain",
+            poolAddress,
+            timestamp: Date.now(),
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Register adapter
+// ---------------------------------------------------------------------------
+(0, index_1.registerAdapter)(new RaydiumClmmAdapter());
+//# sourceMappingURL=raydium-clmm.js.map