COINBASE (0x41)

(none)

coinbase_address (as u256)

stack.push(block.coinbase as u256)

Address: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
As u256: 0x000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f0beb
         └─ 12 zero bytes ─┘└────────── 20 address bytes ──────────┘

import { coinbase } from '@tevm/voltaire/evm/block';
import { createFrame } from '@tevm/voltaire/evm/Frame';

const minerAddress = new Uint8Array([
  0x74, 0x2d, 0x35, 0xcc, 0x66, 0x34, 0xc0, 0x53,
  0x29, 0x25, 0xa3, 0xb8, 0x44, 0xbc, 0x9e, 0x75,
  0x95, 0xf0, 0xbe, 0xb0
]);

const frame = createFrame({
  stack: [],
  blockContext: {
    block_coinbase: minerAddress
  }
});

const err = coinbase(frame);
console.log(frame.stack); // [0x742d35cc6634c0532925a3b844bc9e7595f0beb0]
console.log(frame.gasRemaining); // Original - 2

// Execute COINBASE
coinbase(frame);
const coinbaseU256 = frame.stack[0];

// Convert u256 back to address
const addressBytes = new Uint8Array(20);
for (let i = 0; i < 20; i++) {
  addressBytes[19 - i] = Number((coinbaseU256 >> BigInt(i * 8)) & 0xFFn);
}

console.log(addressBytes); // Original 20-byte address

import { address } from '@tevm/voltaire/evm/context';

// Get coinbase
coinbase(frame);
const coinbaseAddr = frame.stack[0];

// Get current contract address
address(frame);
const currentAddr = frame.stack[0];

// Check if contract is coinbase
const isCoinbase = coinbaseAddr === currentAddr;

contract MinerTip {
    // Send tip directly to block producer
    function tipMiner() external payable {
        require(msg.value > 0, "No tip sent");
        payable(block.coinbase).transfer(msg.value);
    }
}

contract OnlyMiner {
    modifier onlyMiner() {
        require(msg.sender == block.coinbase, "Only miner can call");
        _;
    }

    function privilegedOperation() external onlyMiner {
        // Only callable by block producer
    }
}

contract AntiMEV {
    // Ensure transaction is included by specific validator
    function protectedSwap(address expectedCoinbase) external {
        require(block.coinbase == expectedCoinbase, "Wrong validator");
        // Execute swap
    }
}

contract ValidatorGated {
    mapping(address => bool) public approvedValidators;

    modifier onlyApprovedValidator() {
        require(approvedValidators[block.coinbase], "Validator not approved");
        _;
    }

    function sensitiveOperation() external onlyApprovedValidator {
        // Only execute if produced by approved validator
    }
}

contract ValidatorTracker {
    struct BlockInfo {
        uint256 blockNumber;
        address validator;
        uint256 timestamp;
    }

    BlockInfo[] public history;

    function recordBlock() external {
        history.push(BlockInfo({
            blockNumber: block.number,
            validator: block.coinbase,
            timestamp: block.timestamp
        }));
    }
}

// Coinbase = Miner's address
contract MinerReward {
    // Miners could redirect rewards
    function() external payable {
        // Miner can set coinbase to this contract
        // to receive rewards + fees here
    }
}

// Coinbase = Validator's fee recipient
contract ValidatorOperator {
    mapping(address => address) public feeRecipients;

    // Validators configure their fee recipient
    function setFeeRecipient(address recipient) external {
        feeRecipients[msg.sender] = recipient;
    }
}

// RISKY: Single point of failure
contract CentralizedControl {
    function privilegedAction() external {
        require(msg.sender == block.coinbase, "Only validator");
        // Critical operation controlled by single validator
    }
}

// VULNERABLE: Validators can coordinate
contract CoinbaseDependent {
    mapping(address => uint256) public validatorScores;

    function rewardValidator() external {
        validatorScores[block.coinbase] += 1;
    }
}

contract MEVAware {
    // Pay validators to include transaction
    function urgentSwap() external payable {
        uint256 validatorBribe = msg.value / 10; // 10% to validator
        payable(block.coinbase).transfer(validatorBribe);

        // Execute swap with remaining value
    }
}

// VULNERABLE: Validator could exist on multiple chains
contract CrossChainVulnerable {
    function authenticate() external view returns (bool) {
        return msg.sender == block.coinbase; // Same validator on different chain!
    }
}

// SAFE: Include chain ID
contract CrossChainSafe {
    function authenticate(uint256 expectedChain) external view returns (bool) {
        require(block.chainid == expectedChain, "Wrong chain");
        return msg.sender == block.coinbase;
    }
}

// Coinbase set to 0x0000...0000
const frame = createFrame({
  blockContext: {
    block_coinbase: new Uint8Array(20) // All zeros
  }
});

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

// Coinbase = 0xFFFF...FFFF
const frame = createFrame({
  blockContext: {
    block_coinbase: new Uint8Array(20).fill(0xFF)
  }
});

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

// Stack already full (1024 items)
const frame = createFrame({
  stack: new Array(1024).fill(0n),
  blockContext: { block_coinbase: minerAddress }
});

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

// Insufficient gas
const frame = createFrame({
  gasRemaining: 1n,
  blockContext: { block_coinbase: minerAddress }
});

const err = coinbase(frame);
console.log(err); // { type: "OutOfGas" }
console.log(frame.gasRemaining); // 0n