uups-checker 1.0.0

package/check-alpha-proxy.js

@@ -0,0 +1,42 @@
+const Web3 = require('web3');
+const web3 = new Web3('https://bsc-dataseed.binance.org/');
+
+async function checkProxy() {
+    const proxyAddr = '0x71aa12b3864f577e3e52ca3eac34949df3732c69';
+    const adminAddr = '0xb8af5a48fefa0e696b54839a2a74eceb6d8abb51';
+    
+    // ERC1967 implementation slot
+    const implSlot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+    
+    console.log('=== ALPHA PROXY ANALYSIS ===\n');
+    console.log('Proxy:', proxyAddr);
+    console.log('Admin:', adminAddr);
+    
+    // Get implementation address
+    const implData = await web3.eth.getStorageAt(proxyAddr, implSlot);
+    const impl = '0x' + implData.slice(-40);
+    console.log('\nImplementation:', impl);
+    
+    // Check if implementation has code
+    const implCode = await web3.eth.getCode(impl);
+    console.log('Implementation has code:', implCode.length > 2);
+    
+    // Check admin balance
+    const adminBalance = await web3.eth.getBalance(adminAddr);
+    console.log('\nAdmin BNB balance:', web3.utils.fromWei(adminBalance, 'ether'), 'BNB');
+    
+    // Check if admin is a contract
+    const adminCode = await web3.eth.getCode(adminAddr);
+    console.log('Admin is contract:', adminCode.length > 2);
+    
+    // Check proxy token balance
+    const alphaToken = '0xa1faa113cbe53436df28ff0aee54275c13b40975';
+    const balanceOfSig = '0x70a08231' + proxyAddr.slice(2).padStart(64, '0');
+    const balance = await web3.eth.call({
+        to: alphaToken,
+        data: balanceOfSig
+    });
+    console.log('\nProxy ALPHA balance:', web3.utils.fromWei(balance, 'ether'), 'ALPHA');
+}
+
+checkProxy().catch(console.error);

package/check-arbitrage.js

@@ -0,0 +1,155 @@
+// Check if LendFlare V2/V3 arbitrage is profitable
+// Run with: node check-arbitrage.js
+
+const ethers = require('ethers');
+
+const LFT = '0xB620Be8a1949AA9532e6a3510132864EF9Bc3F82';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const V2_ROUTER = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D';
+const V2_PAIR = '0x9c84f58bb51fabd18698efe95f5bab4f33e96e8f';
+const V3_POOL = '0x9bA091Ca2E2886DB44559784ab4Dc80D69773889';
+
+const ROUTER_ABI = [
+    'function getAmountsOut(uint amountIn, address[] memory path) view returns (uint[] memory amounts)'
+];
+
+const PAIR_ABI = [
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function token0() view returns (address)',
+    'function token1() view returns (address)'
+];
+
+const POOL_ABI = [
+    'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)',
+    'function liquidity() view returns (uint128)',
+    'function token0() view returns (address)',
+    'function token1() view returns (address)'
+];
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(
+        process.env.ETH_RPC_URL || 'https://eth.llamarpc.com'
+    );
+    
+    console.log('=== LENDFLARE ARBITRAGE ANALYSIS ===\n');
+    
+    // V2 Analysis
+    console.log('1. UNISWAP V2 ANALYSIS:');
+    const v2Pair = new ethers.Contract(V2_PAIR, PAIR_ABI, provider);
+    const v2Router = new ethers.Contract(V2_ROUTER, ROUTER_ABI, provider);
+    
+    const reserves = await v2Pair.getReserves();
+    const token0 = await v2Pair.token0();
+    
+    let lftReserve, wethReserve;
+    if (token0.toLowerCase() === LFT.toLowerCase()) {
+        lftReserve = reserves.reserve0;
+        wethReserve = reserves.reserve1;
+    } else {
+        wethReserve = reserves.reserve0;
+        lftReserve = reserves.reserve1;
+    }
+    
+    console.log('   LFT Reserve:', ethers.utils.formatEther(lftReserve));
+    console.log('   WETH Reserve:', ethers.utils.formatEther(wethReserve));
+    
+    const v2Price = wethReserve.mul(ethers.utils.parseEther('1')).div(lftReserve);
+    console.log('   Price: 1 LFT =', ethers.utils.formatEther(v2Price), 'WETH');
+    
+    // Test buy on V2
+    const testAmount = ethers.utils.parseEther('100'); // 100 WETH
+    const v2Path = [WETH, LFT];
+    const v2Amounts = await v2Router.getAmountsOut(testAmount, v2Path);
+    const lftFromV2 = v2Amounts[1];
+    
+    console.log('   Buy 100 WETH → Get', ethers.utils.formatEther(lftFromV2), 'LFT');
+    
+    // V3 Analysis
+    console.log('\n2. UNISWAP V3 ANALYSIS:');
+    const v3Pool = new ethers.Contract(V3_POOL, POOL_ABI, provider);
+    
+    try {
+        const slot0 = await v3Pool.slot0();
+        const liquidity = await v3Pool.liquidity();
+        const v3Token0 = await v3Pool.token0();
+        
+        console.log('   Pool exists: YES');
+        console.log('   Liquidity:', liquidity.toString());
+        console.log('   SqrtPriceX96:', slot0.sqrtPriceX96.toString());
+        
+        // Calculate price from sqrtPriceX96
+        const sqrtPrice = slot0.sqrtPriceX96;
+        const price = sqrtPrice.mul(sqrtPrice).div(ethers.BigNumber.from(2).pow(192));
+        
+        let v3Price;
+        if (v3Token0.toLowerCase() === LFT.toLowerCase()) {
+            // token0 = LFT, token1 = WETH
+            // price = WETH/LFT
+            v3Price = price;
+        } else {
+            // token0 = WETH, token1 = LFT
+            // price = LFT/WETH, need to invert
+            v3Price = ethers.utils.parseEther('1').mul(ethers.utils.parseEther('1')).div(price);
+        }
+        
+        console.log('   Price: 1 LFT =', ethers.utils.formatEther(v3Price), 'WETH (approx)');
+        
+        // Estimate sell on V3 (rough calculation)
+        // Actual amount depends on liquidity and price impact
+        const estimatedWethFromV3 = lftFromV2.mul(v3Price).div(ethers.utils.parseEther('1'));
+        console.log('   Sell', ethers.utils.formatEther(lftFromV2), 'LFT → Get ~', ethers.utils.formatEther(estimatedWethFromV3), 'WETH (approx)');
+        
+        // Calculate profit
+        console.log('\n3. ARBITRAGE CALCULATION:');
+        console.log('   Flash loan: 100 WETH');
+        console.log('   Buy on V2: ', ethers.utils.formatEther(lftFromV2), 'LFT');
+        console.log('   Sell on V3: ~', ethers.utils.formatEther(estimatedWethFromV3), 'WETH');
+        console.log('   Repay loan: 100 WETH');
+        
+        const profit = estimatedWethFromV3.sub(testAmount);
+        const profitPercent = profit.mul(10000).div(testAmount).toNumber() / 100;
+        
+        console.log('   Profit: ', ethers.utils.formatEther(profit), 'WETH');
+        console.log('   Profit %:', profitPercent.toFixed(2), '%');
+        
+        if (profit.gt(0)) {
+            const profitUSD = parseFloat(ethers.utils.formatEther(profit)) * 2200; // Assume $2200/ETH
+            console.log('   Profit USD: $', profitUSD.toFixed(2));
+            
+            if (profitPercent > 1) {
+                console.log('\n🔥 ARBITRAGE OPPORTUNITY DETECTED!');
+                console.log('   Deploy LendFlareFlashLoanArbitrage.sol NOW!');
+            } else {
+                console.log('\n⚠️  Profit is low (<1%)');
+                console.log('   Gas costs might eat into profits');
+                console.log('   Consider waiting for better opportunity');
+            }
+        } else {
+            console.log('\n❌ NO ARBITRAGE OPPORTUNITY');
+            console.log('   V3 price is lower than V2 price');
+            console.log('   Would lose money');
+        }
+        
+    } catch (e) {
+        console.log('   Error reading V3 pool:', e.message);
+        console.log('   Pool might not exist or have liquidity');
+    }
+    
+    // Final verdict
+    console.log('\n=== FINAL VERDICT ===');
+    console.log('V2 allows buying: ✅');
+    console.log('V3 allows selling: ✅');
+    console.log('Flash loan fee: 0% (Balancer) ✅');
+    
+    console.log('\nNext steps:');
+    console.log('1. Deploy LendFlareFlashLoanArbitrage.sol');
+    console.log('2. Call executeArbitrage(100 ether)');
+    console.log('3. Profit!');
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });

package/check-aria-token.js

@@ -0,0 +1,47 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2');
+const address = '0x5d3a12c42e5372b2cc3264ab3cdcf660a1555238';
+
+// Standard ERC20 ABI
+const 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 checkToken() {
+    const contract = new ethers.Contract(address, abi, provider);
+    
+    try {
+        const name = await contract.name();
+        const symbol = await contract.symbol();
+        const decimals = await contract.decimals();
+        const totalSupply = await contract.totalSupply();
+        
+        console.log('Token Name:', name);
+        console.log('Symbol:', symbol);
+        console.log('Decimals:', decimals);
+        console.log('Total Supply:', ethers.utils.formatUnits(totalSupply, decimals));
+        
+        try {
+            const owner = await contract.owner();
+            console.log('Owner:', owner);
+        } catch (e) {
+            console.log('No owner() function or not Ownable');
+        }
+        
+        // Get bytecode
+        const code = await provider.getCode(address);
+        console.log('\nBytecode length:', code.length, 'chars');
+        console.log('Contract is deployed:', code !== '0x');
+        
+    } catch (error) {
+        console.error('Error:', error.message);
+    }
+}
+
+checkToken();

package/check-ark.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+RPC="https://bsc-mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2"
+TOKEN="0xcae117ca6bc8a341d2e7207f30e180f0e5618b9d"
+
+echo "=== ARK Token Info ==="
+echo "Name: $(cast call $TOKEN "name()(string)" --rpc-url $RPC)"
+echo "Symbol: $(cast call $TOKEN "symbol()(string)" --rpc-url $RPC)"
+echo "Decimals: $(cast call $TOKEN "decimals()(uint8)" --rpc-url $RPC)"
+echo "Total Supply: $(cast call $TOKEN "totalSupply()(uint256)" --rpc-url $RPC)"
+echo ""
+echo "=== Governance Info ==="
+echo "Governance: $(cast call $TOKEN "governance()(address)" --rpc-url $RPC)"
+echo "Oracle: $(cast call $TOKEN "oracle()(address)" --rpc-url $RPC)"
+echo "RBS: $(cast call $TOKEN "rbs()(address)" --rpc-url $RPC)"
+echo "Treasury: $(cast call $TOKEN "treasury()(address)" --rpc-url $RPC)"
+echo ""
+echo "=== Tax Rates ==="
+echo "Buy Tax (longGovernanceRatio): $(cast call $TOKEN "longGovernanceRatio()(uint256)" --rpc-url $RPC)"
+echo "Sell Tax (shortGovernanceRatio): $(cast call $TOKEN "shortGovernanceRatio()(uint256)" --rpc-url $RPC)"
+echo "BPS_100: $(cast call $TOKEN "BPS_100()(uint256)" --rpc-url $RPC)"

package/check-btcst-mining.js

@@ -0,0 +1,75 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-dataseed1.binance.org';
+const provider = new ethers.providers.JsonRpcProvider(RPC);
+
+const BTCST_PROXY = '0x78650B139471520656b9E7aA7A5e9276814a38e9';
+
+async function main() {
+    console.log('🔍 BTCST Mining/Rebase Contract Analysis\n');
+    
+    // Check storage slots directly
+    console.log('📊 Reading Storage Slots...\n');
+    
+    // Common storage layout for upgradeable contracts:
+    // Slot 0-10: Basic token data
+    // Higher slots: Custom data
+    
+    for (let i = 0; i < 30; i++) {
+        const slot = ethers.utils.hexZeroPad(ethers.utils.hexlify(i), 32);
+        const value = await provider.getStorageAt(BTCST_PROXY, slot);
+        if (value !== '0x0000000000000000000000000000000000000000000000000000000000000000') {
+            console.log(`Slot ${i}:`, value);
+            
+            // Try to interpret as address
+            if (value.startsWith('0x000000000000000000000000')) {
+                const addr = '0x' + value.slice(26);
+                if (addr !== '0x0000000000000000000000000000000000000000') {
+                    console.log(`  → Possible Address: ${addr}`);
+                    const code = await provider.getCode(addr);
+                    if (code !== '0x') {
+                        console.log(`  → Has Contract Code (${code.length} bytes)`);
+                    }
+                }
+            }
+        }
+    }
+    
+    // Check implementation slot (EIP-1967)
+    const implSlot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+    const implAddress = await provider.getStorageAt(BTCST_PROXY, implSlot);
+    console.log('\n📍 Implementation Address (EIP-1967):', implAddress);
+    
+    // Check admin slot (EIP-1967)
+    const adminSlot = '0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103';
+    const adminAddress = await provider.getStorageAt(BTCST_PROXY, adminSlot);
+    console.log('📍 Admin Address (EIP-1967):', adminAddress);
+    
+    // Get recent transactions
+    console.log('\n📜 Checking Recent Activity...');
+    const latestBlock = await provider.getBlockNumber();
+    console.log('Latest Block:', latestBlock);
+    
+    // Check for Transfer events (last 10000 blocks)
+    const transferTopic = ethers.utils.id('Transfer(address,address,uint256)');
+    const events = await provider.getLogs({
+        address: BTCST_PROXY,
+        topics: [transferTopic],
+        fromBlock: latestBlock - 10000,
+        toBlock: 'latest'
+    });
+    
+    console.log('Transfer Events (last 10000 blocks):', events.length);
+    
+    if (events.length > 0) {
+        console.log('\nRecent Transfers:');
+        events.slice(-5).forEach((event, i) => {
+            const from = '0x' + event.topics[1].slice(26);
+            const to = '0x' + event.topics[2].slice(26);
+            const amount = ethers.BigNumber.from(event.data);
+            console.log(`  ${from} → ${to}: ${ethers.utils.formatUnits(amount, 17)} BTCST`);
+        });
+    }
+}
+
+main().catch(console.error);

package/check-btcst-pools.js

@@ -0,0 +1,163 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
+
+const BTCST = '0x78650B139471520656b9E7aA7A5e9276814a38e9';
+const WBNB = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
+const BUSD = '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56';
+const PANCAKE_FACTORY = '0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73';
+
+const FACTORY_ABI = [
+    'function getPair(address tokenA, address tokenB) external view returns (address pair)'
+];
+
+const PAIR_ABI = [
+    'function token0() external view returns (address)',
+    'function token1() external view returns (address)',
+    'function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+    'function totalSupply() external view returns (uint256)'
+];
+
+const ERC20_ABI = [
+    'function decimals() external view returns (uint8)',
+    'function symbol() external view returns (string)',
+    'function balanceOf(address) external view returns (uint256)'
+];
+
+async function checkBTCSTPool() {
+    console.log('=== BTCST DECIMAL CONFUSION ANALYSIS ===\n');
+    
+    const factory = new ethers.Contract(PANCAKE_FACTORY, FACTORY_ABI, provider);
+    const btcst = new ethers.Contract(BTCST, ERC20_ABI, provider);
+    
+    // Get BTCST info
+    const btcstDecimals = await btcst.decimals();
+    const btcstSymbol = await btcst.symbol();
+    
+    console.log(`Token: ${btcstSymbol}`);
+    console.log(`Address: ${BTCST}`);
+    console.log(`Decimals: ${btcstDecimals} (UNUSUAL! Standard is 18)`);
+    console.log(`Decimal Difference: 10^${18 - btcstDecimals} = ${Math.pow(10, 18 - btcstDecimals)}x\n`);
+    
+    // Check BTCST/WBNB pool
+    console.log('=== CHECKING BTCST/WBNB POOL ===');
+    const btcstWbnbPair = await factory.getPair(BTCST, WBNB);
+    
+    if (btcstWbnbPair === ethers.constants.AddressZero) {
+        console.log('❌ NO BTCST/WBNB POOL FOUND\n');
+    } else {
+        console.log(`✅ Pool Found: ${btcstWbnbPair}`);
+        await analyzePool(btcstWbnbPair, 'BTCST', 'WBNB', btcstDecimals);
+    }
+    
+    // Check BTCST/BUSD pool
+    console.log('=== CHECKING BTCST/BUSD POOL ===');
+    const btcstBusdPair = await factory.getPair(BTCST, BUSD);
+    
+    if (btcstBusdPair === ethers.constants.AddressZero) {
+        console.log('❌ NO BTCST/BUSD POOL FOUND\n');
+    } else {
+        console.log(`✅ Pool Found: ${btcstBusdPair}`);
+        await analyzePool(btcstBusdPair, 'BTCST', 'BUSD', btcstDecimals);
+    }
+    
+    // Check time-locked balances
+    console.log('=== CHECKING TIME-LOCKED BALANCES ===');
+    await checkTimeLockedBalances();
+    
+    // Check owner/admin addresses
+    console.log('\n=== CHECKING OWNER/ADMIN ADDRESSES ===');
+    await checkOwnerAdmin();
+}
+
+async function analyzePool(pairAddress, token0Symbol, token1Symbol, btcstDecimals) {
+    const pair = new ethers.Contract(pairAddress, PAIR_ABI, provider);
+    
+    const token0 = await pair.token0();
+    const token1 = await pair.token1();
+    const reserves = await pair.getReserves();
+    const totalSupply = await pair.totalSupply();
+    
+    const token0Contract = new ethers.Contract(token0, ERC20_ABI, provider);
+    const token1Contract = new ethers.Contract(token1, ERC20_ABI, provider);
+    
+    const decimals0 = await token0Contract.decimals();
+    const decimals1 = await token1Contract.decimals();
+    const symbol0 = await token0Contract.symbol();
+    const symbol1 = await token1Contract.symbol();
+    
+    console.log(`Token0: ${symbol0} (${decimals0} decimals)`);
+    console.log(`Token1: ${symbol1} (${decimals1} decimals)`);
+    console.log(`Reserve0: ${ethers.utils.formatUnits(reserves[0], decimals0)} ${symbol0}`);
+    console.log(`Reserve1: ${ethers.utils.formatUnits(reserves[1], decimals1)} ${symbol1}`);
+    console.log(`LP Supply: ${ethers.utils.formatEther(totalSupply)}`);
+    
+    // Calculate price
+    const price = reserves[1].mul(ethers.BigNumber.from(10).pow(decimals0))
+        .div(reserves[0].mul(ethers.BigNumber.from(10).pow(decimals1)));
+    
+    console.log(`Price: 1 ${symbol0} = ${ethers.utils.formatUnits(price, decimals0)} ${symbol1}`);
+    
+    // Check for decimal confusion
+    if (decimals0 === 17 || decimals1 === 17) {
+        console.log('\n⚠️  DECIMAL CONFUSION RISK DETECTED!');
+        console.log('This pool has a token with 17 decimals (non-standard)');
+        console.log('Check if any integrations assume 18 decimals');
+        console.log('Potential 10x price discrepancy if decimal not read correctly');
+    }
+    
+    // Calculate liquidity value
+    const reserve0Value = ethers.utils.formatUnits(reserves[0], decimals0);
+    const reserve1Value = ethers.utils.formatUnits(reserves[1], decimals1);
+    
+    console.log(`\nLiquidity: ${reserve0Value} ${symbol0} + ${reserve1Value} ${symbol1}`);
+    console.log('');
+}
+
+async function checkTimeLockedBalances() {
+    // Check if there are significant time-locked balances
+    const BTCST_IMPL = '0x85d4F83b0Bf400D3aF6fA12C44a28b490689c091';
+    
+    // Storage slots for time-locked balances (from contract analysis)
+    // _totalSupplyReleaseByTimeLock is at slot 0x1cc
+    const slot = '0x00000000000000000000000000000000000000000000000000000000000001cc';
+    
+    try {
+        const value = await provider.getStorageAt(BTCST_IMPL, slot);
+        const totalLocked = ethers.BigNumber.from(value);
+        
+        if (totalLocked.gt(0)) {
+            console.log(`Total Time-Locked Supply: ${ethers.utils.formatUnits(totalLocked, 17)} BTCST`);
+            console.log('⚠️  Significant time-locked tokens exist');
+            console.log('These tokens unlock linearly over 25 weeks (25 rounds)');
+            console.log('Potential for rounding errors in unlock calculation');
+        } else {
+            console.log('No time-locked tokens found (or unable to read storage)');
+        }
+    } catch (error) {
+        console.log('Unable to read time-locked balance storage');
+    }
+}
+
+async function checkOwnerAdmin() {
+    const OWNER = '0xAd3784cD071602d6c9c2980d8e0933466C3F0a0a';
+    const ADMIN = '0xaa4c10aa3de2e4da6b0c0c9d177f1fa77314c9d8';
+    
+    const ownerBalance = await provider.getBalance(OWNER);
+    const adminBalance = await provider.getBalance(ADMIN);
+    
+    console.log(`Owner: ${OWNER}`);
+    console.log(`  BNB Balance: ${ethers.utils.formatEther(ownerBalance)} BNB`);
+    
+    console.log(`\nAdmin: ${ADMIN}`);
+    console.log(`  BNB Balance: ${ethers.utils.formatEther(adminBalance)} BNB`);
+    
+    // Check recent transactions
+    console.log('\n⚠️  CRITICAL: Monitor these addresses for:');
+    console.log('  - adminChangeDecimal() calls');
+    console.log('  - changeFarmContract() calls');
+    console.log('  - Proxy upgrade transactions');
+    console.log('  - Large token transfers');
+}
+
+checkBTCSTPool().catch(console.error);

package/check-btcst.js

@@ -0,0 +1,88 @@
+const { ethers } = require('ethers');
+
+const provider = new ethers.providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
+
+const BTCST_PROXY = '0x78650B139471520656b9E7aA7A5e9276814a38e9';
+
+// EIP-1967 implementation slot
+const IMPLEMENTATION_SLOT = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+
+const PROXY_ABI = [
+    'function implementation() external view returns (address)',
+    'function admin() external view returns (address)'
+];
+
+const ERC20_ABI = [
+    'function name() external view returns (string)',
+    'function symbol() external view returns (string)',
+    'function decimals() external view returns (uint8)',
+    'function totalSupply() external view returns (uint256)',
+    'function balanceOf(address) external view returns (uint256)',
+    'function owner() external view returns (address)',
+    'function paused() external view returns (bool)'
+];
+
+async function analyzeBTCST() {
+    console.log('=== BTCST (Bitcoin Standard Hashrate Token) ANALYSIS ===\n');
+    console.log('Proxy:', BTCST_PROXY);
+    
+    // Get implementation address from storage slot
+    const implAddress = await provider.getStorageAt(BTCST_PROXY, IMPLEMENTATION_SLOT);
+    const implementation = '0x' + implAddress.slice(-40);
+    
+    console.log('Implementation:', implementation);
+    
+    // Get admin
+    const ADMIN_SLOT = '0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103';
+    const adminAddress = await provider.getStorageAt(BTCST_PROXY, ADMIN_SLOT);
+    const admin = '0x' + adminAddress.slice(-40);
+    
+    console.log('Admin:', admin);
+    
+    // Get token info
+    const token = new ethers.Contract(BTCST_PROXY, ERC20_ABI, provider);
+    
+    try {
+        const name = await token.name();
+        const symbol = await token.symbol();
+        const decimals = await token.decimals();
+        const totalSupply = await token.totalSupply();
+        
+        console.log('\n=== TOKEN INFO ===');
+        console.log('Name:', name);
+        console.log('Symbol:', symbol);
+        console.log('Decimals:', decimals);
+        console.log('Total Supply:', ethers.utils.formatUnits(totalSupply, decimals));
+        
+        // Check if paused
+        try {
+            const paused = await token.paused();
+            console.log('Paused:', paused);
+        } catch {
+            console.log('Paused: function not found');
+        }
+        
+        // Check owner
+        try {
+            const owner = await token.owner();
+            console.log('Owner:', owner);
+        } catch {
+            console.log('Owner: function not found');
+        }
+        
+    } catch (error) {
+        console.log('Error getting token info:', error.message);
+    }
+    
+    console.log('\n=== NEXT STEPS ===');
+    console.log('1. Download implementation contract from BSCScan');
+    console.log('2. Look for:');
+    console.log('   - Minting functions');
+    console.log('   - Burning functions');
+    console.log('   - Pause mechanisms');
+    console.log('   - Upgrade vulnerabilities');
+    console.log('   - Access control issues');
+    console.log('   - Mining power redemption logic');
+}
+
+analyzeBTCST().catch(console.error);

package/check-caller.js

@@ -0,0 +1,26 @@
+const { ethers } = require('ethers');
+
+const RPC = 'https://bsc-mainnet.infura.io/v3/db4d2c885bc946b691dbb3d5ef26d9e2';
+const CALLER = '0x849E612202Ca4E2f3C5e66D491461167Ac1f8Da9';
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC);
+    
+    console.log('=== Checking Successful Caller ===');
+    console.log('Address:', CALLER);
+    
+    const code = await provider.getCode(CALLER);
+    console.log('Is contract:', code !== '0x');
+    console.log('Code length:', code.length);
+    
+    if (code === '0x') {
+        console.log('\nThis is an EOA (Externally Owned Account)');
+        console.log('Staking contract likely has msg.sender == tx.origin check');
+        console.log('Contracts CANNOT stake!');
+    } else {
+        console.log('\nThis is a contract!');
+        console.log('Contracts CAN stake');
+    }
+}
+
+main().catch(console.error);