@flipflop-sdk/node
Version:
FlipFlop Node.js SDK for programmatic token operations
145 lines • 6.01 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.burnLiquidity = void 0;
const web3_js_1 = require("@solana/web3.js");
const spl_token_1 = require("@solana/spl-token");
const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
const config_1 = require("../config");
const display_pool_1 = require("./display-pool");
const bn_js_1 = __importDefault(require("bn.js"));
const burnLiquidity = async (options) => {
// Validate required parameters
if (!options.rpc) {
return {
success: false,
message: "Missing rpc parameter",
};
}
if (!options.mint) {
return {
success: false,
message: "Missing mint parameter",
};
}
if (!options.lpTokenAmount || options.lpTokenAmount <= 0) {
return {
success: false,
message: "Invalid lpTokenAmount parameter",
};
}
if (!options.burner) {
return {
success: false,
message: "Missing burner parameter",
};
}
const connection = new web3_js_1.Connection(options.rpc, "confirmed");
const networkType = (0, config_1.getNetworkType)(options.rpc);
const config = config_1.CONFIGS[networkType];
try {
// Initialize Raydium SDK
const raydium = await raydium_sdk_v2_1.Raydium.load({
connection,
owner: options.burner,
cluster: networkType,
disableFeatureCheck: true,
disableLoadToken: true,
blockhashCommitment: "finalized",
});
// Get pool info using getPoolInfoByRpc function
const poolInfo = await (0, display_pool_1.getPoolInfoByRpc)(connection, raydium, options.mint, spl_token_1.NATIVE_MINT, options.rpc);
if (!poolInfo) {
return {
success: false,
message: `No CPMM pool found for token ${options.mint}`,
};
}
if (!poolInfo.success) {
return {
success: false,
message: poolInfo.message || "Unknown error",
};
}
const poolInfoData = poolInfo.data;
// Get LP mint from pool info
const lpMintPubkey = poolInfoData.lpMint;
// console.log(`Found LP mint: ${lpMintPubkey.toBase58()}`);
// Get the associated token account for LP tokens
const lpTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(lpMintPubkey, options.burner.publicKey);
// Check LP token account exists and get balance
let lpTokenAccountInfo;
try {
lpTokenAccountInfo = await (0, spl_token_1.getAccount)(connection, lpTokenAccount);
}
catch (error) {
if (error instanceof spl_token_1.TokenAccountNotFoundError) {
return {
success: false,
message: `No LP token account found for pool ${poolInfoData.poolAddress.toBase58()}. Please ensure you have LP tokens to burn.`,
};
}
return {
success: false,
message: `Error checking LP token account: ${error.message}`,
};
}
// Check LP token balance
const availableLpBalance = new bn_js_1.default(lpTokenAccountInfo.amount.toString())
.div(new bn_js_1.default(web3_js_1.LAMPORTS_PER_SOL))
.toNumber();
if (availableLpBalance < options.lpTokenAmount) {
return {
success: false,
message: `Insufficient LP token balance. Available: ${availableLpBalance}, Required: ${options.lpTokenAmount}`,
};
}
// console.log(
// `Burning ${options.lpTokenAmount} LP tokens from available ${availableLpBalance}`
// );
// Calculate burn amount with decimals
const burnAmount = new bn_js_1.default(options.lpTokenAmount).mul(new bn_js_1.default(web3_js_1.LAMPORTS_PER_SOL));
const instructions = [];
// Add compute budget instructions
instructions.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 200000 }), web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 50000 }));
// Create burn instruction
const burnInstruction = (0, spl_token_1.createBurnInstruction)(lpTokenAccount, lpMintPubkey, options.burner.publicKey, burnAmount.toNumber(), [], spl_token_1.TOKEN_PROGRAM_ID);
instructions.push(burnInstruction);
// Create and send transaction
const { blockhash } = await connection.getLatestBlockhash();
const message = new web3_js_1.TransactionMessage({
payerKey: options.burner.publicKey,
recentBlockhash: blockhash,
instructions,
}).compileToV0Message();
const tx = new web3_js_1.VersionedTransaction(message);
tx.sign([options.burner]);
const signature = await connection.sendTransaction(tx, {
skipPreflight: false,
preflightCommitment: "confirmed",
});
// Confirm transaction
await connection.confirmTransaction(signature, "confirmed");
return {
success: true,
message: "Liquidity tokens burned successfully",
data: {
signature,
mintAddress: options.mint,
burnedLpTokenAmount: options.lpTokenAmount,
lpMintAddress: lpMintPubkey,
poolAddress: poolInfoData.poolAddress,
},
};
}
catch (error) {
return {
success: false,
message: `Failed to burn liquidity tokens: ${error instanceof Error ? error.message : "Unknown error"}`,
};
}
};
exports.burnLiquidity = burnLiquidity;
//# sourceMappingURL=burn-liquidity.js.map