Struct PushValue 

pub struct PushValue {
    pub value: B256,
}

Represents a value to be pushed onto the EVM stack

This type encapsulates a 32-byte value and provides methods to:

• Generate complete bytecode with optimal PUSH opcode (PUSH0-PUSH32)
• Extract just the hex data without any opcode

Fields

value: B256

The 32-byte value to push

Implementations

impl PushValue

pub fn new(value: B256) -> PushValue

Creates a new PushValue from a B256 value

pub fn to_hex_with_opcode(&self, evm_version: &EVMVersion) -> String

Converts the PushValue to bytecode with the appropriate PUSH opcode

This generates optimal bytecode by:

• Trimming leading zeros from the value
• Selecting the smallest PUSH opcode (PUSH0-PUSH32)
• PUSH0 if the EVM version supports it and the value is zero
• Encoding the result as a hex string

Use this for normal macro/function bytecode generation.

Examples

• Value 0x01 → "6001" (PUSH1 0x01)
• Value 0x00 → "5f" (PUSH0, if supported by EVM version)
• Value 0x123456... → "7f123456..." (PUSH32)

pub fn to_hex_trimmed(&self) -> String

Returns the hex-encoded data without any PUSH opcode

This trims leading zeros and returns just the hex data. Use this for padding operations or when you need just the raw data without leading zeros.

Examples

• Value 0x0000...0001 → "01"
• Value 0x0000...1234 → "1234"
• Value 0x0000...0000 → "" (empty string)

pub fn to_hex_full(&self) -> String

Returns the full 32-byte hex-encoded data without any PUSH opcode

This always returns the full 64-character hex string (32 bytes). Use this for code tables where the full 32-byte value must be preserved.

Examples

• Value 0x0000...0001 → "0000000000000000000000000000000000000000000000000000000000000001"
• Value 0x0000...1234 → "0000000000000000000000000000000000000000000000000000000000001234"
• Value 0x0000...0000 → "0000000000000000000000000000000000000000000000000000000000000000"

pub fn to_hex_full_with_opcode(&self) -> String

Converts the full 32-byte value to hex string with PUSH32 opcode prefix (0x7f).

Always generates a PUSH32 instruction (33 bytes total: 1 byte opcode + 32 bytes data), regardless of leading zeros. This is useful for operations that require exact 32-byte values on the stack, such as padding functions.

Examples

• Value 0x0000...0001 → "7f0000000000000000000000000000000000000000000000000000000000000001"
• Value 0x0000...1234 → "7f0000000000000000000000000000000000000000000000000000000000001234"
• Value 0xFFFF...FFFF → "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"

Trait Implementations

impl Clone for PushValue

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PushValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&[u8; 32]> for PushValue

Convert from a reference to a 32-byte array to PushValue

fn from(bytes: &[u8; 32]) -> Self

Converts to this type from the input type.

impl From<FixedBytes<32>> for PushValue

Convert from B256 to PushValue

fn from(value: B256) -> Self

Converts to this type from the input type.

impl From<[u8; 4]> for PushValue

Convert from a 4-byte array (function/error selector) to PushValue

This left-pads the 4 bytes to 32 bytes (zeros on the left, data on the right)

fn from(bytes: [u8; 4]) -> Self

Converts to this type from the input type.

impl From<[u8; 32]> for PushValue

Convert from a 32-byte array directly to PushValue

fn from(bytes: [u8; 32]) -> Self

Converts to this type from the input type.

impl PartialEq for PushValue

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PushValue

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes