uups-checker 1.0.0

package/BTR_AUDIT.md

@@ -0,0 +1,210 @@
+# BTR Token Security Audit
+
+**Contract:** BTR Token  
+**Proxy:** `0xfed13d0c40790220fbde712987079eda1ed75c51`  
+**Implementation:** `0xc8b5a0c5453c15157328b6cc1f1452be032a41f1`  
+**Chain:** BSC (BNB Smart Chain)  
+**Compiler:** v0.8.24+commit.e11b9ed9 (1000 optimization runs)
+
+---
+
+## EXECUTIVE SUMMARY
+
+**Risk Rating: 6/10 - MEDIUM-HIGH RISK (UUPS Upgradeable + Role Control)**
+
+BTR is a UUPS upgradeable proxy token with role-based access control, pausable transfers, mint quota limits, and whitelist functionality. The contract can be upgraded by admin at any time, and has multiple privileged roles that control critical functions.
+
+---
+
+## CONTRACT OVERVIEW
+
+```solidity
+Token Name: BTR token
+Symbol: BTR
+Decimals: 18
+Total Supply: 62,748,844.828 BTR
+Max Supply: 1,000,000,000 BTR
+Mint Quota: 500,000,000 BTR
+Standard: ERC20 + UUPS Upgradeable + Pausable + Permit
+```
+
+### Key Features:
+- **UUPS Upgradeable**: Admin can upgrade implementation
+- **Role-Based Access**: MINTER, BURNER, PAUSER, DEFAULT_ADMIN
+- **Pausable**: Can freeze transfers for non-whitelisted
+- **Mint Quota**: Capped at 500M (50% of max supply)
+- **Whitelist**: Bypass pause restrictions
+- **ERC20Permit**: Gasless approvals
+
+---
+
+## SECURITY ANALYSIS
+
+### ⚠️ CRITICAL ISSUES
+
+1. **UUPS UPGRADEABLE CONTRACT** 🚨
+   ```solidity
+   contract BTRToken is ... UUPSUpgradeable
+   ```
+   - Admin can upgrade implementation at ANY time
+   - No timelock or delay
+   - Can completely change token behavior
+   - **Users have ZERO protection against malicious upgrades**
+   - Same risk as DUSD proxy
+
+2. **BURNER_ROLE CAN BURN FROM ANY ADDRESS** 🚨
+   ```solidity
+   function burn(address account, uint256 amount) public onlyRole(BURNER_ROLE) {
+       _burn(account, amount);
+   }
+   ```
+   - BURNER_ROLE can burn tokens from ANY address without approval
+   - **This is a CRITICAL backdoor**
+   - Users cannot protect their funds
+   - Similar to DUSD's 0x83536352 function
+
+3. **PAUSABLE TRANSFERS**
+   ```solidity
+   function pause() external onlyRole(PAUSER_ROLE) whenNotPaused
+   ```
+   - PAUSER_ROLE can freeze all transfers
+   - Only whitelisted addresses can transfer when paused
+   - Users can be locked out of their funds
+
+4. **UNLIMITED MINTING (UP TO QUOTA)**
+   ```solidity
+   function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
+       require(totalSupply() + amount <= mintQuota, "minting exceeds max quota");
+       _mint(to, amount);
+   }
+   ```
+   - MINTER can mint up to 500M tokens
+   - Current supply: 62.7M (12.5% of quota used)
+   - Can mint 437M more tokens (7x current supply)
+   - Massive dilution risk
+
+5. **ADMIN CONTROL OVER ROLES**
+   ```solidity
+   function setMinter(address minter, bool enabled) public onlyRole(DEFAULT_ADMIN_ROLE)
+   function setBurner(address burner, bool enabled) public onlyRole(DEFAULT_ADMIN_ROLE)
+   function setWhitelister(address whitelister, bool enabled) public onlyRole(PAUSER_ROLE)
+   ```
+   - Admin can grant/revoke all roles
+   - Can add new minters/burners anytime
+   - No restrictions on role management
+
+### 🔍 CODE QUALITY
+
+**GOOD:**
+- OpenZeppelin Upgradeable contracts
+- Role-based access control
+- Mint quota limit (500M cap)
+- Max supply constant (1B)
+- ERC20Permit support
+- Whitelist for pause bypass
+
+**BAD:**
+- UUPS upgradeable (can change everything)
+- Burner can burn from any address
+- No timelock on upgrades
+- Pausable (can freeze users)
+
+---
+
+## ON-CHAIN STATE
+
+```
+Name: BTR token
+Symbol: BTR
+Total Supply: 62,748,844.828 BTR
+Mint Quota: 500,000,000 BTR (437M remaining)
+Max Supply: 1,000,000,000 BTR
+Paused: false
+Owner: 0x760eB3f1dbBF07Bf3132A28b8B4ACB458266FB4c
+```
+
+---
+
+## ATTACK VECTORS
+
+### ❌ NO USER-EXPLOITABLE BUGS
+
+Standard OZ implementation with proper access controls.
+
+### ⚠️ ADMIN ABUSE SCENARIOS
+
+1. **Burn User Funds** 🚨
+   - BURNER calls `burn(victim, amount)`
+   - Burns tokens from victim without approval
+   - Victim loses funds permanently
+   - **NO USER PROTECTION**
+
+2. **Malicious Upgrade** 🚨
+   - Admin deploys malicious implementation
+   - Upgrades via UUPS
+   - New implementation steals all funds
+   - No timelock or warning
+
+3. **Freeze All Transfers**
+   - PAUSER calls `pause()`
+   - All non-whitelisted transfers blocked
+   - Users cannot sell or move funds
+
+4. **Mint 437M More Tokens**
+   - MINTER mints up to quota (500M)
+   - 7x current supply dilution
+   - Price crashes
+
+5. **Whitelist Manipulation**
+   - Admin adds addresses to whitelist
+   - Those addresses bypass pause
+   - Can trade while others frozen
+
+---
+
+## COMPARISON TO PREVIOUS AUDITS
+
+| Feature | BTR | DUSD | ARK | wkeyDAO2 |
+|---------|-----|------|-----|----------|
+| Upgradeable | YES 🚨 | YES 🚨 | NO ✅ | NO ✅ |
+| Burn from any | YES 🚨 | YES 🚨 | NO ✅ | NO ✅ |
+| Pausable | YES | NO | NO | NO |
+| Mint Quota | 500M | Unlimited | Unlimited | Unlimited |
+| Governance | Active | Active | Renounced ✅ | Active |
+| Risk Level | 6/10 | 9/10 | 3/10 | 6/10 |
+
+---
+
+## FINAL VERDICT
+
+**Risk Rating: 6/10 - MEDIUM-HIGH RISK**
+
+BTR has TWO critical vulnerabilities:
+1. 🚨 **BURNER_ROLE can burn from any address** without approval
+2. 🚨 **UUPS upgradeable** - admin can change all logic
+
+Combined with pausable transfers and 7x dilution potential, this token requires complete trust in the admin team.
+
+### Summary of Risks:
+1. 🚨 **BURNER can burn from any address** (no approval needed)
+2. 🚨 **UUPS upgradeable** (can change everything)
+3. ⚠️ **Pausable** (can freeze transfers)
+4. ⚠️ **437M tokens can still be minted** (7x dilution)
+5. ⚠️ **Admin controls all roles**
+6. ⚠️ **No timelocks** or user protections
+
+### Recommendation:
+**HIGH CAUTION** - This is effectively a custodial token. Admin can:
+- Burn your tokens at any time
+- Freeze your funds
+- Mint 7x more supply
+- Upgrade to malicious implementation
+
+Better than DUSD (9/10) due to mint quota, but worse than ARK (3/10) due to upgradeability.
+
+---
+
+**Audit Date:** March 26, 2026  
+**Auditor:** Kiro AI Security Analysis  
+**Tools Used:** Manual Code Review, On-Chain Verification  
+**Status:** COMPLETE - CRITICAL VULNERABILITIES FOUND

package/BeamBridge-analysis.md

@@ -0,0 +1,226 @@
+# Beam Bridge (LayerZero OFT) - Security Analysis
+
+## Contract Type
+**LayerZero Omnichain Fungible Token (OFT) Bridge** - ProxyOFTWithFee
+
+This is a cross-chain bridge that allows transferring tokens between different blockchains using LayerZero protocol.
+
+## Key Components
+- **LayerZero Integration**: Cross-chain messaging
+- **Fee Mechanism**: Configurable fees per destination chain
+- **Dust Removal**: Handles decimal precision differences
+- **Failed Message Storage**: Retry mechanism for failed transfers
+- **Upgradeable**: Initializable pattern
+
+## Connection to Beam
+
+**YES** - This is the official Beam token bridge:
+- Bridges the BeamToken across chains
+- Uses LayerZero for cross-chain communication
+- Implements fee-on-transfer for bridging
+
+## Critical Findings
+
+### ❌ NOT EXPLOITABLE - Well-Designed Bridge
+
+This is a **professionally implemented LayerZero bridge** with proper security measures.
+
+### ✅ GOOD: Proper Access Controls
+
+```solidity
+function sendFrom(...) {
+    require(msg.sender == address(_from), 
+            Error('ProxyOFTWithFee: owner is not send caller'));
+    // Only token owner can bridge their tokens
+}
+```
+
+### ✅ GOOD: Trusted Remote Validation
+
+```solidity
+function lzReceive(...) {
+    require(msg.sender == _lzEndpoint);
+    require(keccak256(_srcAddress) == keccak256(trustedRemote));
+    // Only accepts messages from trusted sources
+}
+```
+
+### ✅ GOOD: Failed Message Handling
+
+```solidity
+function retryMessage(...) {
+    require(_@_storeFailedMessage_2669[...] != 0);
+    require(keccak256(_payload) == storedHash);
+    // Can retry failed cross-chain transfers
+}
+```
+
+### 🟡 MEDIUM: Centralized Fee Control
+
+**Issue**: Owner can set fees up to 100% per chain.
+
+```solidity
+function setFeeBp(uint16 _dstChainId, bool _enabled, uint16 _feeBp) {
+    require(msg.sender == _owner);
+    require(_feeBp <= 10000); // Max 100%
+    _@quoteOFTFee_4451[_dstChainId].field0_0_1 = _feeBp;
+}
+```
+
+**Impact**: Owner could set 100% bridge fee, effectively blocking transfers to specific chains.
+
+### 🟡 MEDIUM: Outbound Amount Tracking
+
+**Issue**: `_outboundAmount` tracks tokens locked in bridge. If accounting is wrong, could cause issues.
+
+```solidity
+function @_debitFrom_5456(...) {
+    _outboundAmount = _outboundAmount + amount;
+    require(_outboundAmount <= uint64.max);
+}
+
+function @_creditTo_5492(...) {
+    _outboundAmount = _outboundAmount - amount;
+}
+```
+
+**Risk**: If `_outboundAmount` becomes incorrect, `circulatingSupply()` will be wrong.
+
+### 🔵 LOW: Dust Handling
+
+```solidity
+function @_removeDust_3791(uint256 varg0) {
+    dust = varg0 % _@_sd2ld_3768;
+    cleanAmount = varg0 - dust;
+    // Dust is returned to sender
+}
+```
+
+**Good**: Properly handles decimal precision differences between chains.
+
+## Risk Assessment
+
+### For Users: 🟢 LOW RISK
+
+**This is a legitimate bridge** with:
+- ✅ Proper LayerZero integration
+- ✅ Access controls
+- ✅ Failed message retry
+- ✅ Dust handling
+- ⚠️ Centralized fee control (owner can change fees)
+
+### For Attackers: ❌ NOT EXPLOITABLE
+
+**Cannot**:
+- Bridge without owning tokens
+- Bypass trusted remote checks
+- Manipulate cross-chain messages
+- Steal locked tokens
+- Bypass fee mechanism
+
+### Centralization Risks: 🟡 MEDIUM
+
+**Owner Powers**:
+- Set bridge fees (0-100%)
+- Set trusted remotes
+- Set minimum gas limits
+- Change fee owner
+- Pause specific chains (via high fees)
+
+## Comparison to Other Beam Contracts
+
+| Contract | Type | Risk | Exploitable |
+|----------|------|------|-------------|
+| BeamToken | Governance Token | 🟡 MEDIUM | ❌ NO |
+| BeamBridge | LayerZero OFT | 🟢 LOW | ❌ NO |
+
+## How It Works
+
+### Bridging Flow
+
+**Sending Tokens**:
+```
+1. User calls sendFrom(amount, dstChain, recipient)
+2. Bridge takes fee (if configured)
+3. Bridge locks tokens (increases _outboundAmount)
+4. Bridge sends LayerZero message to destination
+5. Destination bridge receives message
+6. Destination bridge unlocks/mints tokens to recipient
+```
+
+**Receiving Tokens**:
+```
+1. LayerZero endpoint calls lzReceive()
+2. Bridge validates trusted remote
+3. Bridge decodes payload
+4. Bridge unlocks tokens (decreases _outboundAmount)
+5. Bridge transfers tokens to recipient
+```
+
+### Fee Mechanism
+
+```solidity
+// Per-chain fees
+chainIdToFeeBps[chainId] = (feeBp, enabled)
+
+// Default fee (if chain-specific not set)
+defaultFeeBp = X
+
+// Fee calculation
+if (chainFeeEnabled) {
+    fee = amount * chainFeeBp / 10000
+} else {
+    fee = amount * defaultFeeBp / 10000
+}
+```
+
+## Potential Issues (Theoretical)
+
+### 1. Fee Manipulation
+
+**Scenario**: Owner sets 100% fee for a chain
+**Impact**: Users cannot bridge to that chain
+**Likelihood**: LOW (would damage protocol reputation)
+
+### 2. Accounting Error
+
+**Scenario**: `_outboundAmount` becomes incorrect due to bug
+**Impact**: `circulatingSupply()` returns wrong value
+**Likelihood**: LOW (code appears correct)
+
+### 3. LayerZero Dependency
+
+**Scenario**: LayerZero protocol has vulnerability
+**Impact**: Bridge could be exploited
+**Likelihood**: LOW (LayerZero is audited)
+
+## Conclusion
+
+**Beam Bridge is a LEGITIMATE, WELL-DESIGNED cross-chain bridge**
+
+✅ **Strengths**:
+- Professional LayerZero implementation
+- Proper access controls
+- Failed message retry mechanism
+- Dust handling for decimal differences
+- Trusted remote validation
+
+⚠️ **Concerns**:
+- Centralized fee control (owner can set 100%)
+- Depends on LayerZero security
+- Owner has significant power
+
+❌ **NOT Exploitable**:
+- Cannot bypass access controls
+- Cannot manipulate cross-chain messages
+- Cannot steal locked tokens
+- Requires token ownership to bridge
+
+**Overall Assessment**: 🟢 **LOW RISK** - Professional implementation
+
+**Recommendation**: 
+- For users: SAFE TO USE (trust LayerZero + Beam team)
+- For attackers: NOT EXPLOITABLE
+- For investors: Check fee settings before bridging
+
+This is a legitimate part of the Beam ecosystem, NOT a scam like DSync.

package/BeamToken-analysis.md

@@ -0,0 +1,201 @@
+# BeamToken - Security Analysis
+
+## Contract Type
+**ERC20 Governance Token** with:
+- ERC20Votes (voting/delegation)
+- ERC20Permit (gasless approvals)
+- AccessControl (role-based permissions)
+- Mint/Burn capabilities
+
+## Key Roles
+- **DEFAULT_ADMIN_ROLE**: `0x0` - Can grant/revoke roles
+- **MINTER_ROLE**: `0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6`
+- **BURNER_ROLE**: `0x3c11d16cbaffd01df69ce1c404f6340ee057498f5f00246190ea54220576a848`
+
+## Connection to DSync?
+
+**UNLIKELY** - This appears to be a different token (BeamToken) based on:
+- Error messages reference "BeamToken"
+- Different architecture (governance token vs simple ERC20)
+- No hardcoded DSync addresses
+
+However, it could be part of the same ecosystem or a related project.
+
+## Critical Findings
+
+### ✅ GOOD: Self-Transfer Protection
+
+```solidity
+function @_transfer_4158(uint256 varg0, address varg1, address varg2) private {
+    require(this != varg1, Error('BeamToken._transfer: transfer to self not allowed'));
+    // ...
+}
+```
+
+**Good**: Prevents contract from transferring to itself (avoids locked funds).
+
+### ✅ GOOD: Mint to Self Protection
+
+```solidity
+function mint(address to, uint256 amount) public payable {
+    require(_@revokeRole_179[MINTER_ROLE].field0[msg.sender]);
+    require(this != to, Error('BeamToken.mint: unable to mint tokens to itself'));
+    // ...
+}
+```
+
+**Good**: Prevents minting to contract address.
+
+### 🟡 MEDIUM: Centralized Minting
+
+**Issue**: Anyone with MINTER_ROLE can mint unlimited tokens.
+
+```solidity
+function mint(address to, uint256 amount) public payable {
+    require(_@revokeRole_179[MINTER_ROLE].field0[msg.sender]);
+    @_mint_989(amount, to);
+    // No cap on total supply (except uint224 limit)
+}
+```
+
+**Impact**: 
+- Minters can inflate supply
+- No maximum supply cap
+- Centralization risk
+
+**Mitigation**: Only uint224 limit prevents overflow:
+```solidity
+require(uint224.max >= _totalSupply, 
+        Error('ERC20Votes: total supply risks overflowing votes'));
+```
+
+### 🟡 MEDIUM: Centralized Burning
+
+**Issue**: Anyone with BURNER_ROLE can burn tokens from ANY address.
+
+```solidity
+function burn(address account, uint256 amount) public payable {
+    require(_@revokeRole_179[BURNER_ROLE].field0[msg.sender]);
+    @_burn_1061(amount, account);  // Burns from 'account', not msg.sender!
+}
+```
+
+**Impact**:
+- Burner can destroy anyone's tokens
+- No approval required
+- Centralization risk
+
+**This is UNUSUAL** - Most tokens only allow burning your own tokens or with approval.
+
+### 🔵 LOW: Domain Separator Hardcoded for Chain 1
+
+```solidity
+function @_domainSeparatorV4_2843() private {
+    if (CHAINID() != 1) {
+        // Calculate dynamically
+        return keccak256(...);
+    } else {
+        return 0x80f6c502ddcafd105fafa433e909f45b207b3b1e9c638eb3081aa80cc0f9ce28;
+    }
+}
+```
+
+**Issue**: Hardcoded for Ethereum mainnet (chain ID 1). If deployed on other chains, uses dynamic calculation.
+
+**Impact**: Minor - just an optimization for mainnet.
+
+## Is This Exploitable?
+
+### ❌ NOT Exploitable by Outsiders
+
+**Why**:
+1. **Mint requires MINTER_ROLE** - Can't mint without permission
+2. **Burn requires BURNER_ROLE** - Can't burn without permission
+3. **Standard ERC20** - No transfer restrictions or honeypot mechanisms
+4. **Good access control** - Role-based permissions work correctly
+
+### ⚠️ Exploitable by Role Holders
+
+**If you have MINTER_ROLE**:
+- Mint unlimited tokens to yourself
+- Dilute other holders
+- Dump on market
+
+**If you have BURNER_ROLE**:
+- Burn anyone's tokens
+- Destroy competitor holdings
+- Manipulate supply
+
+**If you have DEFAULT_ADMIN_ROLE**:
+- Grant yourself MINTER_ROLE and BURNER_ROLE
+- Complete control over token
+
+## Risk Assessment
+
+### For Regular Users: 🟡 MEDIUM RISK
+
+**Risks**:
+- Minters can inflate supply
+- Burners can destroy your tokens
+- Centralized control
+
+**Protections**:
+- Standard ERC20 (no honeypot)
+- Self-transfer protection
+- Voting/governance capabilities
+
+### For Attackers: ❌ NOT EXPLOITABLE
+
+**Cannot**:
+- Mint without MINTER_ROLE
+- Burn without BURNER_ROLE
+- Bypass access control
+- Exploit transfer logic
+
+### For Role Holders: ✅ FULL CONTROL
+
+**Can**:
+- Mint unlimited tokens (MINTER_ROLE)
+- Burn anyone's tokens (BURNER_ROLE)
+- Grant/revoke roles (DEFAULT_ADMIN_ROLE)
+
+## Comparison to DSync
+
+| Feature | BeamToken | DSync |
+|---------|-----------|-------|
+| Type | Governance Token | Simple ERC20 |
+| Sell Tax | None | 60% |
+| Blacklist | None | Yes (unlimited) |
+| Mint | Role-based | None |
+| Burn | Role-based (any address) | None |
+| Voting | Yes | No |
+| Honeypot | No | Yes (sell tax) |
+| Risk Level | 🟡 MEDIUM | 🔴 HIGH |
+
+## Conclusion
+
+**BeamToken is a STANDARD GOVERNANCE TOKEN** with:
+
+✅ **Good**:
+- No honeypot mechanisms
+- No sell tax
+- Self-transfer protection
+- Standard ERC20 implementation
+- Voting/delegation capabilities
+
+⚠️ **Concerns**:
+- Centralized minting (unlimited)
+- Centralized burning (can burn anyone's tokens)
+- Role holders have significant power
+
+❌ **Not Exploitable**:
+- Requires privileged roles
+- Standard access control
+- No external attack vectors
+
+**Overall**: This is a legitimate governance token with centralization risks, NOT a scam like DSync. However, users should trust the team holding MINTER_ROLE and BURNER_ROLE.
+
+**Recommendation**: 
+- For users: MEDIUM RISK - Depends on who holds roles
+- For attackers: NOT EXPLOITABLE - Need privileged access
+- For investors: Check who has MINTER_ROLE and BURNER_ROLE before investing