uups-checker 1.0.0

package/check-ceek-lp.js

@@ -0,0 +1,73 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-dataseed.binance.org/';
+const provider = new ethers.providers.JsonRpcProvider(RPC);
+
+const LP_ADDRESS = '0x119D6Ebe840966c9Cf4fF6603E76208d30BA2179';
+const CEEK_ADDRESS = '0xe0f94ac5462997d2bc57287ac3a3ae4c31345d66';
+
+const LP_ABI = [
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function totalSupply() view returns (uint256)',
+    'function balanceOf(address) view returns (uint256)',
+    'function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external'
+];
+
+const TOKEN_ABI = [
+    'function symbol() view returns (string)',
+    'function decimals() view returns (uint8)',
+    'function balanceOf(address) view returns (uint256)'
+];
+
+async function main() {
+    const lp = new ethers.Contract(LP_ADDRESS, LP_ABI, provider);
+    
+    console.log('=== CEEK LP PAIR ANALYSIS ===');
+    console.log('LP Address:', LP_ADDRESS);
+    
+    const token0 = await lp.token0();
+    const token1 = await lp.token1();
+    
+    console.log('\nToken0:', token0);
+    console.log('Token1:', token1);
+    
+    const token0Contract = new ethers.Contract(token0, TOKEN_ABI, provider);
+    const token1Contract = new ethers.Contract(token1, TOKEN_ABI, provider);
+    
+    const symbol0 = await token0Contract.symbol();
+    const symbol1 = await token1Contract.symbol();
+    const decimals0 = await token0Contract.decimals();
+    const decimals1 = await token1Contract.decimals();
+    
+    console.log(`\n${symbol0} (${decimals0} decimals)`);
+    console.log(`${symbol1} (${decimals1} decimals)`);
+    
+    const reserves = await lp.getReserves();
+    console.log('\nReserves:');
+    console.log(`${symbol0}:`, ethers.utils.formatUnits(reserves.reserve0, decimals0));
+    console.log(`${symbol1}:`, ethers.utils.formatUnits(reserves.reserve1, decimals1));
+    
+    const totalSupply = await lp.totalSupply();
+    console.log('\nLP Total Supply:', ethers.utils.formatEther(totalSupply));
+    
+    // Check if CEEK is token0 or token1
+    if (token0.toLowerCase() === CEEK_ADDRESS.toLowerCase()) {
+        console.log('\nCEEK is token0');
+    } else if (token1.toLowerCase() === CEEK_ADDRESS.toLowerCase()) {
+        console.log('\nCEEK is token1');
+    } else {
+        console.log('\nWARNING: CEEK not found in this pair!');
+    }
+    
+    // Calculate price
+    const price0 = reserves.reserve1.mul(ethers.utils.parseUnits('1', decimals0)).div(reserves.reserve0);
+    const price1 = reserves.reserve0.mul(ethers.utils.parseUnits('1', decimals1)).div(reserves.reserve1);
+    
+    console.log('\nPrices:');
+    console.log(`1 ${symbol0} =`, ethers.utils.formatUnits(price0, decimals1), symbol1);
+    console.log(`1 ${symbol1} =`, ethers.utils.formatUnits(price1, decimals0), symbol0);
+}
+
+main().catch(console.error);

package/check-ceek.js

@@ -0,0 +1,47 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-dataseed.binance.org/';
+const provider = new ethers.providers.JsonRpcProvider(RPC);
+
+const CEEK_ADDRESS = '0xe0f94ac5462997d2bc57287ac3a3ae4c31345d66';
+
+const ABI = [
+    'function owner() view returns (address)',
+    'function gate() view returns (address)',
+    'function trustedForwarder() view returns (address)',
+    'function totalSupply() view returns (uint256)',
+    'function cap() view returns (uint256)',
+    'function decimals() view returns (uint8)',
+    'function balanceOf(address) view returns (uint256)'
+];
+
+async function main() {
+    const ceek = new ethers.Contract(CEEK_ADDRESS, ABI, provider);
+    
+    console.log('=== CEEK TOKEN ANALYSIS ===');
+    console.log('Address:', CEEK_ADDRESS);
+    
+    const owner = await ceek.owner();
+    console.log('\nOwner:', owner);
+    
+    const gate = await ceek.gate();
+    console.log('Gate (minter):', gate);
+    
+    const trustedForwarder = await ceek.trustedForwarder();
+    console.log('Trusted Forwarder:', trustedForwarder);
+    
+    const totalSupply = await ceek.totalSupply();
+    const cap = await ceek.cap();
+    const decimals = await ceek.decimals();
+    
+    console.log('\nTotal Supply:', ethers.utils.formatUnits(totalSupply, decimals), 'CEEK');
+    console.log('Cap:', ethers.utils.formatUnits(cap, decimals), 'CEEK');
+    console.log('Remaining mintable:', ethers.utils.formatUnits(cap.sub(totalSupply), decimals), 'CEEK');
+    
+    // Check if gate has any special permissions
+    if (gate !== ethers.constants.AddressZero) {
+        console.log('\n⚠️ Gate address can mint unlimited tokens up to cap!');
+    }
+}
+
+main().catch(console.error);

package/check-dxsale-address.js

@@ -0,0 +1,35 @@
+const { ethers } = require('ethers');
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
+    
+    // CatGirl token
+    const catgirl = '0x79ebc9a2ce02277a4b5b3a768b1c0a4ed75bd936';
+    
+    console.log('=== CHECKING FOR DXSALE LOCK CONTRACTS ===\n');
+    
+    // Common DXSale lock addresses on BSC:
+    const knownDXSaleLocks = [
+        '0xc765bddb93b0d1c1a88282ba0fa6b2d00e3e0c83', // DXSale Lock v1
+        '0x2d045410f002a95efcee67759a92518fa3fce677', // DXSale Lock v2  
+        '0x7ee058420e5937496f5a2096f04caa7721cf70cc', // DXSale Lock Forwarder
+    ];
+    
+    const tokenAbi = ['function balanceOf(address) view returns (uint256)'];
+    const token = new ethers.Contract(catgirl, tokenAbi, provider);
+    
+    for (const lockAddr of knownDXSaleLocks) {
+        console.log(`Checking: ${lockAddr}`);
+        const lockCode = await provider.getCode(lockAddr);
+        if (lockCode !== '0x') {
+            const balance = await token.balanceOf(lockAddr);
+            console.log('  ✓ Contract exists');
+            console.log('  CATGIRL balance:', ethers.utils.formatEther(balance));
+        } else {
+            console.log('  ✗ No contract');
+        }
+        console.log('');
+    }
+}
+
+main().catch(console.error);

package/check-fara-exploit-timing.js

@@ -0,0 +1,56 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-dataseed.binance.org';
+const provider = new ethers.providers.JsonRpcProvider(RPC);
+
+const STAKING_CONTRACT = '0x107E5696fAc55207DFC05C071404C31CEc57d47A';
+const REAL_USER = '0xc75124Cc9d40d7f53FB05B5f8CC13638EfD869fE';
+
+async function checkExploitTiming() {
+    console.log('=== CHECKING WHEN THE EXPLOIT HAPPENED ===\n');
+    
+    // Get the contract creation block
+    const currentBlock = await provider.getBlockNumber();
+    console.log('Current block:', currentBlock);
+    
+    // Check if there were any contract upgrades or changes
+    // by looking at the transaction history
+    
+    // The user showed transaction logs with these characteristics:
+    // 1. Normal transaction: periodId = 7,677,834,305,148,927,392
+    // 2. Exploit transaction: periodId = 2,348,722,764,634,508,715,752,853
+    
+    // The exploit periodId is 305,909x larger than normal
+    // This suggests a MASSIVE underflow in time calculation
+    
+    console.log('=== EXPLOIT CHARACTERISTICS ===');
+    console.log('Normal periodId: 7,677,834,305,148,927,392');
+    console.log('Exploit periodId: 2,348,722,764,634,508,715,752,853');
+    console.log('Multiplier: 305,909x');
+    
+    console.log('\n=== HYPOTHESIS ===');
+    console.log('The exploit likely occurred when:');
+    console.log('1. A fund had a future endTime (set incorrectly by owner)');
+    console.log('2. User staked in that fund');
+    console.log('3. Reward calculation: (currentTime - endTime) underflowed');
+    console.log('4. Result: Massive periodId -> Massive rewards');
+    
+    console.log('\n=== WHY IT DOESNT WORK NOW ===');
+    console.log('1. The vulnerable fund may have expired');
+    console.log('2. The contract may have been patched');
+    console.log('3. The owner may have fixed the fund parameters');
+    
+    console.log('\n=== CONCLUSION ===');
+    console.log('This was a TIME-SENSITIVE exploit that required:');
+    console.log('- A specific fund with misconfigured endTime');
+    console.log('- Staking during the vulnerable window');
+    console.log('- The exploit window has likely closed');
+    
+    console.log('\n=== POTENTIAL CURRENT EXPLOITS ===');
+    console.log('We should check if:');
+    console.log('1. Any OTHER funds have future endTimes');
+    console.log('2. The owner can still create vulnerable funds');
+    console.log('3. There are other underflow vectors in the contract');
+}
+
+checkExploitTiming().catch(console.error);

package/check-fara-real-exploit.js

@@ -0,0 +1,73 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-dataseed.binance.org';
+const provider = new ethers.providers.JsonRpcProvider(RPC);
+
+const STAKING_CONTRACT = '0x107E5696fAc55207DFC05C071404C31CEc57d47A';
+const FARA_TOKEN = '0xF4Ed363144981D3A65f42e7D0DC54FF9EEf559A1';
+const REAL_USER = '0xc75124Cc9d40d7f53FB05B5f8CC13638EfD869fE';
+
+// Transaction hashes from the user's history
+const TX_WITH_568_FARA = '0x...'; // The one with 568 FARA reward
+const TX_WITH_2_FARA = '0x...'; // The one with 2.36 FARA reward
+
+async function analyzeRealExploit() {
+    console.log('=== ANALYZING REAL USER EXPLOIT ===\n');
+    
+    // Check current contract state
+    const faraToken = new ethers.Contract(FARA_TOKEN, [
+        'function balanceOf(address) view returns (uint256)',
+        'function decimals() view returns (uint8)'
+    ], provider);
+    
+    const contractBalance = await faraToken.balanceOf(STAKING_CONTRACT);
+    const decimals = await faraToken.decimals();
+    
+    console.log('Contract FARA balance:', ethers.utils.formatUnits(contractBalance, decimals));
+    console.log('Contract address:', STAKING_CONTRACT);
+    
+    // The key insight: User got 568 FARA but events show 0 rewards
+    // This means the Transfer event happened OUTSIDE the RewardClaimed event
+    
+    // Let's check if there's a separate reward pool contract
+    console.log('\n=== CHECKING FOR REWARD POOL ===');
+    console.log('Reward sender in 568 FARA tx: 0x0771CdEDC2aDA575c98b3cF5AC3b42f5A99b9c4b');
+    
+    const rewardPool = '0x0771CdEDC2aDA575c98b3cF5AC3b42f5A99b9c4b';
+    const rewardPoolBalance = await faraToken.balanceOf(rewardPool);
+    console.log('Reward pool FARA balance:', ethers.utils.formatUnits(rewardPoolBalance, decimals));
+    
+    // Check if reward pool has code
+    const code = await provider.getCode(rewardPool);
+    console.log('Reward pool has code:', code.length > 2);
+    console.log('Code length:', code.length);
+    
+    // The massive periodId suggests time-based calculation overflow
+    // periodId: 2,348,722,764,634,508,715,752,853
+    // This is approximately 2.35 * 10^24
+    
+    console.log('\n=== ANALYZING PERIOD ID ===');
+    const exploitPeriodId = BigInt('2348722764634508715752853');
+    const normalPeriodId = BigInt('7677834305148927392');
+    
+    console.log('Exploit periodId:', exploitPeriodId.toString());
+    console.log('Normal periodId:', normalPeriodId.toString());
+    console.log('Ratio:', Number(exploitPeriodId / normalPeriodId));
+    
+    // Check if this could be a timestamp overflow
+    const currentTime = Math.floor(Date.now() / 1000);
+    console.log('\nCurrent timestamp:', currentTime);
+    console.log('Exploit periodId as timestamp:', Number(exploitPeriodId));
+    
+    // If periodId is calculated as (endTime - startTime) * multiplier
+    // and startTime > endTime, it underflows
+    
+    console.log('\n=== HYPOTHESIS ===');
+    console.log('If the contract calculates:');
+    console.log('  periodId = (currentTime - lastUpdateTime) * SOME_MULTIPLIER');
+    console.log('And lastUpdateTime > currentTime (future timestamp)');
+    console.log('Then: periodId underflows to massive value');
+    console.log('Result: User gets MASSIVE rewards');
+}
+
+analyzeRealExploit().catch(console.error);

package/check-flashloan-limits.js

@@ -0,0 +1,129 @@
+// Check maximum flash loan amounts available
+const ethers = require('ethers');
+
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+
+// Flash loan providers
+const BALANCER_VAULT = '0xBA12222222228d8Ba445958a75a0704d566BF2C8';
+const AAVE_POOL = '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2'; // Aave V3
+const UNISWAP_V3_FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+
+const ERC20_ABI = [
+    'function balanceOf(address) view returns (uint256)',
+    'function decimals() view returns (uint8)',
+    'function symbol() view returns (string)'
+];
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(
+        'https://mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2'
+    );
+    
+    console.log('=== MAXIMUM FLASH LOAN AMOUNTS ===\n');
+    
+    // Check Balancer Vault (0% fee, best option)
+    console.log('1. BALANCER VAULT (0% fee)');
+    console.log('   Address:', BALANCER_VAULT);
+    
+    const weth = new ethers.Contract(WETH, ERC20_ABI, provider);
+    const usdc = new ethers.Contract(USDC, ERC20_ABI, provider);
+    const dai = new ethers.Contract(DAI, ERC20_ABI, provider);
+    
+    const balancerWETH = await weth.balanceOf(BALANCER_VAULT);
+    const balancerUSDC = await usdc.balanceOf(BALANCER_VAULT);
+    const balancerDAI = await dai.balanceOf(BALANCER_VAULT);
+    
+    console.log('   WETH:', ethers.utils.formatEther(balancerWETH), 'WETH');
+    console.log('   USDC:', ethers.utils.formatUnits(balancerUSDC, 6), 'USDC');
+    console.log('   DAI:', ethers.utils.formatEther(balancerDAI), 'DAI');
+    
+    // Check Aave V3 (0.05% fee)
+    console.log('\n2. AAVE V3 (0.05% fee)');
+    console.log('   Address:', AAVE_POOL);
+    
+    const aaveWETH = await weth.balanceOf(AAVE_POOL);
+    const aaveUSDC = await usdc.balanceOf(AAVE_POOL);
+    const aaveDAI = await dai.balanceOf(AAVE_POOL);
+    
+    console.log('   WETH:', ethers.utils.formatEther(aaveWETH), 'WETH');
+    console.log('   USDC:', ethers.utils.formatUnits(aaveUSDC, 6), 'USDC');
+    console.log('   DAI:', ethers.utils.formatEther(aaveDAI), 'DAI');
+    
+    // Check XFI liquidity on Uniswap V2
+    console.log('\n3. XFI LIQUIDITY');
+    const XFI = '0x5BEfBB272290dD5b8521D4a938f6c4757742c430';
+    const XFI_WETH_PAIR = '0xaF996125e98b5804c00FFDB4f7fF386307c99A00';
+    
+    const xfi = new ethers.Contract(XFI, ERC20_ABI, provider);
+    const pairWETH = await weth.balanceOf(XFI_WETH_PAIR);
+    const pairXFI = await xfi.balanceOf(XFI_WETH_PAIR);
+    
+    console.log('   Uniswap V2 XFI/WETH Pair:', XFI_WETH_PAIR);
+    console.log('   WETH in pair:', ethers.utils.formatEther(pairWETH), 'WETH');
+    console.log('   XFI in pair:', ethers.utils.formatEther(pairXFI), 'XFI');
+    
+    // Calculate max XFI we can buy
+    const maxWETH = balancerWETH; // Use Balancer's WETH
+    
+    // Uniswap V2 formula: amountOut = (amountIn * 997 * reserveOut) / (reserveIn * 1000 + amountIn * 997)
+    // But we can't buy ALL the XFI, max is ~99% of reserves
+    const maxXFI = pairXFI.mul(99).div(100);
+    
+    console.log('\n=== MAXIMUM EXPLOIT CAPACITY ===');
+    console.log('Max WETH flash loan (Balancer):', ethers.utils.formatEther(balancerWETH), 'WETH');
+    console.log('Max XFI we can buy (~99% of pool):', ethers.utils.formatEther(maxXFI), 'XFI');
+    
+    // Calculate how much WETH needed to buy that much XFI
+    // amountIn = (reserveIn * amountOut * 1000) / ((reserveOut - amountOut) * 997)
+    const amountOut = maxXFI;
+    const reserveIn = pairWETH;
+    const reserveOut = pairXFI;
+    
+    const numerator = reserveIn.mul(amountOut).mul(1000);
+    const denominator = reserveOut.sub(amountOut).mul(997);
+    const wethNeeded = numerator.div(denominator);
+    
+    console.log('WETH needed to buy that much XFI:', ethers.utils.formatEther(wethNeeded), 'WETH');
+    
+    if (wethNeeded.lt(balancerWETH)) {
+        console.log('\n✅ FEASIBLE! We can flash loan enough WETH from Balancer');
+        console.log('   Flash loan:', ethers.utils.formatEther(wethNeeded), 'WETH');
+        console.log('   Buy:', ethers.utils.formatEther(maxXFI), 'XFI');
+        console.log('   Fee: 0 WETH (Balancer has 0% fee)');
+    } else {
+        console.log('\n❌ NOT FEASIBLE - Need more WETH than available');
+        console.log('   Max we can buy with', ethers.utils.formatEther(balancerWETH), 'WETH:');
+        
+        // Calculate max XFI with available WETH
+        const amountIn = balancerWETH;
+        const amountInWithFee = amountIn.mul(997);
+        const numerator2 = amountInWithFee.mul(reserveOut);
+        const denominator2 = reserveIn.mul(1000).add(amountInWithFee);
+        const maxXFIWithAvailableWETH = numerator2.div(denominator2);
+        
+        console.log('   Max XFI:', ethers.utils.formatEther(maxXFIWithAvailableWETH), 'XFI');
+    }
+    
+    // Check current XFI staking pool
+    console.log('\n=== XFI STAKING POOL ===');
+    const STAKING = '0x5cD1C00a88822182733E3ac335863fcC9A1c0705';
+    const stakingXFI = await xfi.balanceOf(STAKING);
+    
+    const STAKING_ABI = [
+        'function totalStakes() view returns (uint256)',
+        'function totalDividends() view returns (uint256)'
+    ];
+    
+    const staking = new ethers.Contract(STAKING, STAKING_ABI, provider);
+    const totalStakes = await staking.totalStakes();
+    const totalDividends = await staking.totalDividends();
+    
+    console.log('XFI in staking contract:', ethers.utils.formatEther(stakingXFI), 'XFI');
+    console.log('Total staked:', ethers.utils.formatEther(totalStakes), 'XFI');
+    console.log('Total dividends:', totalDividends.toString());
+    console.log('Available to drain:', ethers.utils.formatEther(stakingXFI.sub(totalStakes)), 'XFI');
+}
+
+main().catch(console.error);

package/check-kel-cel-pool.js

@@ -0,0 +1,91 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2');
+
+const PAIR = '0x638BC0940C623DF5094C5C176a087ba250dF4756';
+const KEL = '0x8d99569ef5fEBb19989892eEE7f81f8f909D07F3';
+const CEL = '0xaaAEBE6Fe48E54f431b0C390CfaF0b017d09D42d';
+
+const pairAbi = [
+    'function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function token0() external view returns (address)',
+    'function token1() external view returns (address)',
+    'function price0CumulativeLast() external view returns (uint256)',
+    'function price1CumulativeLast() external view returns (uint256)',
+    'function kLast() external view returns (uint256)'
+];
+
+const erc20Abi = [
+    'function balanceOf(address) external view returns (uint256)',
+    'function decimals() external view returns (uint8)',
+    'function symbol() external view returns (string)',
+    'function totalSupply() external view returns (uint256)'
+];
+
+async function main() {
+    console.log('=== KEL-CEL POOL ANALYSIS ===\n');
+    
+    const pair = new ethers.Contract(PAIR, pairAbi, provider);
+    const kelToken = new ethers.Contract(KEL, erc20Abi, provider);
+    const celToken = new ethers.Contract(CEL, erc20Abi, provider);
+    
+    // Get token info
+    const kelDecimals = await kelToken.decimals();
+    const celDecimals = await celToken.decimals();
+    const kelSymbol = await kelToken.symbol();
+    const celSymbol = await celToken.symbol();
+    
+    console.log('Token Info:');
+    console.log(`${kelSymbol} (${KEL}): ${kelDecimals} decimals`);
+    console.log(`${celSymbol} (${CEL}): ${celDecimals} decimals\n`);
+    
+    // Get pair info
+    const token0 = await pair.token0();
+    const token1 = await pair.token1();
+    const reserves = await pair.getReserves();
+    
+    console.log('Pair Info:');
+    console.log(`Token0: ${token0} (${token0 === KEL ? 'KEL' : 'CEL'})`);
+    console.log(`Token1: ${token1} (${token1 === KEL ? 'KEL' : 'CEL'})\n`);
+    
+    // Get balances
+    const bal0 = await (token0 === KEL ? kelToken : celToken).balanceOf(PAIR);
+    const bal1 = await (token1 === KEL ? kelToken : celToken).balanceOf(PAIR);
+    
+    console.log('Reserves vs Balances:');
+    console.log(`Reserve0: ${reserves[0]} (${ethers.utils.formatUnits(reserves[0], token0 === KEL ? kelDecimals : celDecimals)})`);
+    console.log(`Balance0: ${bal0} (${ethers.utils.formatUnits(bal0, token0 === KEL ? kelDecimals : celDecimals)})`);
+    console.log(`Dust0: ${bal0 - reserves[0]}\n`);
+    
+    console.log(`Reserve1: ${reserves[1]} (${ethers.utils.formatUnits(reserves[1], token1 === KEL ? kelDecimals : celDecimals)})`);
+    console.log(`Balance1: ${bal1} (${ethers.utils.formatUnits(bal1, token1 === KEL ? kelDecimals : celDecimals)})`);
+    console.log(`Dust1: ${bal1 - reserves[1]}\n`);
+    
+    // Calculate K
+    const k = reserves[0] * reserves[1];
+    console.log(`K (constant product): ${k}`);
+    console.log(`sqrt(K): ${Math.sqrt(Number(k))}\n`);
+    
+    // Check price
+    const kelReserve = token0 === KEL ? reserves[0] : reserves[1];
+    const celReserve = token0 === CEL ? reserves[0] : reserves[1];
+    const price = Number(celReserve) / Number(kelReserve);
+    console.log(`Price: 1 KEL = ${price.toFixed(6)} CEL`);
+    console.log(`Price: 1 CEL = ${(1/price).toFixed(6)} KEL\n`);
+    
+    // Get total supplies
+    const kelSupply = await kelToken.totalSupply();
+    const celSupply = await celToken.totalSupply();
+    console.log('Total Supplies:');
+    console.log(`KEL: ${ethers.utils.formatUnits(kelSupply, kelDecimals)}`);
+    console.log(`CEL: ${ethers.utils.formatUnits(celSupply, celDecimals)}\n`);
+    
+    // Calculate pool percentage
+    const kelPoolPct = (Number(kelReserve) / Number(kelSupply) * 100).toFixed(2);
+    const celPoolPct = (Number(celReserve) / Number(celSupply) * 100).toFixed(2);
+    console.log('Pool Percentage of Supply:');
+    console.log(`KEL: ${kelPoolPct}%`);
+    console.log(`CEL: ${celPoolPct}%`);
+}
+
+main().catch(console.error);

package/check-lax-staking.js

@@ -0,0 +1,41 @@
+const { ethers } = require('ethers');
+
+const LAX_TOKEN = '0x7F9Bd73e51e66e0b2c7A87dB0ca530A11Eb7A7E9';
+const RPC = 'https://bsc-mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2';
+
+const LAX_ABI = [
+    'function STAKING() view returns (address)',
+    'function owner() view returns (address)',
+    'function recycle(uint256 amount) external'
+];
+
+async function checkLAXStaking() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC);
+    const lax = new ethers.Contract(LAX_TOKEN, LAX_ABI, provider);
+    
+    console.log('=== LAX TOKEN STAKING ADDRESS CHECK ===\n');
+    
+    try {
+        const stakingAddress = await lax.STAKING();
+        console.log('STAKING address:', stakingAddress);
+        
+        const owner = await lax.owner();
+        console.log('Owner address:', owner);
+        
+        console.log('\n=== EXPLOIT REQUIREMENTS ===');
+        console.log('To call recycle() and drain the pool, you need:');
+        console.log('1. Control of STAKING address:', stakingAddress);
+        console.log('2. STAKING is immutable (set in constructor, cannot change)');
+        console.log('3. Only STAKING can call recycle()');
+        
+        console.log('\n=== CONCLUSION ===');
+        console.log('❌ NOT USER-EXPLOITABLE');
+        console.log('✅ Requires privileged access (STAKING address control)');
+        console.log('⚠️  This is a CENTRALIZATION RISK, not a user exploit');
+        
+    } catch (error) {
+        console.error('Error:', error.message);
+    }
+}
+
+checkLAXStaking();