// Example: Identical code deploys on both Ethereum and Base
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract BaseToken is ERC20 {
    constructor() ERC20("BaseToken", "BASE") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
    
    // Inherits Ethereum security standards
    // No code modification needed for cross-deployment
}

// Solana program structure - fundamentally different paradigm
use anchor_lang::prelude::*;

declare_id!("YourProgramID");

#[program]
pub mod solana_token {
    use super::*;
    
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        // Account-based model vs Ethereum's storage model
        // Requires understanding Solana-specific concepts
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = user, space = 8 + 8)]
    pub token_account: Account<'info, TokenAccount>,
    // Rent-exempt accounts, different memory model
}

// Solana: Users must bid for transaction priority
let ix = Instruction {
    program_id: system_program::id(),
    accounts: vec![...],
    data: vec![],
};

// Priority fee can spike 100x during high demand
let compute_budget_ix = ComputeBudgetInstruction::set_compute_unit_price(
    5000 // microlamports per compute unit - can reach 50,000+ in meme launches
);

// Base: First-come-first-served sequencing (anti-MEV)
// No priority fees in standard transactions
// Sequencer controlled by Coinbase (centralized but predictable)

contract FairLaunch {
    uint256 public constant MAX_PER_WALLET = 1000e18;
    mapping(address => bool) public hasMinted;
    
    function mint() external {
        require(!hasMinted[msg.sender], "Already minted");
        require(totalSupply() < MAX_SUPPLY, "Sold out");
        
        hasMinted[msg.sender] = true;
        _mint(msg.sender, MAX_PER_WALLET);
        // Bots cannot frontrun due to sequencer ordering
    }
}

// ERC-404: Pioneered on Base/Ethereum, demonstrates sophistication
// Combines ERC-20 (fungible) + ERC-721 (NFT) properties

abstract contract ERC404 is IERC20, IERC721 {
    mapping(uint256 => address) internal _owners;
    mapping(address => uint256) internal _balances;
    
    // When you sell tokens, NFT burns
    function transfer(address to, uint256 amount) public override returns (bool) {
        _balances[msg.sender] -= amount;
        _balances[to] += amount;
        
        // Fractional NFT logic
        uint256 tokensPerNFT = 10**decimals();
        if (_balances[msg.sender] < tokensPerNFT && _ownsNFT(msg.sender)) {
            _burnNFT(msg.sender);
        }
        if (_balances[to] >= tokensPerNFT && !_ownsNFT(to)) {
            _mintNFT(to);
        }
        
        return true;
    }
}

// Most Solana tokens use SPL Token standard - very template-driven
use spl_token::instruction::initialize_mint;

// Literally 5 lines to deploy
// No custom logic needed
// Anyone can deploy in 10 minutes

// Even "meme" tokens on Base often include:
contract BasedToken is ERC20, Ownable, ReentrancyGuard {
    uint256 public constant MAX_SUPPLY = 1_000_000_000e18;
    uint256 public constant TAX_RATE = 200; // 2%
    address public liquidityPool;
    
    mapping(address => bool) public isExcludedFromTax;
    
    // Anti-bot mechanisms
    uint256 public tradingEnabledAt;
    mapping(address => uint256) private _lastTransfer;
    
    function _transfer(address from, address to, uint256 amount) 
        internal 
        override 
        nonReentrant // Security standard
    {
        require(
            block.timestamp >= tradingEnabledAt || 
            isExcludedFromTax[from], 
            "Trading not enabled"
        );
        require(
            block.timestamp >= _lastTransfer[from] + 2 seconds,
            "Transfer cooldown" // Anti-sandwich attack
        );
        
        // Tax logic for liquidity
        uint256 taxAmount = 0;
        if (!isExcludedFromTax[from] && to == liquidityPool) {
            taxAmount = amount * TAX_RATE / 10000;
        }
        
        super._transfer(from, to, amount - taxAmount);
        if (taxAmount > 0) {
            super._transfer(from, address(this), taxAmount);
        }
        
        _lastTransfer[from] = block.timestamp;
    }
}

// Common pattern: Liquidity locked in verifiable contract
interface IUniswapV2Pair {
    function balanceOf(address) external view returns (uint256);
}

contract LiquidityLocker {
    IUniswapV2Pair public lpToken;
    uint256 public unlockTime;
    address public owner;
    
    constructor(address _lpToken, uint256 _lockDuration) {
        lpToken = IUniswapV2Pair(_lpToken);
        unlockTime = block.timestamp + _lockDuration;
        owner = msg.sender;
    }
    
    function withdraw() external {
        require(msg.sender == owner, "Not owner");
        require(block.timestamp >= unlockTime, "Still locked");
        lpToken.transfer(owner, lpToken.balanceOf(address(this)));
    }
}
// Easily verifiable on Basescan - transparency builds trust

// Solana's account model enables subtle drainage attacks
// Token accounts can have unexpected authority transfers

#[derive(Accounts)]
pub struct TransferAuthority<'info> {
    #[account(mut)]
    pub token_account: Account<'info, TokenAccount>,
    // If authority isn't checked properly, malicious update possible
    pub new_authority: AccountInfo<'info>,
}

// Attack: Developer retains mint/freeze authority after "renouncing"
// Harder to verify due to Solana's account architecture

// Coinbase Wallet SDK - seamless Base integration
import { CoinbaseWallet } from '@coinbase/wallet-sdk';

const wallet = new CoinbaseWallet({
  appName: 'My dApp',
  appLogoUrl: 'https://example.com/logo.png',
  defaultNetwork: 'base', // Native support
  defaultChainId: 8453
});

// One-click onboarding from Coinbase exchange
// 100M+ potential users with existing accounts

// Proposed: Permissionless sequencer participation
contract SequencerRegistry {
    struct Sequencer {
        address operator;
        uint256 stake;
        uint256 performance;
    }
    
    mapping(address => Sequencer) public sequencers;
    
    function registerSequencer() external payable {
        require(msg.value >= 1000 ether, "Insufficient stake");
        sequencers[msg.sender] = Sequencer({
            operator: msg.sender,
            stake: msg.value,
            performance: 100
        });
    }
    
    // Rotation based on performance metrics
    // Reduces centralization concern
}

// Bonding curve with anti-snipe
contract FairLaunchToken is ERC20 {
    uint256 public constant INITIAL_PRICE = 0.0001 ether;
    uint256 public constant PRICE_INCREMENT = 0.00001 ether;
    uint256 public soldTokens;
    
    function buy() external payable {
        uint256 currentPrice = INITIAL_PRICE + 
            (soldTokens / 1000) * PRICE_INCREMENT;
        uint256 tokenAmount = msg.value / currentPrice;
        
        require(tokenAmount <= 1000e18, "Max 1000 per tx");
        
        soldTokens += tokenAmount;
        _mint(msg.sender, tokenAmount);
    }
    // Gradual price discovery, no frontrun advantage
}

// Instant liquidity, vulnerable to bots
pub fn buy_token(ctx: Context<Buy>, amount: u64) -> Result<()> {
    let price = calculate_price(ctx.accounts.bonding_curve.supply);
    // No per-transaction limits
    // Priority fee determines execution order
    // Bots with high fees execute first
    
    transfer_sol(ctx.accounts.buyer, ctx.accounts.vault, price * amount)?;
    mint_tokens(ctx.accounts.buyer, amount)?;
    Ok(())
}