contract TokenVault {
    IERC20 public token;
    
    // External call to another contract
    function deposit(uint amount) external {
        // CALL opcode used here
        bool success = token.transferFrom(msg.sender, address(this), amount);
        require(success, "Transfer failed");
    }
    
    // External call via this keyword
    function checkBalance() external view returns (uint) {
        // Forces external call even within same contract
        return this.getBalance();
    }
    
    // Will be called externally via this.getBalance()
    function getBalance() public view returns (uint) {
        return token.balanceOf(address(this));
    }
}

contract Proxy {
    address public implementation;
    uint public value;
    
    // Delegatecall preserves Proxy's storage
    fallback() external payable {
        address impl = implementation;
        assembly {
            // Copy calldata
            calldatacopy(0, 0, calldatasize())
            
            // DELEGATECALL to implementation
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
            
            // Copy return data
            returndatacopy(0, 0, returndatasize())
            
            // Return or revert
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

contract Implementation {
    address public implementation;  // Same storage slot as Proxy!
    uint public value;              // Same storage slot as Proxy!
    
    function setValue(uint _value) external {
        value = _value;  // Updates PROXY's storage, not Implementation's!
    }
}

contract Oracle {
    // View function—automatically uses STATICCALL when called externally
    function getPrice() external view returns (uint) {
        return 1500 * 1e18;  // Cannot modify state
    }
}

contract PriceConsumer {
    Oracle oracle;
    
    function checkPrice() external view returns (uint) {
        // STATICCALL ensures oracle cannot modify state
        return oracle.getPrice();
    }
    
    // This would fail—view function cannot call non-view
    function badExample() external view returns (uint) {
        // oracle.updatePrice();  // Compilation error!
        return 0;
    }
}