LOG0 (0xa0)

offset (top)
length

(none)

data = memory[offset : offset + length]
log_entry = { address: msg.sender, topics: [], data: data }
append log_entry to logs

new_memory_size = (ceil((offset + length) / 32)) * 32

function badLog() external view {
    // Reverts: StaticCallViolation
}

import { handler_0xa0_LOG0 } from '@tevm/voltaire/evm/log';

const frame = createFrame({
  address: "0x1234567890123456789012345678901234567890",
  stack: [0n, 0n],  // offset=0, length=0
  gasRemaining: 1000000n,
});

const err = handler_0xa0_LOG0(frame);
console.log(err); // null (success)
console.log(frame.logs); // [{ address, topics: [], data: Uint8Array(0) }]
console.log(frame.gasRemaining); // 999625n (1000000 - 375)

const frame = createFrame({
  address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  memory: new Map([
    [0, 0xde], [1, 0xad], [2, 0xbe], [3, 0xef]
  ]),
  stack: [0n, 4n],  // offset=0, length=4
  gasRemaining: 1000000n,
});

handler_0xa0_LOG0(frame);

const log = frame.logs[0];
console.log(log.data); // Uint8Array(4) [0xde, 0xad, 0xbe, 0xef]
console.log(frame.gasRemaining); // 999617n (375 base + 32 memory + 32 data)

event SimpleLog(string message);

contract Logger {
  function log(string memory msg) public {
    emit SimpleLog(msg);  // Compiler generates LOG0
  }
}

// Usage
Logger logger = new Logger();
logger.log("Hello, world!");
// Transaction receipt includes log with empty topics

event Transfer(uint256 indexed id, address from, address to, uint256 value);

// If only 'id' is indexed, Solidity uses LOG1
// But we can emit an event with all non-indexed params using LOG0:

event Data(string text, uint256 amount, bytes payload);

contract DataLogger {
  function logData(string memory text, uint256 amount, bytes memory payload) public {
    emit Data(text, amount, payload);  // LOG0 (no indexed params)
  }
}

const frame = createFrame({ stack: [100n, 0n] });
handler_0xa0_LOG0(frame);
// Valid: logs empty data, no memory expansion

const frame = createFrame({
  stack: [0n, 10000n],
  gasRemaining: 100000n,
});
handler_0xa0_LOG0(frame);
// Gas: 375 + 80000 (data) + memory expansion
// Result: OutOfGas (insufficient gas)

const frame = createFrame({
  stack: [0n, 1000n],
  memory: new Map(),  // Empty
  gasRemaining: 100000n,
});
handler_0xa0_LOG0(frame);
// Memory fills with zeros from current_size to 1000
// log.data = Uint8Array(1000) filled with zeros

const frame = createFrame({ stack: [0n] });  // Only 1 item
const err = handler_0xa0_LOG0(frame);
console.log(err); // { type: "StackUnderflow" }

const frame = createFrame({
  stack: [0n, 0n],
  gasRemaining: 374n,  // Not enough for base cost
});
const err = handler_0xa0_LOG0(frame);
console.log(err); // { type: "OutOfGas" }

event Minted(uint256 amount);
event Burned(uint256 amount);

contract Token {
  function mint(uint256 amount) public {
    totalSupply += amount;
    emit Minted(amount);  // LOG0
  }

  function burn(uint256 amount) public {
    totalSupply -= amount;
    emit Burned(amount);  // LOG0
  }
}

event ConfigUpdated(string newConfig);

contract Config {
  function updateConfig(string memory newConfig) public {
    config = newConfig;
    emit ConfigUpdated(newConfig);  // LOG0 (newConfig is non-indexed)
  }
}

event StatusChanged(string status);

contract Service {
  function shutdown() public {
    isActive = false;
    emit StatusChanged("OFFLINE");  // LOG0
  }
}

// INEFFICIENT: No topic filtering
event EventWithoutTopics(address user, uint256 amount);

// BETTER: Use indexed parameters
event EventWithTopics(address indexed user, uint256 amount);

function badView() external view {
  emit SomeEvent();  // Reverts: cannot log in view context
}

contract Caller {
  function staticCallBad(address target) public {
    target.staticcall(abi.encodeCall(Logger.log, ()));  // Reverts
  }
}

// Be aware of what's written to memory
function logUninitialized() public {
  // If no data written to memory[0:100], emits 100 zero bytes
  emit Data();
}

import { describe, it, expect } from 'vitest';
import { handler_0xa0_LOG0 } from './0xa0_LOG0.js';

describe('LOG0 (0xa0)', () => {
  it('emits log with empty data', () => {
    const frame = createFrame({
      stack: [0n, 0n],
      gasRemaining: 1000000n,
    });
    const err = handler_0xa0_LOG0(frame);
    expect(err).toBeNull();
    expect(frame.logs).toHaveLength(1);
    expect(frame.logs[0].topics).toEqual([]);
    expect(frame.gasRemaining).toBe(999625n);
  });

  it('reads data from memory', () => {
    const frame = createFrame({
      memory: new Map([[0, 0xde], [1, 0xad], [2, 0xbe], [3, 0xef]]),
      stack: [0n, 4n],
      gasRemaining: 1000000n,
    });
    handler_0xa0_LOG0(frame);
    const log = frame.logs[0];
    expect(log.data).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
  });

  it('returns WriteProtection in static context', () => {
    const frame = createFrame({ isStatic: true, stack: [0n, 0n] });
    const err = handler_0xa0_LOG0(frame);
    expect(err).toEqual({ type: "WriteProtection" });
  });

  it('returns StackUnderflow with insufficient stack', () => {
    const frame = createFrame({ stack: [0n] });
    const err = handler_0xa0_LOG0(frame);
    expect(err).toEqual({ type: "StackUnderflow" });
  });

  it('returns OutOfGas when insufficient gas', () => {
    const frame = createFrame({
      stack: [0n, 0n],
      gasRemaining: 374n,
    });
    const err = handler_0xa0_LOG0(frame);
    expect(err).toEqual({ type: "OutOfGas" });
  });

  it('expands memory correctly', () => {
    const frame = createFrame({
      stack: [0n, 100n],
      gasRemaining: 1000000n,
    });
    handler_0xa0_LOG0(frame);
    expect(frame.memorySize).toBe(128); // ceil(100/32)*32
  });
});