clodds 1.1.0

package/dist/solana/raydium.js

@@ -0,0 +1,673 @@
+"use strict";
+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.executeRaydiumSwap = executeRaydiumSwap;
+exports.getRaydiumQuote = getRaydiumQuote;
+exports.listRaydiumPools = listRaydiumPools;
+exports.initRaydiumSdk = initRaydiumSdk;
+exports.getRaydiumPoolInfoSdk = getRaydiumPoolInfoSdk;
+exports.listRaydiumPoolsSdk = listRaydiumPoolsSdk;
+exports.executeRaydiumSwapSdk = executeRaydiumSwapSdk;
+exports.getClmmPositions = getClmmPositions;
+exports.createClmmPosition = createClmmPosition;
+exports.increaseClmmLiquidity = increaseClmmLiquidity;
+exports.decreaseClmmLiquidity = decreaseClmmLiquidity;
+exports.closeClmmPosition = closeClmmPosition;
+exports.harvestClmmRewards = harvestClmmRewards;
+exports.addAmmLiquidity = addAmmLiquidity;
+exports.removeAmmLiquidity = removeAmmLiquidity;
+exports.swapClmm = swapClmm;
+exports.createClmmPool = createClmmPool;
+exports.getClmmConfigs = getClmmConfigs;
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const wallet_1 = require("./wallet");
+// ===== LEGACY REST API FUNCTIONS (backward compatible) =====
+async function executeRaydiumSwap(connection, keypair, params) {
+    const baseUrl = process.env.RAYDIUM_SWAP_BASE_URL || 'https://transaction-v1.raydium.io';
+    const slippageBps = params.slippageBps ?? 50;
+    const swapMode = params.swapMode ?? 'BaseIn';
+    const txVersion = params.txVersion ?? 'V0';
+    const computeUrl = new URL(`${baseUrl}/compute/swap-base-${swapMode === 'BaseOut' ? 'out' : 'in'}`);
+    computeUrl.searchParams.set('inputMint', params.inputMint);
+    computeUrl.searchParams.set('outputMint', params.outputMint);
+    computeUrl.searchParams.set(swapMode === 'BaseOut' ? 'outputAmount' : 'inputAmount', params.amount);
+    computeUrl.searchParams.set('slippageBps', slippageBps.toString());
+    computeUrl.searchParams.set('txVersion', txVersion);
+    if (params.computeUnitPriceMicroLamports !== undefined) {
+        computeUrl.searchParams.set('computeUnitPriceMicroLamports', params.computeUnitPriceMicroLamports.toString());
+    }
+    const computeResponse = await fetch(computeUrl.toString());
+    if (!computeResponse.ok) {
+        throw new Error(`Raydium compute error: ${computeResponse.status}`);
+    }
+    const computeJson = await computeResponse.json();
+    const routeSummary = computeJson?.data;
+    if (!routeSummary) {
+        throw new Error('Raydium compute response missing data');
+    }
+    const txResponse = await fetch(`${baseUrl}/transaction/swap-base-${swapMode === 'BaseOut' ? 'out' : 'in'}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            wallet: keypair.publicKey.toBase58(),
+            computeUnitPriceMicroLamports: params.computeUnitPriceMicroLamports,
+            swapResponse: routeSummary,
+            txVersion,
+        }),
+    });
+    if (!txResponse.ok) {
+        throw new Error(`Raydium swap error: ${txResponse.status}`);
+    }
+    const txJson = await txResponse.json();
+    const txData = txJson?.data?.[0]?.transaction || txJson?.data?.transaction || txJson?.transaction;
+    if (!txData) {
+        throw new Error('Raydium swap response missing transaction');
+    }
+    const txBytes = Buffer.from(txData, 'base64');
+    const signature = await (0, wallet_1.signAndSendVersionedTransaction)(connection, keypair, new Uint8Array(txBytes));
+    return { signature, routeSummary };
+}
+async function getRaydiumQuote(params) {
+    const baseUrl = process.env.RAYDIUM_SWAP_BASE_URL || 'https://transaction-v1.raydium.io';
+    const slippageBps = params.slippageBps ?? 50;
+    const swapMode = params.swapMode ?? 'BaseIn';
+    const computeUrl = new URL(`${baseUrl}/compute/swap-base-${swapMode === 'BaseOut' ? 'out' : 'in'}`);
+    computeUrl.searchParams.set('inputMint', params.inputMint);
+    computeUrl.searchParams.set('outputMint', params.outputMint);
+    computeUrl.searchParams.set(swapMode === 'BaseOut' ? 'outputAmount' : 'inputAmount', params.amount);
+    computeUrl.searchParams.set('slippageBps', slippageBps.toString());
+    computeUrl.searchParams.set('txVersion', 'V0');
+    const response = await fetch(computeUrl.toString());
+    if (!response.ok) {
+        throw new Error(`Raydium compute error: ${response.status}`);
+    }
+    const data = await response.json();
+    const summary = data?.data ?? data;
+    return {
+        outAmount: summary?.outAmount?.toString?.() ?? summary?.outAmount,
+        minOutAmount: summary?.minOutAmount?.toString?.() ?? summary?.minOutAmount,
+        priceImpact: summary?.priceImpact ? Number(summary.priceImpact) : undefined,
+        raw: summary,
+    };
+}
+async function listRaydiumPools(filters) {
+    const baseUrl = process.env.RAYDIUM_POOL_LIST_URL || 'https://api.raydium.io/v2/sdk/liquidity/mainnet.json';
+    const response = await fetch(baseUrl);
+    if (!response.ok) {
+        throw new Error(`Raydium pool list error: ${response.status}`);
+    }
+    const data = await response.json();
+    const pools = [];
+    if (Array.isArray(data)) {
+        pools.push(...data);
+    }
+    else if (data?.official || data?.unOfficial) {
+        if (Array.isArray(data.official))
+            pools.push(...data.official);
+        if (Array.isArray(data.unOfficial))
+            pools.push(...data.unOfficial);
+    }
+    else if (data?.data?.pools) {
+        pools.push(...data.data.pools);
+    }
+    else if (data?.data?.poolList) {
+        pools.push(...data.data.poolList);
+    }
+    const tokenMints = (filters?.tokenMints || []).map((m) => m.toLowerCase());
+    const limit = filters?.limit && filters.limit > 0 ? filters.limit : 50;
+    const results = [];
+    for (const pool of pools) {
+        const baseMint = pool.baseMint || pool.baseMintAddress || pool.baseMintId || pool.baseMintMint || pool.mintA;
+        const quoteMint = pool.quoteMint || pool.quoteMintAddress || pool.quoteMintId || pool.mintB;
+        if (!baseMint || !quoteMint)
+            continue;
+        if (tokenMints.length > 0) {
+            const matches = tokenMints.every((mint) => [String(baseMint).toLowerCase(), String(quoteMint).toLowerCase()].includes(mint));
+            if (!matches)
+                continue;
+        }
+        results.push({
+            id: pool.id || pool.ammId || pool.poolId,
+            name: pool.name || pool.symbol,
+            baseMint: String(baseMint),
+            quoteMint: String(quoteMint),
+            lpMint: pool.lpMint || pool.lpMintAddress,
+            marketId: pool.marketId || pool.market,
+            type: pool.version ? `v${pool.version}` : pool.type,
+            liquidity: Number(pool.liquidity ?? pool.tvl ?? pool.reserve ?? 0) || undefined,
+            volume24h: Number(pool.volume24h ?? pool.volume ?? pool.day?.volume ?? 0) || undefined,
+        });
+        if (results.length >= limit)
+            break;
+    }
+    return results;
+}
+// ===== SDK-BASED FUNCTIONS (new implementation) =====
+async function loadSdk() {
+    const { Raydium } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    return Raydium;
+}
+async function initRaydiumSdk(connection, owner, cluster = 'mainnet') {
+    const Raydium = await loadSdk();
+    return Raydium.load({
+        connection,
+        owner: owner?.publicKey,
+        cluster,
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+}
+// ===== POOL QUERIES (SDK) =====
+async function getRaydiumPoolInfoSdk(connection, poolId) {
+    const raydium = await initRaydiumSdk(connection);
+    try {
+        const data = await raydium.api.fetchPoolById({ ids: poolId });
+        if (!data || data.length === 0)
+            return null;
+        const pool = data[0];
+        return {
+            id: pool.id,
+            type: pool.type === 'Concentrated' ? 'CLMM' : pool.type === 'Standard' ? 'AMM' : 'CPMM',
+            mintA: pool.mintA?.address || pool.baseMint,
+            mintB: pool.mintB?.address || pool.quoteMint,
+            symbolA: pool.mintA?.symbol,
+            symbolB: pool.mintB?.symbol,
+            price: pool.price,
+            tvl: pool.tvl,
+            volume24h: pool.day?.volume,
+            feeRate: pool.feeRate,
+            lpMint: pool.lpMint?.address,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function listRaydiumPoolsSdk(connection, filters) {
+    const raydium = await initRaydiumSdk(connection);
+    const poolType = filters?.type === 'CLMM' ? 'concentrated'
+        : filters?.type === 'AMM' ? 'standard'
+            : filters?.type === 'CPMM' ? 'cpmm'
+                : 'all';
+    const response = await raydium.api.getPoolList({
+        type: poolType,
+        sort: 'volume24h',
+        order: 'desc',
+        pageSize: filters?.limit || 50,
+    });
+    let pools = response?.data || [];
+    if (filters?.tokenMint) {
+        const mint = filters.tokenMint.toLowerCase();
+        pools = pools.filter((p) => p.mintA?.address?.toLowerCase() === mint ||
+            p.mintB?.address?.toLowerCase() === mint);
+    }
+    return pools.map((pool) => ({
+        id: pool.id,
+        type: pool.type === 'Concentrated' ? 'CLMM' : pool.type === 'Standard' ? 'AMM' : 'CPMM',
+        mintA: pool.mintA?.address,
+        mintB: pool.mintB?.address,
+        symbolA: pool.mintA?.symbol,
+        symbolB: pool.mintB?.symbol,
+        price: pool.price,
+        tvl: pool.tvl,
+        volume24h: pool.day?.volume,
+        feeRate: pool.feeRate,
+        lpMint: pool.lpMint?.address,
+    }));
+}
+// ===== SWAP OPERATIONS (SDK) =====
+async function executeRaydiumSwapSdk(connection, keypair, params) {
+    // For SDK-based swap, we use the REST API approach which is more reliable
+    // The SDK's tradeV2.swap has complex requirements (routeProgram, ownerInfo)
+    // that require additional setup. Use the REST API for simplicity.
+    return executeRaydiumSwap(connection, keypair, params);
+}
+// ===== CLMM OPERATIONS =====
+async function getClmmPositions(connection, keypair, poolId) {
+    const { Raydium, CLMM_PROGRAM_ID } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const positions = await raydium.clmm.getOwnerPositionInfo({ programId: CLMM_PROGRAM_ID });
+    let filtered = positions;
+    if (poolId) {
+        filtered = positions.filter((p) => p.poolId.toBase58() === poolId);
+    }
+    return filtered.map((p) => ({
+        nftMint: p.nftMint.toBase58(),
+        poolId: p.poolId.toBase58(),
+        tickLower: p.tickLower,
+        tickUpper: p.tickUpper,
+        liquidity: p.liquidity.toString(),
+        tokenA: p.tokenFeesOwedA?.toString() || '0',
+        tokenB: p.tokenFeesOwedB?.toString() || '0',
+        feeOwedA: p.feeGrowthInsideLastX64A?.toString(),
+        feeOwedB: p.feeGrowthInsideLastX64B?.toString(),
+    }));
+}
+async function createClmmPosition(connection, keypair, params) {
+    const { Raydium, TickUtils, PoolUtils, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const { tick: lowerTick } = TickUtils.getPriceAndTick({
+        poolInfo,
+        price: new decimal_js_1.default(params.priceLower),
+        baseIn: params.baseIn !== false,
+    });
+    const { tick: upperTick } = TickUtils.getPriceAndTick({
+        poolInfo,
+        price: new decimal_js_1.default(params.priceUpper),
+        baseIn: params.baseIn !== false,
+    });
+    const epochInfo = await raydium.fetchEpochInfo();
+    const baseAmount = new bn_js_1.default(params.baseAmount);
+    const res = await PoolUtils.getLiquidityAmountOutFromAmountIn({
+        poolInfo,
+        slippage: 0,
+        inputA: params.baseIn !== false,
+        tickUpper: Math.max(lowerTick, upperTick),
+        tickLower: Math.min(lowerTick, upperTick),
+        amount: baseAmount,
+        add: true,
+        amountHasFee: true,
+        epochInfo,
+    });
+    const slippage = params.slippage || 0.01;
+    const { execute, extInfo } = await raydium.clmm.openPositionFromBase({
+        poolInfo,
+        tickUpper: Math.max(lowerTick, upperTick),
+        tickLower: Math.min(lowerTick, upperTick),
+        base: params.baseIn !== false ? 'MintA' : 'MintB',
+        ownerInfo: {
+            useSOLBalance: true,
+        },
+        baseAmount,
+        otherAmountMax: new bn_js_1.default(new decimal_js_1.default(res.amountSlippageB.amount.toString()).mul(1 + slippage).toFixed(0)),
+        txVersion: TxVersion.V0,
+        computeBudgetConfig: {
+            units: 600000,
+            microLamports: 100000,
+        },
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return {
+        signature: txId,
+        nftMint: extInfo.nftMint.toBase58(),
+    };
+}
+async function increaseClmmLiquidity(connection, keypair, params) {
+    const { Raydium, PoolUtils, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const positions = await raydium.clmm.getOwnerPositionInfo({ programId: new web3_js_1.PublicKey(poolInfo.programId) });
+    const position = positions.find((p) => p.nftMint.toBase58() === params.positionNftMint);
+    if (!position)
+        throw new Error(`Position not found: ${params.positionNftMint}`);
+    const slippage = params.slippage || 0.05;
+    const inputAmount = params.amountA || params.amountB || '0';
+    const inputA = !!params.amountA;
+    const epochInfo = await raydium.fetchEpochInfo();
+    const res = await PoolUtils.getLiquidityAmountOutFromAmountIn({
+        poolInfo,
+        slippage: 0,
+        inputA,
+        tickUpper: Math.max(position.tickLower, position.tickUpper),
+        tickLower: Math.min(position.tickLower, position.tickUpper),
+        amount: new bn_js_1.default(inputAmount),
+        add: true,
+        amountHasFee: true,
+        epochInfo,
+    });
+    const { execute } = await raydium.clmm.increasePositionFromLiquidity({
+        poolInfo,
+        ownerPosition: position,
+        ownerInfo: {
+            useSOLBalance: true,
+        },
+        liquidity: new bn_js_1.default(new decimal_js_1.default(res.liquidity.toString()).mul(1 - slippage).toFixed(0)),
+        amountMaxA: new bn_js_1.default(new decimal_js_1.default(inputA ? inputAmount : res.amountSlippageA.amount.toString()).mul(1 + slippage).toFixed(0)),
+        amountMaxB: new bn_js_1.default(new decimal_js_1.default(!inputA ? inputAmount : res.amountSlippageB.amount.toString()).mul(1 + slippage).toFixed(0)),
+        checkCreateATAOwner: true,
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return { signature: txId };
+}
+async function decreaseClmmLiquidity(connection, keypair, params) {
+    const { Raydium, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const positions = await raydium.clmm.getOwnerPositionInfo({ programId: new web3_js_1.PublicKey(poolInfo.programId) });
+    const position = positions.find((p) => p.nftMint.toBase58() === params.positionNftMint);
+    if (!position)
+        throw new Error(`Position not found: ${params.positionNftMint}`);
+    let liquidityToRemove = position.liquidity;
+    if (params.liquidity) {
+        liquidityToRemove = new bn_js_1.default(params.liquidity);
+    }
+    else if (params.percentBps) {
+        liquidityToRemove = position.liquidity.muln(params.percentBps).divn(10000);
+    }
+    const closePosition = params.closePosition || liquidityToRemove.eq(position.liquidity);
+    const { execute } = await raydium.clmm.decreaseLiquidity({
+        poolInfo,
+        ownerPosition: position,
+        ownerInfo: {
+            useSOLBalance: true,
+            closePosition,
+        },
+        liquidity: liquidityToRemove,
+        amountMinA: new bn_js_1.default(0),
+        amountMinB: new bn_js_1.default(0),
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return {
+        signature: txId,
+        amountA: '0',
+        amountB: '0',
+    };
+}
+async function closeClmmPosition(connection, keypair, poolId, positionNftMint) {
+    const { Raydium, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: poolId });
+    const poolInfo = data[0];
+    const positions = await raydium.clmm.getOwnerPositionInfo({ programId: new web3_js_1.PublicKey(poolInfo.programId) });
+    const position = positions.find((p) => p.nftMint.toBase58() === positionNftMint);
+    if (!position)
+        throw new Error(`Position not found: ${positionNftMint}`);
+    const { execute } = await raydium.clmm.closePosition({
+        poolInfo,
+        ownerPosition: position,
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return { signature: txId };
+}
+async function harvestClmmRewards(connection, keypair, poolId) {
+    const { Raydium, CLMM_PROGRAM_ID, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const allPositions = await raydium.clmm.getOwnerPositionInfo({ programId: CLMM_PROGRAM_ID });
+    const nonZeroPositions = allPositions.filter((p) => !p.liquidity.isZero());
+    if (!nonZeroPositions.length) {
+        throw new Error('No positions with liquidity found');
+    }
+    let positionsToHarvest = nonZeroPositions;
+    if (poolId) {
+        positionsToHarvest = nonZeroPositions.filter((p) => p.poolId.toBase58() === poolId);
+    }
+    const poolIds = [...new Set(positionsToHarvest.map((p) => p.poolId.toBase58()))];
+    const poolInfoList = await raydium.api.fetchPoolById({ ids: poolIds.join(',') });
+    const allPositionsMap = positionsToHarvest.reduce((acc, cur) => ({
+        ...acc,
+        [cur.poolId.toBase58()]: acc[cur.poolId.toBase58()] ? acc[cur.poolId.toBase58()].concat(cur) : [cur],
+    }), {});
+    const { execute } = await raydium.clmm.harvestAllRewards({
+        allPoolInfo: poolInfoList.reduce((acc, cur) => ({
+            ...acc,
+            [cur.id]: cur,
+        }), {}),
+        allPositions: allPositionsMap,
+        ownerInfo: {
+            useSOLBalance: true,
+        },
+        programId: CLMM_PROGRAM_ID,
+        txVersion: TxVersion.V0,
+    });
+    const { txIds } = await execute({ sequentially: true });
+    return { signatures: txIds };
+}
+// ===== AMM OPERATIONS =====
+async function addAmmLiquidity(connection, keypair, params) {
+    const { Raydium, TokenAmount, toToken, Percent, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const inputAmount = params.amountA || params.amountB || '0';
+    const baseIn = !!params.amountA;
+    const slippage = params.slippage || 0.01;
+    const pairAmount = raydium.liquidity.computePairAmount({
+        poolInfo,
+        amount: new decimal_js_1.default(inputAmount).div(10 ** (baseIn ? poolInfo.mintA.decimals : poolInfo.mintB.decimals)).toString(),
+        baseIn,
+        slippage: new Percent(Math.floor(slippage * 100), 100),
+    });
+    const { execute } = await raydium.liquidity.addLiquidity({
+        poolInfo,
+        amountInA: new TokenAmount(toToken(poolInfo.mintA), baseIn ? inputAmount : new decimal_js_1.default(pairAmount.maxAnotherAmount.toExact()).mul(10 ** poolInfo.mintA.decimals).toFixed(0)),
+        amountInB: new TokenAmount(toToken(poolInfo.mintB), !baseIn ? inputAmount : new decimal_js_1.default(pairAmount.maxAnotherAmount.toExact()).mul(10 ** poolInfo.mintB.decimals).toFixed(0)),
+        otherAmountMin: pairAmount.minAnotherAmount,
+        fixedSide: params.fixedSide || (baseIn ? 'a' : 'b'),
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return {
+        signature: txId,
+        lpAmount: '0',
+    };
+}
+async function removeAmmLiquidity(connection, keypair, params) {
+    const { Raydium, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const lpAmount = new bn_js_1.default(params.lpAmount);
+    const slippage = params.slippage || 0.1;
+    const lpMintDecimals = poolInfo.lpMint?.decimals || 9;
+    const mintAmountA = poolInfo.mintAmountA || poolInfo.baseReserve || 0;
+    const mintAmountB = poolInfo.mintAmountB || poolInfo.quoteReserve || 0;
+    const lpTotalAmount = poolInfo.lpAmount || poolInfo.lpSupply || 1;
+    const [baseRatio, quoteRatio] = [
+        new decimal_js_1.default(mintAmountA).div(lpTotalAmount),
+        new decimal_js_1.default(mintAmountB).div(lpTotalAmount),
+    ];
+    const withdrawAmountDe = new decimal_js_1.default(lpAmount.toString()).div(10 ** lpMintDecimals);
+    const [withdrawAmountA, withdrawAmountB] = [
+        withdrawAmountDe.mul(baseRatio).mul(10 ** poolInfo.mintA.decimals),
+        withdrawAmountDe.mul(quoteRatio).mul(10 ** poolInfo.mintB.decimals),
+    ];
+    const { execute } = await raydium.liquidity.removeLiquidity({
+        poolInfo,
+        lpAmount,
+        baseAmountMin: new bn_js_1.default(withdrawAmountA.mul(1 - slippage).toFixed(0)),
+        quoteAmountMin: new bn_js_1.default(withdrawAmountB.mul(1 - slippage).toFixed(0)),
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return {
+        signature: txId,
+        amountA: withdrawAmountA.toFixed(0),
+        amountB: withdrawAmountB.toFixed(0),
+    };
+}
+// ===== CLMM SWAP (DIRECT) =====
+async function swapClmm(connection, keypair, params) {
+    const { Raydium, PoolUtils, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    const data = await raydium.api.fetchPoolById({ ids: params.poolId });
+    const poolInfo = data[0];
+    const clmmPoolInfo = await PoolUtils.fetchComputeClmmInfo({
+        connection,
+        poolInfo,
+    });
+    const tickCache = await PoolUtils.fetchMultiplePoolTickArrays({
+        connection,
+        poolKeys: [clmmPoolInfo],
+    });
+    const baseIn = params.inputMint === poolInfo.mintA.address;
+    const inputAmount = new bn_js_1.default(params.amountIn);
+    const slippage = params.slippage || 0.01;
+    const { minAmountOut, remainingAccounts } = await PoolUtils.computeAmountOutFormat({
+        poolInfo: clmmPoolInfo,
+        tickArrayCache: tickCache[params.poolId],
+        amountIn: inputAmount,
+        tokenOut: poolInfo[baseIn ? 'mintB' : 'mintA'],
+        slippage,
+        epochInfo: await raydium.fetchEpochInfo(),
+    });
+    const { execute } = await raydium.clmm.swap({
+        poolInfo,
+        inputMint: params.inputMint,
+        amountIn: inputAmount,
+        amountOutMin: minAmountOut.amount.raw,
+        observationId: clmmPoolInfo.observationId,
+        ownerInfo: {
+            useSOLBalance: true,
+        },
+        remainingAccounts,
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    return {
+        signature: txId,
+        txId,
+        inputAmount: params.amountIn,
+        outputAmount: minAmountOut.amount.raw.toString(),
+    };
+}
+// ===== CREATE CLMM POOL =====
+async function createClmmPool(connection, keypair, params) {
+    const { Raydium, CLMM_PROGRAM_ID, TxVersion } = await Promise.resolve().then(() => __importStar(require('@raydium-io/raydium-sdk-v2')));
+    const raydium = await Raydium.load({
+        connection,
+        owner: keypair,
+        cluster: 'mainnet',
+        disableFeatureCheck: true,
+        blockhashCommitment: 'finalized',
+    });
+    // Load token info
+    const mint1 = await raydium.token.getTokenInfo(params.mintA);
+    const mint2 = await raydium.token.getTokenInfo(params.mintB);
+    const clmmConfigs = await raydium.api.getClmmConfigs();
+    const configIndex = params.configIndex || 0;
+    const config = clmmConfigs[configIndex];
+    const { execute, extInfo } = await raydium.clmm.createPool({
+        programId: CLMM_PROGRAM_ID,
+        mint1,
+        mint2,
+        ammConfig: {
+            ...config,
+            id: new web3_js_1.PublicKey(config.id),
+            fundOwner: '',
+            description: '',
+        },
+        initialPrice: new decimal_js_1.default(params.initialPrice),
+        txVersion: TxVersion.V0,
+    });
+    const { txId } = await execute({ sendAndConfirm: true });
+    // extInfo.address is ClmmKeys object - try to get pool ID from it
+    let poolIdStr = '';
+    if (extInfo?.address) {
+        const addr = extInfo.address;
+        poolIdStr = addr.poolId?.toBase58?.() || addr.id?.toBase58?.() || '';
+    }
+    return {
+        signature: txId,
+        poolId: poolIdStr,
+    };
+}
+// ===== GET CLMM CONFIGS =====
+async function getClmmConfigs(connection) {
+    const raydium = await initRaydiumSdk(connection);
+    const configs = await raydium.api.getClmmConfigs();
+    return configs.map((c) => ({
+        id: c.id,
+        index: c.index,
+        tickSpacing: c.tickSpacing,
+        tradeFeeRate: c.tradeFeeRate,
+    }));
+}
+//# sourceMappingURL=raydium.js.map