PUSH1 (0x60)

Push 1-byte immediate value onto stack

This page is a placeholder. All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.

Overview

Opcode: 0x60 Introduced: Frontier (EVM genesis)

PUSH1 pushes a 1-byte immediate value from the bytecode onto the stack. The 1 byte immediately following the opcode is read and zero-padded to 256 bits.

Specification

Stack Input:

[]

Stack Output:

value (uint256, 1 byte from bytecode)

Gas Cost: 3 (GasFastestStep)

Bytecode: 1 byte opcode + 1 byte immediate data

Operation:

value = read_bytes(pc + 1, 1)  // Big-endian
stack.push(value)
pc += 2

Behavior

PUSH1 reads 1 byte from bytecode starting at position pc + 1, interprets it as a big-endian unsigned integer, and pushes the result onto the stack.

Key characteristics:

• Reads exactly 1 byte following opcode
• Big-endian byte order (most significant byte first)
• Zero-padded to 256 bits if less than 32 bytes
• InvalidOpcode if insufficient bytecode remaining
• PC advances by 2 (opcode + data)

Examples

Basic Usage

import { handler_0x60_PUSH1 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// Bytecode with PUSH1
const bytecode = new Uint8Array([
  0x60,  // PUSH1
  0x01   // 1 byte: 01
]);

const frame = createFrame({
  bytecode,
  pc: 0,
  stack: [],
  gasRemaining: 1000n
});

const err = handler_0x60_PUSH1(frame);

console.log(frame.stack); // [0x0100000000000000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 2
console.log(frame.gasRemaining); // 997n (3 gas consumed)

Solidity Compilation

contract Example {
    // Function selectors use PUSH4
    function transfer() public {
        // PUSH4 0xa9059cbb  (4-byte selector)
    }
}

Assembly Usage

assembly {
    // Push 1-byte value
    push1 0xff
    
    // Example: 1-byte constant
}

Gas Cost

Cost: 3 gas (GasFastestStep)

All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:

• PUSH1: 2 bytes (1 opcode + 1 data)
• PUSH32: 33 bytes (1 opcode + 32 data)

Comparison:

Opcode	Gas	Bytes	Use Case
PUSH0	2	1	Zero constant (Shanghai+)
PUSH1	3	2	Small numbers (0-255)

Common Usage

Small Constants

assembly {
    push1 0x20  // Memory offset (32 bytes)
    push1 0x00  // Zero offset
    push1 0x01  // Boolean true
    push1 0xff  // Maximum byte value
}

Big-Endian Encoding

// Bytecode: PUSH1 01
// Reads as: 0x01

// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 0: 0x01 (lowest significance)

Implementation

TypeScript

/**
 * Read immediate data from bytecode for PUSH operations
 */
function readImmediate(bytecode: Uint8Array, pc: number, size: number): bigint | null {
  if (pc + 1 + size > bytecode.length) {
    return null;
  }

  let result = 0n;
  for (let i = 0; i < size; i++) {
    result = (result << 8n) | BigInt(bytecode[pc + 1 + i]);
  }
  return result;
}

/**
 * PUSH1 opcode (0x60) - Push 1 byte onto stack
 *
 * Stack: [] => [value]
 * Gas: 3 (GasFastestStep)
 */
export function handler_0x60_PUSH1(frame: FrameType): EvmError | null {
  const gasErr = consumeGas(frame, FastestStep);
  if (gasErr) return gasErr;

  const value = readImmediate(frame.bytecode, frame.pc, 1);
  if (value === null) {
    return { type: "InvalidOpcode" };
  }

  const pushErr = pushStack(frame, value);
  if (pushErr) return pushErr;

  frame.pc += 2;
  return null;
}

Edge Cases

Insufficient Bytecode

// Bytecode ends before 1 byte read
const bytecode = new Uint8Array([0x60, 0x01]); // Only 1 byte instead of 1
const frame = createFrame({ bytecode, pc: 0 });

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

Stack Overflow

// Stack at maximum capacity
const frame = createFrame({
  stack: new Array(1024).fill(0n),
  bytecode: new Uint8Array([0x60, 0x00])
});

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

Out of Gas

// Insufficient gas
const frame = createFrame({
  gasRemaining: 2n,  // Need 3 gas
  bytecode: new Uint8Array([0x60, 0xff])
});

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

Maximum Value

// All bytes 0xFF
const bytecode = new Uint8Array([0x60, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });

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

References

• Yellow Paper - Section 9.4.1 (PUSH)
• EVM Codes - PUSH1
• Solidity Assembly - push1