LOG3 (0xa3)

offset (top)
length
topic0
topic1
topic2

(none)

data = memory[offset : offset + length]
topic0 = stack.pop()
topic1 = stack.pop()
topic2 = stack.pop()
log_entry = { address: msg.sender, topics: [topic0, topic1, topic2], data: data }
append log_entry to logs

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

const frame = createFrame({
  address: "0x1234567890123456789012345678901234567890",
  stack: [
    0xccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccn,  // topic2 (item)
    0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn,  // topic1 (seller)
    0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan,  // topic0 (buyer)
    0n,  // length
    0n,  // offset
  ],
  gasRemaining: 1000000n,
});

const err = handler_0xa3_LOG3(frame);
console.log(err); // null (success)
console.log(frame.logs[0].topics.length); // 3
console.log(frame.gasRemaining);
// 999000n - 375 (base) - 1125 (3 topics)

const frame = createFrame({
  address: "0xmarketplace",
  memory: new Map([
    [0, 0x00], [1, 0x00], [2, 0x01], [3, 0x00],  // Price: 256 wei
  ]),
  stack: [
    0xitem_id,
    0xseller,
    0xbuyer,
    4n,    // length (price bytes)
    0n,    // offset
  ],
  gasRemaining: 1000000n,
});

handler_0xa3_LOG3(frame);

const log = frame.logs[0];
console.log(log.topics.length); // 3
console.log(log.data); // Price encoded
console.log(frame.gasRemaining);
// 999000n - 1125 (topics) - 32 (data) - 3 (memory)

event Transfer(
  address indexed from,
  address indexed to,
  uint256 indexed tokenId
);

contract NFT {
  function transfer(address to, uint256 tokenId) public {
    require(balances[msg.sender][tokenId] > 0);
    balances[msg.sender][tokenId]--;
    balances[to][tokenId]++;

    // Compiler generates LOG3
    // topic0 = from
    // topic1 = to
    // topic2 = tokenId
    // data = (empty for ERC721)
    emit Transfer(msg.sender, to, tokenId);
  }
}

event ApprovalForToken(
  address indexed owner,
  address indexed spender,
  address indexed token,
  uint256 amount
);

contract ApprovalManager {
  function approveForToken(
    address token,
    address spender,
    uint256 amount
  ) public {
    approvals[msg.sender][spender][token] = amount;
    emit ApprovalForToken(msg.sender, spender, token, amount);  // LOG3
  }
}

event OrderPlaced(
  address indexed buyer,
  address indexed seller,
  bytes32 indexed orderId,
  uint256 amount
);

contract OrderBook {
  function placeOrder(
    address seller,
    bytes32 orderId,
    uint256 amount
  ) public {
    orders[orderId] = Order({
      buyer: msg.sender,
      seller: seller,
      amount: amount,
      status: OrderStatus.PENDING
    });

    emit OrderPlaced(msg.sender, seller, orderId, amount);  // LOG3
  }
}

const topic = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn;
const frame = createFrame({
  stack: [topic, topic, topic, 0n, 0n],
  gasRemaining: 1000000n,
});
handler_0xa3_LOG3(frame);
const log = frame.logs[0];
console.log(log.topics); // [topic, topic, topic] (all identical, allowed)

const frame = createFrame({
  stack: [
    (1n << 256n) - 1n,  // Max value
    0n,                 // Min value
    0x1234567890abcdefn, // Mixed
    0n,
    0n,
  ],
  gasRemaining: 1000000n,
});
handler_0xa3_LOG3(frame);
const log = frame.logs[0];
console.log(log.topics); // [0x1234..., 0n, (1n << 256n) - 1n]

const frame = createFrame({
  stack: [
    0xfff,
    0xfff,
    0xfff,
    5000n,  // length
    0n,     // offset
  ],
  gasRemaining: 100000n,
});
const err = handler_0xa3_LOG3(frame);
// Gas: 1500 + 40000 (data) + memory expansion ≈ 41500
// Result: OutOfGas

const frame = createFrame({ stack: [0n, 0n, 0n, 0n] });  // Only 4 items
const err = handler_0xa3_LOG3(frame);
console.log(err); // { type: "StackUnderflow" }

const frame = createFrame({
  stack: [0xfff, 0xfff, 0xfff, 0n, 0n],
  gasRemaining: 1499n,  // Not enough for base + all topics
});
const err = handler_0xa3_LOG3(frame);
console.log(err); // { type: "OutOfGas" }

event Trade(
  address indexed trader,
  address indexed token,
  address indexed counterparty,
  uint256 amount
);

contract DEX {
  function swapExactIn(
    address token,
    address counterparty,
    uint256 amountIn
  ) public {
    // ... swap logic
    emit Trade(msg.sender, token, counterparty, amountIn);  // LOG3
  }
}

// Listen for all trades by a specific trader
const logs = await provider.getLogs({
  address: dex.address,
  topics: [
    keccak256("Trade(address,indexed address,indexed address,indexed uint256)"),
    "0xtrader_address"
  ]
});

// Listen for trades with specific token
const logsWithToken = await provider.getLogs({
  address: dex.address,
  topics: [
    keccak256("Trade(...)"),
    null,              // Any trader
    "0xtoken_address", // Specific token
    null               // Any counterparty
  ]
});

// Listen for trades between specific parties
const logsBetween = await provider.getLogs({
  address: dex.address,
  topics: [
    keccak256("Trade(...)"),
    "0xtrader_address",
    null,
    "0xcounterparty_address"
  ]
});

event StateTransition(
  address indexed user,
  bytes32 indexed fromState,
  bytes32 indexed toState,
  string reason
);

contract StateMachine {
  mapping(address => bytes32) public userState;

  function transitionState(bytes32 newState, string memory reason) public {
    bytes32 oldState = userState[msg.sender];
    userState[msg.sender] = newState;

    emit StateTransition(msg.sender, oldState, newState, reason);  // LOG3
  }
}

event Authorization(
  address indexed grantor,
  address indexed grantee,
  address indexed resource,
  uint256 permissions
);

contract AccessControl {
  function grant(address grantee, address resource, uint256 perms) public {
    permissions[msg.sender][grantee][resource] = perms;
    emit Authorization(msg.sender, grantee, resource, perms);  // LOG3
  }
}

// BAD: Private data in topics
event BadLog(address indexed user, string indexed password);

// GOOD: Hash sensitive data
event GoodLog(address indexed user, bytes32 passwordHash);

event Swap(
  address indexed buyer,
  address indexed seller,
  address indexed token
);

// Off-chain: must match exact parameter order
// Topics: [buyer_hash, seller_hash, token]

// WRONG
function badView(address a, address b, address c) external view {
  emit Event(a, b, c);  // Reverts
}

// CORRECT
function goodNonView(address a, address b, address c) external {
  emit Event(a, b, c);  // Works
}

import { describe, it, expect } from 'vitest';
import { handler_0xa3_LOG3 } from './0xa3_LOG3.js';

describe('LOG3 (0xa3)', () => {
  it('emits log with 3 topics and empty data', () => {
    const topic0 = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan;
    const topic1 = 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn;
    const topic2 = 0xccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccn;
    const frame = createFrame({
      stack: [topic2, topic1, topic0, 0n, 0n],
      gasRemaining: 1000000n,
    });
    const err = handler_0xa3_LOG3(frame);
    expect(err).toBeNull();
    expect(frame.logs).toHaveLength(1);
    expect(frame.logs[0].topics).toEqual([topic0, topic1, topic2]);
    expect(frame.gasRemaining).toBe(998500n);
  });

  it('emits log with 3 topics and data', () => {
    const frame = createFrame({
      memory: new Map([[0, 0xde], [1, 0xad]]),
      stack: [0x3333n, 0x2222n, 0x1111n, 2n, 0n],
      gasRemaining: 1000000n,
    });
    handler_0xa3_LOG3(frame);
    const log = frame.logs[0];
    expect(log.topics).toEqual([0x1111n, 0x2222n, 0x3333n]);
    expect(log.data).toEqual(new Uint8Array([0xde, 0xad]));
  });

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

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

  it('handles boundary topic values', () => {
    const max = (1n << 256n) - 1n;
    const frame = createFrame({
      stack: [max, 0n, max, 0n, 0n],
      gasRemaining: 1000000n,
    });
    handler_0xa3_LOG3(frame);
    expect(frame.logs[0].topics).toEqual([max, 0n, max]);
  });
});