Flash Borrow Reserve Liquidity : Math operation overflow

[starkit7k]

I'm using surfpool(which provide mainnet like environment),version(satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ solana --version
solana-cli 2.3.8 (src:473089c1; feat:2255652435, client:Agave)
satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ rustc --version
rustc 1.89.0 (29483883e 2025-08-04)
satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ cargo --version
cargo 1.89.0 (c24e10642 2025-06-23)
satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ avm --version
avm 0.31.1
satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ anchor --version
anchor-cli 0.31.1)

[starkit7k]

code : import { Connection, Keypair, Transaction, PublicKey, SystemProgram } from '@solana/web3.js';
import {
getOrCreateAssociatedTokenAccount,
createApproveInstruction,
createSyncNativeInstruction,
TOKEN_PROGRAM_ID
} from '@solana/spl-token';
import {
flashBorrowReserveLiquidityInstruction,
flashRepayReserveLiquidityInstruction
} from '@solendprotocol/solend-sdk';
import * as fs from 'fs';
import BN from 'bn.js';

// Connect to your local Surf pool
const connection = new Connection('http://localhost:8899', 'confirmed');

// Load your wallet
const wallet = Keypair.fromSecretKey(
Uint8Array.from(JSON.parse(fs.readFileSync("wallet-keypair.json", "utf-8")))
);
console.log("✅ Wallet loaded:", wallet.publicKey.toString());

// Solend mainnet program ID
const SOLEND_MAINNET_PROGRAM_ID = new PublicKey('So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo');

// Mainnet market address for SOL
const SOLEND_MAINNET_MARKET = new PublicKey('7dA8PMT6bhopvRkDmJAeQT74NyDkGvi4isYoiYd8pES');

// Reserve address for SOL
const SOL_RESERVE = new PublicKey('FNDYHVzPrB9B4FNqe5swcDPgKqoVif3ohPnmAUkJ5K5t');

// Liquidity address for SOL reserve
const SOL_LIQUIDITY_ADDRESS = new PublicKey('FcUyGMNs43mHDKW7juU8hT4UvUh5dcKYixSA881dS6Uj');

// Liquidity fee receiver for SOL reserve
const SOL_LIQUIDITY_FEE_RECEIVER = new PublicKey('5wo1tFpi4HaVKnemqaXeQnBEpezrJXcXvuztYaPhvgC7');

// SOL mint
const SOL_MINT = new PublicKey('So11111111111111111111111111111111111111112');

// Amount to borrow (0.001 SOL) - Use BN for all arithmetic
const BORROW_AMOUNT = new BN(1000000);
const FLASH_LOAN_FEE_BPS = 30; // 0.3% (30 basis points)
// Calculate fees using BN to avoid overflow
const FEE_AMOUNT = BORROW_AMOUNT.muln(FLASH_LOAN_FEE_BPS).divn(10000);
const TOTAL_REPAY_AMOUNT = BORROW_AMOUNT.add(FEE_AMOUNT);
const BUFFER_AMOUNT = new BN(10000); // Extra 0.00001 SOL for safety

// Helper to format lamports to SOL
function formatSol(lamports: BN): string {
return (lamports.toNumber() / 1e9).toFixed(6) + " SOL";
}

async function getTokenBalance(account: PublicKey): Promise {
try {
const balance = await connection.getTokenAccountBalance(account);
return new BN(balance.value.amount);
} catch {
return new BN(0);
}
}

async function ensureMinimumBalance(tokenAccount: PublicKey, minBalance: BN) {
const currentBalance = await getTokenBalance(tokenAccount);

if (currentBalance.gte(minBalance)) {
    console.log(`   Current balance sufficient: ${formatSol(currentBalance)}`);
    return;
}

const neededAmount = minBalance.sub(currentBalance);
console.log(`   Need to wrap ${formatSol(neededAmount)} to cover fees`);

// Create wrap transaction
const wrapTx = new Transaction();
wrapTx.add(
    SystemProgram.transfer({
        fromPubkey: wallet.publicKey,
        toPubkey: tokenAccount,
        lamports: neededAmount.toNumber()
    }),
    createSyncNativeInstruction(tokenAccount)
);

console.log("   Wrapping additional SOL...");
const wrapSig = await connection.sendTransaction(wrapTx, [wallet]);
await connection.confirmTransaction(wrapSig, 'confirmed');
console.log(`   Wrap successful: ${wrapSig}`);

}

async function runFlashLoan() {
try {
console.log("\n🚀 Starting Flash Loan Process");
console.log("----------------------------------");

    // Create or get WSOL token account
    console.log("🔍 Setting up WSOL token account...");
    const tokenAccount = await getOrCreateAssociatedTokenAccount(
        connection,
        wallet,
        SOL_MINT,
        wallet.publicKey
    );
    console.log(`   Using WSOL account: ${tokenAccount.address.toBase58()}`);
    
    // Ensure account has enough to cover fees + buffer
    await ensureMinimumBalance(
        tokenAccount.address, 
        TOTAL_REPAY_AMOUNT.add(BUFFER_AMOUNT)
    );

    const initialBalance = await getTokenBalance(tokenAccount.address);
    console.log(`   Initial WSOL Balance: ${formatSol(initialBalance)}`);

    // Create a delegate for approval
    console.log("\n👤 Creating delegate account for temporary approval...");
    const delegate = Keypair.generate();
    console.log(`   Delegate public key: ${delegate.publicKey.toBase58()}`);

    // Ensure delegate account is funded for rent
    console.log("\n💸 Funding delegate for rent exemption...");
    const rentExemptAmount = await connection.getMinimumBalanceForRentExemption(0);
    console.log(`   Rent exemption amount: ${rentExemptAmount} lamports`);
    
    const rentExemptIx = SystemProgram.transfer({
        fromPubkey: wallet.publicKey,
        toPubkey: delegate.publicKey,
        lamports: rentExemptAmount,
    });

    // Create approve instruction - Convert BN to number for spl-token instruction
    console.log("\n🔏 Creating approval instruction...");
    console.log(`   Borrow Amount: ${formatSol(BORROW_AMOUNT)}`);
    console.log(`   Flash Loan Fee (0.3%): ${formatSol(FEE_AMOUNT)}`);
    console.log(`   Total to Approve: ${formatSol(TOTAL_REPAY_AMOUNT)}`);
    
    const approveIx = createApproveInstruction(
        tokenAccount.address,
        delegate.publicKey,
        wallet.publicKey,
        TOTAL_REPAY_AMOUNT.toNumber()
    );

    // Create flash loan transaction
    const tx = new Transaction();
    
    // Add rent exemption for delegate
    tx.add(rentExemptIx);
    
    // Add approve instruction
    tx.add(approveIx);
    
    // Add flash borrow instruction - Pass BN directly
    console.log("\n⬇️ Creating flash borrow instruction...");
    console.log(`   Borrow Amount (BN): ${BORROW_AMOUNT.toString()}`);
    console.log(`   Source Liquidity: ${SOL_LIQUIDITY_ADDRESS.toBase58()}`);
    console.log(`   Destination Liquidity: ${tokenAccount.address.toBase58()}`);
    console.log(`   Reserve: ${SOL_RESERVE.toBase58()}`);
    console.log(`   Lending Market: ${SOLEND_MAINNET_MARKET.toBase58()}`);
    console.log(`   Program ID: ${SOLEND_MAINNET_PROGRAM_ID.toBase58()}`);
    
    const borrowIx = flashBorrowReserveLiquidityInstruction(
        BORROW_AMOUNT,
        SOL_LIQUIDITY_ADDRESS,
        tokenAccount.address,
        SOL_RESERVE,
        SOLEND_MAINNET_MARKET,
        SOLEND_MAINNET_PROGRAM_ID
    );
    
    console.log(`   Borrow Instruction Keys: ${borrowIx.keys.map(k => k.pubkey.toBase58()).join(', ')}`);
    tx.add(borrowIx);

    // Add flash repay instruction - Pass BN directly
    console.log("\n⬆️ Creating flash repay instruction...");
    console.log(`   Repay Amount (BN): ${BORROW_AMOUNT.toString()}`);
    console.log(`   Borrow Instruction Index: 2`);
    
    const repayIx = flashRepayReserveLiquidityInstruction(
        BORROW_AMOUNT,
        2, // Borrow instruction index (0: rent, 1: approve, 2: borrow)
        tokenAccount.address,
        SOL_LIQUIDITY_ADDRESS,
        SOL_LIQUIDITY_FEE_RECEIVER,
        tokenAccount.address,
        SOL_RESERVE,
        SOLEND_MAINNET_MARKET,
        delegate.publicKey,
        SOLEND_MAINNET_PROGRAM_ID
    );
    
    console.log(`   Repay Instruction Keys: ${repayIx.keys.map(k => k.pubkey.toBase58()).join(', ')}`);
    tx.add(repayIx);

    // First, simulate the transaction to see if it will work
    console.log("\n🔍 Simulating transaction...");
    const simulationResult = await connection.simulateTransaction(tx, [wallet, delegate]);
    
    if (simulationResult.value.err) {
        console.log("❌ Simulation failed:", simulationResult.value.err);
        console.log("📋 Simulation logs:", simulationResult.value.logs);
        
        return;
    }
    
    console.log("✅ Simulation successful!");

    // Sign and send transaction
    console.log("\n📤 Sending transaction...");
    const signature = await connection.sendTransaction(tx, [wallet, delegate]);
    console.log("   Transaction sent:", signature);

    // Confirm transaction
    console.log("\n⏳ Waiting for confirmation...");
    await connection.confirmTransaction(signature, 'confirmed');
    console.log("✅ Transaction confirmed");
    
    // Show results
    console.log("\n💎 Flash Loan Summary");
    console.log("----------------------------------");
    console.log(`   Borrowed: ${formatSol(BORROW_AMOUNT)}`);
    console.log(`   Fee Paid: ${formatSol(FEE_AMOUNT)}`);
    
    // Get final balances
    const finalBalance = await getTokenBalance(tokenAccount.address);
    console.log(`   Final WSOL Balance: ${formatSol(finalBalance)}`);
    
    const balanceChange = initialBalance.sub(finalBalance);
    console.log(`   Net Change: ${formatSol(balanceChange)}`);
    
    console.log("\n🎉 Flash Loan Completed Successfully!");

} catch (error) {
    console.error("\n🔥 Transaction failed:", error);
    
    // Try to get more details if it's a SendTransactionError
    if (error.logs) {
        console.error("📋 Transaction logs:", error.logs);
    }
    
    
}

}

runFlashLoan();

[starkit7k]

satish@DESKTOP-G9TN1HM:/mnt/e/arbitrage-bot-anchor$ npx ts-node backend/solend-flashloan.ts
bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)
✅ Wallet loaded: 8b26K87RjNek9YXUSRw34z6aoofowR2hH2d8uJMbm7R6

🚀 Starting Flash Loan Process

🔍 Setting up WSOL token account...
Using WSOL account: HuuC2KB4mNPA8uNvVoDoguP9GqEhyAkkywGDbrr2p41L
Current balance sufficient: 0.001013 SOL
Initial WSOL Balance: 0.001013 SOL

👤 Creating delegate account for temporary approval...
Delegate public key: 252gAStuvnUs5gRBUacwaw4wjR59wdz7cpFmbLkMVMwp

💸 Funding delegate for rent exemption...
Rent exemption amount: 890880 lamports

🔏 Creating approval instruction...
Borrow Amount: 0.001000 SOL
Flash Loan Fee (0.3%): 0.000003 SOL
Total to Approve: 0.001003 SOL

⬇️ Creating flash borrow instruction...
Borrow Amount (BN): 1000000
Source Liquidity: FcUyGMNs43mHDKW7juU8hT4UvUh5dcKYixSA881dS6Uj
Destination Liquidity: HuuC2KB4mNPA8uNvVoDoguP9GqEhyAkkywGDbrr2p41L
Reserve: FNDYHVzPrB9B4FNqe5swcDPgKqoVif3ohPnmAUkJ5K5t
Lending Market: 7dA8PMT6bhopvRkDmJAeQT74NyDkGvi4isYoiYd8pES
Program ID: So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo
Borrow Instruction Keys: FcUyGMNs43mHDKW7juU8hT4UvUh5dcKYixSA881dS6Uj, HuuC2KB4mNPA8uNvVoDoguP9GqEhyAkkywGDbrr2p41L, FNDYHVzPrB9B4FNqe5swcDPgKqoVif3ohPnmAUkJ5K5t, 7dA8PMT6bhopvRkDmJAeQT74NyDkGvi4isYoiYd8pES, Hv5Rvm2gfVWfpbxiBhE1ZiFg7LMVhCY7oheWdUpUsGBX, Sysvar1nstructions1111111111111111111111111, TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA

⬆️ Creating flash repay instruction...
Repay Amount (BN): 1000000
Borrow Instruction Index: 2
Repay Instruction Keys: HuuC2KB4mNPA8uNvVoDoguP9GqEhyAkkywGDbrr2p41L, FcUyGMNs43mHDKW7juU8hT4UvUh5dcKYixSA881dS6Uj, 5wo1tFpi4HaVKnemqaXeQnBEpezrJXcXvuztYaPhvgC7, HuuC2KB4mNPA8uNvVoDoguP9GqEhyAkkywGDbrr2p41L, FNDYHVzPrB9B4FNqe5swcDPgKqoVif3ohPnmAUkJ5K5t, 7dA8PMT6bhopvRkDmJAeQT74NyDkGvi4isYoiYd8pES, 252gAStuvnUs5gRBUacwaw4wjR59wdz7cpFmbLkMVMwp, Sysvar1nstructions1111111111111111111111111, TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA

🔍 Simulating transaction...
❌ Simulation failed: { InstructionError: [ 2, { Custom: 14 } ] }
📋 Simulation logs: [
'Program 11111111111111111111111111111111 invoke [1]',
'Program 11111111111111111111111111111111 success',
'Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [1]',
'Program log: Instruction: Approve',
'Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 2903 of 602850 compute units',
'Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success',
'Program So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo invoke [1]',
'Program log: Instruction: Flash Borrow Reserve Liquidity',
'Program log: Math operation overflow',
'Program So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo consumed 52404 of 599947 compute units',
'Program So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo failed: custom program error: 0xe'
]

[starkit7k]

someone provide me solution