Ethereum Virtual Machine Deep Dive — EVM Architecture, Gas, and Bytecode

# EVM opcode reference and gas costs
OPCODES = {
    # Arithmetic
    0x01: ("ADD", 3, "Add top two stack items"),
    0x02: ("MUL", 5, "Multiply top two stack items"),
    0x03: ("SUB", 3, "Subtract top two stack items"),

    # Stack manipulation
    0x50: ("POP", 2, "Remove top stack item"),
    0x51: ("MLOAD", 3, "Load word from memory"),
    0x52: ("MSTORE", 3, "Store word to memory"),

    # Storage
    0x54: ("SLOAD", 100, "Load word from storage (warm)"),
    0x55: ("SSTORE", 20000, "Store word to storage (cold)"),

    # Environment
    0x31: ("BALANCE", 700, "Get balance of address"),
    0x34: ("CALLVALUE", 2, "Get value sent with call"),
    0x35: ("CALLDATALOAD", 3, "Load calldata word"),

    # Control flow
    0x56: ("JUMP", 8, "Jump to program counter"),
    0x57: ("JUMPI", 10, "Conditional jump"),
    0xFD: ("REVERT", 0, "Revert execution"),

    # Contract creation
    0xF0: ("CREATE", 32000, "Create new contract"),
    0xFF: ("SELFDESTRUCT", 5000, "Destroy contract"),
}

def estimate_gas(bytecode_ops: list) -> dict:
    """Estimate gas cost for a sequence of EVM opcodes."""
    total_gas = 0
    breakdown = []

    for op in bytecode_ops:
        if op in OPCODES:
            name, gas, desc = OPCODES[op]
            total_gas += gas
            breakdown.append(f"  {name} (0x{op:02x}): {gas} gas — {desc}")
        else:
            breakdown.append(f"  Unknown opcode 0x{op:02x}: skipping")

    return {"total_gas": total_gas, "breakdown": breakdown}

# Example: Simple storage write sequence
# PUSH1 0x42, PUSH1 0x00, SSTORE
simple_contract = [0x60, 0x42, 0x60, 0x00, 0x55]

result = estimate_gas(simple_contract)
print(f"Total gas: {result['total_gas']}")
print("Breakdown:")
for line in result['breakdown']:
    print(line)

// SimpleStorage.sol
pragma solidity ^0.8.19;

contract SimpleStorage {
    uint256 public storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

# Simulating EVM bytecode execution for SimpleStorage.set(42)
import hashlib

class EVMSimulator:
    def __init__(self):
        self.stack = []
        self.memory = bytearray()
        self.storage = {}
        self.pc = 0
        self.gas = 100000
        self.calldata = b''

    def execute_set(self, value: int):
        """Simulate calling set(uint256) with a given value."""
        # Function selector: keccak256("set(uint256)")[:4]
        func_sig = hashlib.sha3_256(b"set(uint256)").digest()[:4]

        # Calldata: 4-byte selector + 32-byte argument
        self.calldata = func_sig + value.to_bytes(32, 'big')
        print(f"Calldata: {self.calldata.hex()}")

        # Simplified execution of set(x):
        # 1. Load argument from calldata (offset 4, 32 bytes)
        arg = int.from_bytes(self.calldata[4:36], 'big')
        print(f"  Argument value: {arg}")

        # 2. SSTORE to slot 0
        slot = 0
        old_value = self.storage.get(slot, 0)
        self.storage[slot] = arg
        self.gas -= 20000  # cold SSTORE cost
        print(f"  SSTORE slot {slot}: {old_value} -> {arg}")

        # 3. Event log (simplified)
        print(f"  Gas remaining: {self.gas}")

        return True

    def execute_get(self):
        """Simulate calling get() — reads from storage."""
        func_sig = hashlib.sha3_256(b"get()").digest()[:4]
        self.calldata = func_sig

        # SLOAD from slot 0
        value = self.storage.get(0, 0)
        self.gas -= 2100  # cold SLOAD cost

        # Return value in memory
        result = value.to_bytes(32, 'big')
        print(f"get() returns: {value}")
        print(f"Return data: 0x{result.hex()}")
        return result

# Run the simulation
evm = EVMSimulator()
evm.execute_set(42)
print()
evm.execute_get()

# Gas cost breakdown for a typical transaction
def calculate_tx_gas(
    calldata_bytes: int,
    storage_writes: int,
    storage_reads: int,
    contract_creation: bool = False
) -> dict:
    """Calculate approximate gas cost for an Ethereum transaction."""
    costs = {
        "base_tx": 21000,                          # base transaction cost
        "calldata_zero": calldata_bytes * 4,       # zero byte: 4 gas
        "calldata_nonzero": calldata_bytes * 16,   # non-zero byte: 16 gas
        "sstore_cold": storage_writes * 22100,     # first write to slot
        "sstore_warm": storage_writes * 2900,      # subsequent write to same slot
        "sload_cold": storage_reads * 2100,        # first read from slot
        "sload_warm": storage_reads * 100,         # subsequent read from same slot
    }

    if contract_creation:
        costs["creation"] = 53000  # base contract creation cost

    total = sum(costs.values())
    costs["total"] = total
    return costs

# Example: Calling set(42) on SimpleStorage
gas = calculate_tx_gas(
    calldata_bytes=36,     # 4 selector + 32 argument
    storage_writes=1,      # one SSTORE
    storage_reads=0,
    contract_creation=False
)

print("Gas cost breakdown for set(42):")
for item, cost in gas.items():
    print(f"  {item}: {cost}")

print(f"\nTotal gas: {gas['total']}")
print(f"At 50 gwei, 1 ETH = $3000:")
eth_cost = gas['total'] * 50 * 1e-9
usd_cost = eth_cost * 3000
print(f"  Cost: {eth_cost:.6f} ETH (${usd_cost:.2f})")

import hashlib

def encode_function_call(func_name: str, param_types: list, params: list) -> str:
    """Encode a Solidity function call according to the ABI spec."""
    # Step 1: Build function signature
    sig = f"{func_name}({','.join(param_types)})"

    # Step 2: Keccak-256 hash, take first 4 bytes
    selector = hashlib.sha3_256(sig.encode()).digest()[:4]

    # Step 3: Encode parameters (simplified — handles uint256 only)
    encoded_params = b''
    for i, param in enumerate(params):
        encoded_params += param.to_bytes(32, 'big')

    result = selector.hex() + encoded_params.hex()
    return "0x" + result

# Example encodings
call1 = encode_function_call("transfer", ["address", "uint256"],
                             [0x1234567890abcdef1234567890abcdef12345678, 1000])
print(f"transfer(address,uint256):")
print(f"  {call1}")
print()

call2 = encode_function_call("balanceOf", ["address"],
                             [0x1234567890abcdef1234567890abcdef12345678])
print(f"balanceOf(address):")
print(f"  {call2}")