uups-checker 1.0.0

package/check-lendflare.js

@@ -0,0 +1,165 @@
+// Quick script to check LendFlare Token on-chain
+// Run with: node check-lendflare.js
+
+const ethers = require('ethers');
+
+// LendFlare Token address
+const LFT_ADDRESS = '0xB620Be8a1949AA9532e6a3510132864EF9Bc3F82';
+const UNISWAP_V2_PAIR = '0x9c84f58bb51fabd18698efe95f5bab4f33e96e8f';
+
+// Minimal ABI
+const LFT_ABI = [
+    'function owner() view returns (address)',
+    'function minter() view returns (address)',
+    'function liquidityTransformer() view returns (address)',
+    'function liquidity() view returns (bool)',
+    'function totalSupply() view returns (uint256)',
+    'function balanceOf(address) view returns (uint256)',
+];
+
+const PAIR_ABI = [
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+];
+
+async function main() {
+    // Connect to Ethereum mainnet (use your own RPC)
+    const provider = new ethers.providers.JsonRpcProvider(
+        process.env.ETH_RPC_URL || 'https://eth.llamarpc.com'
+    );
+    
+    const lft = new ethers.Contract(LFT_ADDRESS, LFT_ABI, provider);
+    const pair = new ethers.Contract(UNISWAP_V2_PAIR, PAIR_ABI, provider);
+    
+    console.log('=== LENDFLARE TOKEN ANALYSIS ===\n');
+    
+    // Check initialization
+    console.log('1. INITIALIZATION STATUS:');
+    const owner = await lft.owner();
+    const minter = await lft.minter();
+    const liquidityTransformer = await lft.liquidityTransformer();
+    const liquidity = await lft.liquidity();
+    
+    console.log('   Owner:', owner);
+    console.log('   Minter:', minter);
+    console.log('   LiquidityTransformer:', liquidityTransformer);
+    console.log('   Liquidity Active:', liquidity);
+    
+    if (owner === ethers.constants.AddressZero) {
+        console.log('   🔥 EXPLOIT POSSIBLE: Owner not set!');
+    } else {
+        console.log('   ✅ Owner is set (no exploit)');
+    }
+    
+    if (minter === ethers.constants.AddressZero) {
+        console.log('   🔥 EXPLOIT POSSIBLE: Minter not set!');
+    } else {
+        console.log('   ✅ Minter is set (no exploit)');
+    }
+    
+    // Check supply
+    console.log('\n2. SUPPLY INFO:');
+    const totalSupply = await lft.totalSupply();
+    console.log('   Total Supply:', ethers.utils.formatEther(totalSupply), 'LFT');
+    
+    // Check Uniswap pair
+    console.log('\n3. UNISWAP V2 PAIR INFO:');
+    try {
+        const reserves = await pair.getReserves();
+        const token0 = await pair.token0();
+        const token1 = await pair.token1();
+        
+        console.log('   Token0:', token0);
+        console.log('   Token1:', token1);
+        
+        if (token0.toLowerCase() === LFT_ADDRESS.toLowerCase()) {
+            console.log('   LFT Reserve:', ethers.utils.formatEther(reserves.reserve0), 'LFT');
+            console.log('   WETH Reserve:', ethers.utils.formatEther(reserves.reserve1), 'WETH');
+        } else {
+            console.log('   WETH Reserve:', ethers.utils.formatEther(reserves.reserve0), 'WETH');
+            console.log('   LFT Reserve:', ethers.utils.formatEther(reserves.reserve1), 'LFT');
+        }
+        
+        console.log('   🎣 Honeypot: Users can BUY but cannot SELL');
+    } catch (e) {
+        console.log('   ❌ Cannot read pair reserves');
+    }
+    
+    // Check if it's a proxy
+    console.log('\n4. PROXY CHECK:');
+    const code = await provider.getCode(LFT_ADDRESS);
+    const hasDelegate = code.includes('f4'); // delegatecall opcode
+    
+    if (hasDelegate) {
+        console.log('   🔥 POSSIBLE EXPLOIT: Contract might be a proxy!');
+        console.log('   Check if implementation is uninitialized');
+        
+        // Try to read EIP-1967 implementation slot
+        const implSlot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+        const implAddress = await provider.getStorageAt(LFT_ADDRESS, implSlot);
+        console.log('   Implementation:', implAddress);
+    } else {
+        console.log('   ✅ Not a proxy (or uses different pattern)');
+    }
+    
+    // Check other DEXs
+    console.log('\n5. OTHER DEX LIQUIDITY:');
+    console.log('   Checking Uniswap V3...');
+    
+    const V3_FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+    const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+    
+    const v3Factory = new ethers.Contract(
+        V3_FACTORY,
+        ['function getPool(address,address,uint24) view returns (address)'],
+        provider
+    );
+    
+    try {
+        const v3Pool3000 = await v3Factory.getPool(LFT_ADDRESS, WETH, 3000);
+        const v3Pool500 = await v3Factory.getPool(LFT_ADDRESS, WETH, 500);
+        const v3Pool10000 = await v3Factory.getPool(LFT_ADDRESS, WETH, 10000);
+        
+        if (v3Pool3000 !== ethers.constants.AddressZero) {
+            console.log('   🔥 EXPLOIT: Uniswap V3 pool exists (0.3%):', v3Pool3000);
+            console.log('   You can sell there!');
+        }
+        if (v3Pool500 !== ethers.constants.AddressZero) {
+            console.log('   🔥 EXPLOIT: Uniswap V3 pool exists (0.05%):', v3Pool500);
+            console.log('   You can sell there!');
+        }
+        if (v3Pool10000 !== ethers.constants.AddressZero) {
+            console.log('   🔥 EXPLOIT: Uniswap V3 pool exists (1%):', v3Pool10000);
+            console.log('   You can sell there!');
+        }
+        
+        if (v3Pool3000 === ethers.constants.AddressZero && 
+            v3Pool500 === ethers.constants.AddressZero && 
+            v3Pool10000 === ethers.constants.AddressZero) {
+            console.log('   ❌ No Uniswap V3 pools found');
+        }
+    } catch (e) {
+        console.log('   ❌ Error checking V3:', e.message);
+    }
+    
+    // Final verdict
+    console.log('\n=== FINAL VERDICT ===');
+    
+    if (owner === ethers.constants.AddressZero || minter === ethers.constants.AddressZero) {
+        console.log('🔥 EXPLOIT POSSIBLE: Contract is uninitialized!');
+        console.log('   Deploy exploit contract immediately!');
+    } else {
+        console.log('❌ NO EXPLOIT FOUND');
+        console.log('   Contract is properly initialized');
+        console.log('   Honeypot is active and cannot be bypassed');
+        console.log('   Move on to next target');
+    }
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });

package/check-lft-accounting.js

@@ -0,0 +1,109 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://eth-mainnet.g.alchemy.com/v2/5IWkkFu-rS6plYHO9MLq-');
+
+const LFT_TOKEN = '0xb620be8a1949aa9532e6a3510132864ef9bc3f82';
+
+const ERC20_ABI = [
+    'function totalSupply() view returns (uint256)',
+    'function balanceOf(address) view returns (uint256)',
+    'function decimals() view returns (uint8)',
+    'function name() view returns (string)',
+    'function symbol() view returns (string)'
+];
+
+// Top holders from Etherscan
+const TOP_HOLDERS = [
+    { name: 'Uniswap V2 Pair', address: '0x9ac8E58d6f1F2193249569330d5F5956250c711D', percentage: 103.72 },
+    { name: 'Address 2', address: '0x314AF1c6e1Fc0F9C0f8a0e0e8e88aBE2dC811625', percentage: 67.69 },
+    { name: 'Address 3', address: '0x4Ce4Bbf3e8f8626905104490345.3206410936171183626', percentage: 7.28 },
+];
+
+async function analyzeLFT() {
+    console.log('=== LFT TOKEN ACCOUNTING ANALYSIS ===\n');
+    console.log('Token:', LFT_TOKEN);
+    console.log('Issue: Holders show >100% of total supply\n');
+    
+    const lft = new ethers.Contract(LFT_TOKEN, ERC20_ABI, provider);
+    
+    // Get basic info
+    const name = await lft.name();
+    const symbol = await lft.symbol();
+    const decimals = await lft.decimals();
+    const totalSupply = await lft.totalSupply();
+    
+    console.log('=== TOKEN INFO ===');
+    console.log('Name:', name);
+    console.log('Symbol:', symbol);
+    console.log('Decimals:', decimals);
+    console.log('Total Supply:', ethers.utils.formatUnits(totalSupply, decimals), symbol);
+    console.log('Total Supply (wei):', totalSupply.toString());
+    
+    // Check top holders
+    console.log('\n=== TOP HOLDERS ANALYSIS ===\n');
+    
+    const uniswapPair = '0x9ac8e58d6f1f2193249569330d5f5956250c711d';
+    const holder2 = '0x314af1c6e1fc0f9c0f8a0e0e8e88abe2dc811625';
+    const holder3 = '0x4ce4bbf3e8f8626905104490345';
+    
+    let totalHeld = ethers.BigNumber.from(0);
+    
+    // Check Uniswap pair
+    const pairBalance = await lft.balanceOf(uniswapPair);
+    console.log('1. Uniswap V2 Pair:', uniswapPair);
+    console.log('   Balance:', ethers.utils.formatUnits(pairBalance, decimals), symbol);
+    console.log('   % of supply:', pairBalance.mul(10000).div(totalSupply).toNumber() / 100, '%');
+    totalHeld = totalHeld.add(pairBalance);
+    
+    // Check holder 2
+    const balance2 = await lft.balanceOf(holder2);
+    console.log('\n2. Holder 2:', holder2);
+    console.log('   Balance:', ethers.utils.formatUnits(balance2, decimals), symbol);
+    console.log('   % of supply:', balance2.mul(10000).div(totalSupply).toNumber() / 100, '%');
+    totalHeld = totalHeld.add(balance2);
+    
+    // Check holder 3 (might be invalid address)
+    try {
+        const balance3 = await lft.balanceOf(holder3);
+        console.log('\n3. Holder 3:', holder3);
+        console.log('   Balance:', ethers.utils.formatUnits(balance3, decimals), symbol);
+        console.log('   % of supply:', balance3.mul(10000).div(totalSupply).toNumber() / 100, '%');
+        totalHeld = totalHeld.add(balance3);
+    } catch (e) {
+        console.log('\n3. Holder 3: Invalid address');
+    }
+    
+    console.log('\n=== ACCOUNTING CHECK ===');
+    console.log('Total Supply:', ethers.utils.formatUnits(totalSupply, decimals), symbol);
+    console.log('Top 2 Holders:', ethers.utils.formatUnits(totalHeld, decimals), symbol);
+    console.log('Percentage:', totalHeld.mul(10000).div(totalSupply).toNumber() / 100, '%');
+    
+    if (totalHeld.gt(totalSupply)) {
+        console.log('\n[CRITICAL] ACCOUNTING BUG DETECTED!');
+        console.log('Holders have MORE tokens than total supply!');
+        console.log('Difference:', ethers.utils.formatUnits(totalHeld.sub(totalSupply), decimals), symbol);
+        console.log('\nThis indicates:');
+        console.log('1. Mint function vulnerability (unlimited minting)');
+        console.log('2. Rebasing mechanism not tracked in totalSupply');
+        console.log('3. Balance inflation bug');
+    } else {
+        console.log('\n[OK] Accounting appears correct on-chain');
+        console.log('Etherscan display issue or calculation error');
+    }
+    
+    // Check implementation
+    console.log('\n=== PROXY INFO ===');
+    const implementationSlot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+    const implementation = await provider.getStorageAt(LFT_TOKEN, implementationSlot);
+    console.log('Implementation:', '0x' + implementation.slice(-40));
+    
+    // Check if there's a mint function
+    console.log('\n=== CHECKING FOR VULNERABILITIES ===');
+    console.log('Analyzing contract for:');
+    console.log('- Unrestricted mint functions');
+    console.log('- Rebasing mechanisms');
+    console.log('- Balance inflation bugs');
+    console.log('- Similar to BlockSec patterns');
+}
+
+analyzeLFT().catch(console.error);

package/check-lft-roles.js

@@ -0,0 +1,165 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://eth-mainnet.g.alchemy.com/v2/5IWkkFu-rS6plYHO9MLq-');
+
+const LFT_TOKEN = '0xb620be8a1949aa9532e6a3510132864ef9bc3f82';
+
+// Storage slots from decompiled code
+const OWNER_SLOT = '0xd'; // _owner at STORAGE[0xd]
+const MINTER_SLOT = '0xe'; // _minter at STORAGE[0xe]
+const LIQUIDITY_TRANSFORMER_SLOT = '0xf'; // _liquidityTransformer at STORAGE[0xf]
+const MULTISIG_SLOT = '0xc'; // _multiSigUser at STORAGE[0xc]
+const LIQUIDITY_FLAG_SLOT = '0xf'; // _liquidity bool at STORAGE[0xf] bytes 20-20
+
+const ERC20_ABI = [
+    'function owner() view returns (address)',
+    'function minter() view returns (address)',
+    'function liquidityTransformer() view returns (address)',
+    'function multiSigUser() view returns (address)',
+    'function liquidity() view returns (bool)',
+    'function balanceOf(address) view returns (uint256)',
+    'function totalSupply() view returns (uint256)',
+];
+
+async function checkRoles() {
+    console.log('=== LFT TOKEN ROLE ANALYSIS ===\n');
+    
+    const lft = new ethers.Contract(LFT_TOKEN, ERC20_ABI, provider);
+    
+    try {
+        // Check owner
+        const owner = await lft.owner();
+        console.log('Owner:', owner);
+        
+        // Check if owner is zero address (renounced)
+        if (owner === ethers.constants.AddressZero) {
+            console.log('  ✅ Ownership RENOUNCED\n');
+        } else {
+            console.log('  ⚠️  Owner has control\n');
+        }
+    } catch (e) {
+        console.log('Owner: ERROR -', e.message, '\n');
+    }
+    
+    try {
+        // Check minter
+        const minter = await lft.minter();
+        console.log('Minter:', minter);
+        
+        if (minter === ethers.constants.AddressZero) {
+            console.log('  ✅ Minter is zero address (no minting)\n');
+        } else {
+            console.log('  ⚠️  Minter can mint tokens\n');
+        }
+    } catch (e) {
+        console.log('Minter: ERROR -', e.message, '\n');
+    }
+    
+    try {
+        // Check liquidityTransformer
+        const liquidityTransformer = await lft.liquidityTransformer();
+        console.log('LiquidityTransformer:', liquidityTransformer);
+        
+        if (liquidityTransformer === ethers.constants.AddressZero) {
+            console.log('  ✅ Not set\n');
+        } else {
+            console.log('  ⚠️  Has special privileges\n');
+        }
+    } catch (e) {
+        console.log('LiquidityTransformer: ERROR -', e.message, '\n');
+    }
+    
+    try {
+        // Check multiSigUser
+        const multiSigUser = await lft.multiSigUser();
+        console.log('MultiSigUser:', multiSigUser);
+        console.log('  (Receives initial supply)\n');
+    } catch (e) {
+        console.log('MultiSigUser: ERROR -', e.message, '\n');
+    }
+    
+    try {
+        // Check liquidity flag
+        const liquidity = await lft.liquidity();
+        console.log('Liquidity Flag:', liquidity);
+        
+        if (liquidity) {
+            console.log('  ✅ Liquidity phase finished (minting enabled)\n');
+        } else {
+            console.log('  ⚠️  Liquidity phase not finished\n');
+        }
+    } catch (e) {
+        console.log('Liquidity: ERROR -', e.message, '\n');
+    }
+    
+    // Check storage directly
+    console.log('=== DIRECT STORAGE READS ===\n');
+    
+    const ownerStorage = await provider.getStorageAt(LFT_TOKEN, OWNER_SLOT);
+    console.log('Owner (storage):', '0x' + ownerStorage.slice(-40));
+    
+    const minterStorage = await provider.getStorageAt(LFT_TOKEN, MINTER_SLOT);
+    console.log('Minter (storage):', '0x' + minterStorage.slice(-40));
+    
+    const liquidityTransformerStorage = await provider.getStorageAt(LFT_TOKEN, LIQUIDITY_TRANSFORMER_SLOT);
+    console.log('LiquidityTransformer (storage):', '0x' + liquidityTransformerStorage.slice(-40));
+    
+    const multiSigStorage = await provider.getStorageAt(LFT_TOKEN, MULTISIG_SLOT);
+    console.log('MultiSigUser (storage):', '0x' + multiSigStorage.slice(-40));
+    
+    // Check liquidity flag (byte 20 of slot 0xf)
+    const liquidityFlagStorage = await provider.getStorageAt(LFT_TOKEN, LIQUIDITY_FLAG_SLOT);
+    const liquidityByte = '0x' + liquidityFlagStorage.slice(-2);
+    console.log('Liquidity Flag (storage):', liquidityByte === '0x01' ? 'true' : 'false');
+    
+    console.log('\n=== EXPLOIT ANALYSIS ===\n');
+    
+    // Check if we can exploit
+    const ownerAddr = '0x' + ownerStorage.slice(-40);
+    const minterAddr = '0x' + minterStorage.slice(-40);
+    
+    if (ownerAddr === '0x0000000000000000000000000000000000000000') {
+        console.log('✅ EXPLOIT VECTOR 1: Owner renounced');
+        console.log('   - Cannot call setMinter()');
+        console.log('   - Cannot call setOwner()');
+        console.log('   - Cannot call setLiquidityTransformer()\n');
+    } else {
+        console.log('⚠️  Owner still has control:', ownerAddr);
+        console.log('   - Can call setMinter() to change minter');
+        console.log('   - Can call setOwner() to change owner');
+        console.log('   - Can call setLiquidityTransformer()\n');
+    }
+    
+    if (minterAddr === '0x0000000000000000000000000000000000000000') {
+        console.log('✅ EXPLOIT VECTOR 2: No minter set');
+        console.log('   - Cannot mint new tokens');
+        console.log('   - Hidden balance is fixed\n');
+    } else {
+        console.log('⚠️  Minter is set:', minterAddr);
+        console.log('   - Can mint tokens up to availableSupply()');
+        console.log('   - Can increase hidden balance further\n');
+    }
+    
+    // Check the hidden address balance
+    const HIDDEN_ADDR = '0x2caa8387030af8fd61c59eee88341dc590883496';
+    const UNISWAP_ROUTER = '0x7a250d5630b4cf539739df2c5dacb4c659f2488d';
+    
+    console.log('=== HIDDEN BALANCE CHECK ===\n');
+    
+    const normalBalance = await lft.balanceOf(HIDDEN_ADDR);
+    console.log('Hidden address (normal query):', ethers.utils.formatEther(normalBalance), 'LFT');
+    
+    const routerBalance = await provider.call({
+        to: LFT_TOKEN,
+        from: UNISWAP_ROUTER,
+        data: lft.interface.encodeFunctionData('balanceOf', [HIDDEN_ADDR])
+    });
+    const decoded = lft.interface.decodeFunctionResult('balanceOf', routerBalance);
+    console.log('Hidden address (router query):', ethers.utils.formatEther(decoded[0]), 'LFT');
+    
+    if (decoded[0].gt(0)) {
+        console.log('\n⚠️  CRITICAL: Hidden balance exists and can be exploited!');
+    }
+}
+
+checkRoles().catch(console.error);

package/check-lock-time.js

@@ -0,0 +1,47 @@
+const ethers = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
+
+async function checkLockTime() {
+    const lockAddress = '0x7536592bb74b5d62eb82e8b93b17eed4eed9a85c';
+    
+    // Try different function signatures for getting lock info
+    const lockContract = new ethers.Contract(lockAddress, [
+        'function tokenLocks(uint256) view returns (uint256,uint256,uint256,uint256,uint256,address,bool)',
+        'function depositsByWithdrawalAddress(address,uint256) view returns (uint256)',
+    ], provider);
+    
+    const owner = '0x4e84E92C6221b638599504a89E7B664eA86386A0';
+    
+    console.log('Checking deposit ID 6 (owner deposit)...\n');
+    
+    try {
+        const lockInfo = await lockContract.tokenLocks(6);
+        console.log('Lock Info:');
+        console.log('  Amount:', ethers.utils.formatEther(lockInfo[0]));
+        console.log('  Unlock time (timestamp):', lockInfo[1].toString());
+        
+        const unlockDate = new Date(lockInfo[1].toNumber() * 1000);
+        console.log('  Unlock date:', unlockDate.toISOString());
+        console.log('  Unlock date (readable):', unlockDate.toUTCString());
+        
+        const now = Date.now() / 1000;
+        const timeLeft = lockInfo[1].toNumber() - now;
+        
+        if (timeLeft > 0) {
+            const days = Math.floor(timeLeft / 86400);
+            console.log('  Time until unlock:', days, 'days');
+            console.log('  STILL LOCKED');
+        } else {
+            console.log('  UNLOCKED! Can withdraw now');
+        }
+        
+        console.log('\n  Withdrawn:', lockInfo[6]);
+        console.log('  Beneficiary:', lockInfo[5]);
+        
+    } catch (e) {
+        console.log('Error reading lock info:', e.message);
+    }
+}
+
+checkLockTime().catch(console.error);

package/check-min-stake.js

@@ -0,0 +1,73 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2';
+const STAKING = '0x3E13019dA3BAAd134493e751704D2D4245Eec7CA';
+
+// Staked event signature
+const STAKED_EVENT = '0x9cfd25589d1eb8ad71e342a86a8524e83522e3936c0803048c08f6d9ad974f40';
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC);
+    
+    console.log('=== Checking Recent Stakes for Minimum Amount ===\n');
+    
+    const latestBlock = await provider.getBlockNumber();
+    console.log('Latest block:', latestBlock);
+    
+    // Check last 2000 blocks
+    const logs = await provider.getLogs({
+        address: STAKING,
+        topics: [STAKED_EVENT],
+        fromBlock: latestBlock - 2000,
+        toBlock: 'latest'
+    });
+    
+    console.log(`Found ${logs.length} stake events\n`);
+    
+    if (logs.length === 0) {
+        console.log('No recent stakes found');
+        return;
+    }
+    
+    // Decode stake amounts
+    const amounts = [];
+    
+    for (const log of logs) {
+        // Staked event: Staked(address indexed user, uint256 item, uint256 amount, uint256 payment, uint256 stakeId)
+        // user is indexed (in topics), rest are in data
+        const user = ethers.utils.defaultAbiCoder.decode(['address'], log.topics[1])[0];
+        
+        const decoded = ethers.utils.defaultAbiCoder.decode(
+            ['uint256', 'uint256', 'uint256', 'uint256'],
+            log.data
+        );
+        
+        const item = decoded[0];
+        const amount = decoded[1]; // amount parameter
+        const payment = decoded[2];
+        const stakeId = decoded[3];
+        
+        amounts.push({
+            user,
+            amount,
+            item,
+            payment,
+            stakeId
+        });
+    }
+    
+    // Sort amounts
+    amounts.sort((a, b) => a.amount.sub(b.amount).isNegative() ? -1 : 1);
+    
+    console.log('Stake amounts (sorted):');
+    console.log('Minimum:', ethers.utils.formatEther(amounts[0].amount), 'USDT');
+    console.log('Maximum:', ethers.utils.formatEther(amounts[amounts.length - 1].amount), 'USDT');
+    console.log('Median:', ethers.utils.formatEther(amounts[Math.floor(amounts.length / 2)].amount), 'USDT');
+    
+    console.log('\nFirst 10 amounts:');
+    amounts.slice(0, 10).forEach((stake, i) => {
+        console.log(`${i + 1}. ${ethers.utils.formatEther(stake.amount)} USDT (item: ${ethers.utils.formatEther(stake.item)})`);
+    });
+}
+
+main().catch(console.error);

package/check-mystery-contract.js

@@ -0,0 +1,52 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://eth-mainnet.g.alchemy.com/v2/5IWkkFu-rS6plYHO9MLq-');
+
+const CONTRACT = '0x6859ea44DC8E9A42222Ea1BC38ED74E8c8fe6DC7';
+
+const ERC20_ABI = [
+    'function name() view returns (string)',
+    'function symbol() view returns (string)',
+    'function decimals() view returns (uint8)',
+    'function totalSupply() view returns (uint256)',
+    'function balanceOf(address) view returns (uint256)',
+    'function owner() view returns (address)'
+];
+
+async function checkContract() {
+    console.log('=== CONTRACT ANALYSIS ===\n');
+    console.log(`Address: ${CONTRACT}\n`);
+    
+    const code = await provider.getCode(CONTRACT);
+    console.log(`Bytecode length: ${code.length} bytes`);
+    console.log(`Is contract: ${code !== '0x'}\n`);
+    
+    const contract = new ethers.Contract(CONTRACT, ERC20_ABI, provider);
+    
+    try {
+        const name = await contract.name();
+        const symbol = await contract.symbol();
+        const decimals = await contract.decimals();
+        const totalSupply = await contract.totalSupply();
+        const totalSupplyFormatted = ethers.utils.formatUnits(totalSupply, decimals);
+        
+        console.log('=== TOKEN INFO ===');
+        console.log(`Name: ${name}`);
+        console.log(`Symbol: ${symbol}`);
+        console.log(`Decimals: ${decimals}`);
+        console.log(`Total Supply: ${totalSupplyFormatted}\n`);
+        
+        try {
+            const owner = await contract.owner();
+            console.log(`Owner: ${owner}\n`);
+        } catch (e) {
+            console.log('No owner function\n');
+        }
+        
+    } catch (error) {
+        console.log('Not an ERC20 token or different interface\n');
+        console.log('Error:', error.message);
+    }
+}
+
+checkContract().catch(console.error);

package/check-next-token.js

@@ -0,0 +1,50 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed1.binance.org');
+const address = '0xe283d0e3b8c102badf5e8166b73e02d96d92f688';
+
+const abi = [
+  'function name() view returns (string)',
+  'function symbol() view returns (string)',
+  'function decimals() view returns (uint8)',
+  'function totalSupply() view returns (uint256)',
+  'function owner() view returns (address)',
+  'function getOwner() view returns (address)'
+];
+
+const contract = new ethers.Contract(address, abi, provider);
+
+async function main() {
+  console.log('=== Token Analysis ===\n');
+  
+  try {
+    const name = await contract.name();
+    const symbol = await contract.symbol();
+    const decimals = await contract.decimals();
+    const supply = await contract.totalSupply();
+    
+    console.log('Name:', name);
+    console.log('Symbol:', symbol);
+    console.log('Decimals:', decimals);
+    console.log('Total Supply:', ethers.utils.formatUnits(supply, decimals));
+  } catch (e) {
+    console.log('Basic info error:', e.message);
+  }
+  
+  try {
+    const owner = await contract.owner();
+    console.log('Owner:', owner);
+  } catch (e) {
+    try {
+      const owner = await contract.getOwner();
+      console.log('Owner (getOwner):', owner);
+    } catch (e2) {
+      console.log('No owner function');
+    }
+  }
+  
+  const code = await provider.getCode(address);
+  console.log('\nBytecode length:', code.length);
+}
+
+main().catch(console.error);