ADDRESS (0x30)

[]

address (uint160 as uint256)

stack.push(execution_context.address)

import { address } from '@tevm/voltaire/evm/context';
import { createFrame } from '@tevm/voltaire/evm/Frame';
import * as Address from '@tevm/voltaire/Address';

// Get current contract address
const contractAddr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
const frame = createFrame({
  address: contractAddr,
  stack: []
});

const err = address(frame);

console.log(frame.stack.length); // 1
console.log(frame.stack[0]); // 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbn

contract Example {
    address public self;

    constructor() {
        // Store contract's own address
        assembly {
            let addr := address()
            sstore(0, addr)
        }
    }

    function getAddress() public view returns (address) {
        return address(this);  // Compiler uses ADDRESS opcode
    }
}

contract Implementation {
    function whoAmI() public view returns (address) {
        return address(this);
    }
}

contract Proxy {
    Implementation impl;

    function regularCall() public view returns (address) {
        // Returns Implementation's address
        return impl.whoAmI();
    }

    function delegateCall() public returns (address) {
        // Returns Proxy's address (context is preserved)
        (bool success, bytes memory data) = address(impl).delegatecall(
            abi.encodeWithSignature("whoAmI()")
        );
        require(success);
        return abi.decode(data, (address));
    }
}

contract Proxy {
    address public implementation;

    fallback() external payable {
        address impl = implementation;
        assembly {
            // Load calldata
            calldatacopy(0, 0, calldatasize())

            // Delegate to implementation
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)

            // In implementation: address() returns Proxy's address

            // Return data
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

contract SelfDestructible {
    function destroy() public {
        // Send remaining balance to this contract's address
        selfdestruct(payable(address(this)));
    }
}

contract TokenSwap {
    function swap(address token, uint256 amount) public {
        // Ensure not swapping with the swap contract itself
        require(token != address(this), "Cannot swap with self");
        // ...
    }
}

contract PaymentReceiver {
    receive() external payable {
        // Log payment to this contract
        emit PaymentReceived(msg.sender, address(this), msg.value);
    }
}

// ADDRESS (0x30) - Contract being executed
address(this)

// CALLER (0x33) - Immediate caller
msg.sender

// ORIGIN (0x32) - Transaction originator
tx.origin

User (0xAAA) → Contract A (0xBBB) → Contract B (0xCCC)

In Contract B:
- address(this) = 0xCCC (Contract B's address)
- msg.sender = 0xBBB (Contract A called us)
- tx.origin = 0xAAA (User started the transaction)

contract Vulnerable {
    address public owner;

    function upgrade(address newImpl) public {
        // DANGEROUS: In delegatecall, address(this) is caller's address
        // An attacker can delegatecall to malicious code
        require(msg.sender == owner);
        (bool success,) = newImpl.delegatecall(msg.data);
        require(success);
    }
}

contract Safe {
    // Store contract's own address for validation
    address immutable self = address(this);

    function initialize() public {
        // Prevent initialization in delegatecall context
        require(address(this) == self, "Cannot delegatecall initialize");
        // ...
    }
}

// Address is 160 bits, stored as uint256
const maxAddr = (1n << 160n) - 1n;
const frame = createFrame({ address: maxAddr });
address(frame);

console.log(frame.stack[0]); // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn

// Zero address is valid
const frame = createFrame({ address: 0x0n });
address(frame);

console.log(frame.stack[0]); // 0x0n

// Stack at maximum capacity
const frame = createFrame({
  address: 0x123n,
  stack: new Array(1024).fill(0n)
});

const err = address(frame);
console.log(err); // { type: "StackOverflow" }

// Insufficient gas
const frame = createFrame({
  address: 0x123n,
  gasRemaining: 1n
});

const err = address(frame);
console.log(err); // { type: "OutOfGas" }