native/ bindings are supported on Bun. In Node.js, use the regular TypeScript API or the WASM modules.
skip:
JUMPDEST
```
This prevents evaluating condition2 if condition1 is false, saving gas and avoiding side effects.
## Compiler Behavior
### Require Statements
```solidity theme={null}
require(balance >= amount, "Insufficient");
```
Compiles to:
```
// Check condition
PUSH balance
PUSH amount
LT
ISZERO
// Jump to continue if true
PUSH2 continue
JUMPI
// Revert with error message
PUSH error_data_offset
PUSH error_data_size
REVERT
continue:
JUMPDEST
```
### If Statements
```solidity theme={null}
if (value > 0) {
result = 1;
} else {
result = 2;
}
```
Compiles to:
```
// Evaluate condition
PUSH value
PUSH1 0
GT
// Jump to then if true
PUSH2 then_branch
JUMPI
// Else branch
PUSH1 2
PUSH1 result_slot
SSTORE
PUSH2 end
JUMP
// Then branch
then_branch:
JUMPDEST
PUSH1 1
PUSH1 result_slot
SSTORE
end:
JUMPDEST
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.3 (JUMPI instruction)
* [EVM Codes - JUMPI](https://www.evm.codes/#57)
* [Solidity Docs - Assembly](https://docs.soliditylang.org/en/latest/assembly.html)
* [EVM Deep Dives - Control Flow](https://noxx.substack.com/p/evm-deep-dives-the-path-to-shadowy-3ea)
# PC (0x58)
Source: https://voltaire.tevm.sh/evm/instructions/control-flow/pc
Push current program counter 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:** `0x58`
**Introduced:** Frontier (EVM genesis)
PC pushes the current program counter value onto the stack. The program counter represents the position of the currently executing instruction in the bytecode.
This opcode enables position-aware bytecode, dynamic jump calculations, and self-referential code patterns.
## Specification
**Stack Input:** None
**Stack Output:**
```
pc (top) - Current program counter value
```
**Gas Cost:** 2 (GasQuickStep)
**Operation:**
```
1. Push current PC onto stack
2. Increment PC by 1
```
## Behavior
PC provides the current execution position:
1. Consumes 2 gas (GasQuickStep)
2. Pushes current PC value onto stack
3. Increments PC to next instruction
**Important:** The value pushed is the PC of the PC instruction itself, NOT the next instruction.
**Example:**
```
Position Opcode
-------- ------
0x00 PUSH1 0x05
0x02 PC ← PC = 0x02
0x03 ADD
```
When PC executes at position 0x02, it pushes `0x02` onto the stack.
## Examples
### Basic PC Usage
```typescript theme={null}
import { createFrame } from '@tevm/voltaire/evm/Frame';
import { handler_0x58_PC } from '@tevm/voltaire/evm/control';
const bytecode = new Uint8Array([
0x60, 0x05, // PUSH1 5 (positions 0-1)
0x58, // PC (position 2)
0x01, // ADD (position 3)
]);
const frame = createFrame({
bytecode,
stack: [5n],
pc: 2 // At PC instruction
});
const err = handler_0x58_PC(frame);
console.log(err); // null (success)
console.log(frame.stack); // [5n, 2n] (pushed PC value 2)
console.log(frame.pc); // 3 (incremented)
```
### Calculate Relative Position
```solidity theme={null}
assembly {
let currentPos := pc()
let targetPos := add(currentPos, 10) // 10 bytes ahead
// Use for relative jumps or calculations
}
```
### Position-Aware Code
```typescript theme={null}
const bytecode = new Uint8Array([
0x58, // PC → pushes 0
0x60, 0x05, // PUSH1 5
0x01, // ADD → 0 + 5 = 5
0x58, // PC → pushes 5
0x01, // ADD → 5 + 5 = 10
]);
const frame = createFrame({ bytecode, pc: 0 });
// First PC
handler_0x58_PC(frame);
console.log(frame.stack); // [0n]
// Execute PUSH1 5
frame.pc = 1;
handler_0x60_PUSH1(frame);
console.log(frame.stack); // [0n, 5n]
// ADD
frame.pc = 3;
handler_0x01_ADD(frame);
console.log(frame.stack); // [5n]
// Second PC
frame.pc = 4;
handler_0x58_PC(frame);
console.log(frame.stack); // [5n, 4n]
```
### Dynamic Jump Table
```solidity theme={null}
assembly {
let base := pc()
// Jump table based on current position
let offset := mul(selector, 0x20)
let dest := add(base, offset)
jump(dest)
}
```
## Gas Cost
**Cost:** 2 gas (GasQuickStep)
**Comparison:**
* PC: 2 gas (read position)
* PUSH1: 3 gas (push constant)
* JUMP: 8 gas
* JUMPI: 10 gas
**Efficiency:**
PC is cheaper than PUSH for getting current position, but PUSH is still preferred for constants.
## Edge Cases
### PC at Start
```typescript theme={null}
// PC at position 0
const bytecode = new Uint8Array([0x58, 0x00]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x58_PC(frame);
console.log(frame.stack); // [0n]
```
### PC at End
```typescript theme={null}
// PC at last instruction
const bytecode = new Uint8Array([0x00, 0x00, 0x58]);
const frame = createFrame({ bytecode, pc: 2 });
handler_0x58_PC(frame);
console.log(frame.stack); // [2n]
console.log(frame.pc); // 3 (past bytecode - will stop)
```
### Stack Overflow
```typescript theme={null}
// Stack at max capacity (1024 items)
const frame = createFrame({
stack: new Array(1024).fill(0n),
pc: 0
});
const err = handler_0x58_PC(frame);
console.log(err); // { type: "StackOverflow" }
```
### Multiple PC Calls
```typescript theme={null}
const bytecode = new Uint8Array([
0x58, // PC → 0
0x58, // PC → 1
0x58, // PC → 2
0x58, // PC → 3
]);
const frame = createFrame({ bytecode, pc: 0 });
// Execute all PC instructions
for (let i = 0; i < 4; i++) {
handler_0x58_PC(frame);
}
console.log(frame.stack); // [0n, 1n, 2n, 3n]
```
## Common Usage
### Relative Addressing
Calculate addresses relative to current position:
```solidity theme={null}
assembly {
let here := pc()
let data_offset := add(here, 0x20) // 32 bytes ahead
// Load data from relative position
let data := mload(data_offset)
}
```
### Position Verification
```solidity theme={null}
assembly {
let expected := 0x1234
let actual := pc()
// Verify we're at expected position
if iszero(eq(actual, expected)) {
revert(0, 0)
}
}
```
### Code Size Calculation
```solidity theme={null}
assembly {
let start := pc()
// ... code block ...
let end := pc()
let size := sub(end, start)
}
```
### Dynamic Dispatch Base
```solidity theme={null}
assembly {
// Get base address for jump table
let base := pc()
// Calculate jump destination
switch selector
case 0 { jump(add(base, 0x10)) }
case 1 { jump(add(base, 0x30)) }
case 2 { jump(add(base, 0x50)) }
}
```
## Implementation
```typescript theme={null}
import { consumeGas } from "../Frame/consumeGas.js";
import { pushStack } from "../Frame/pushStack.js";
import { QuickStep } from "../../primitives/GasConstants/constants.js";
/**
* PC opcode (0x58) - Get program counter
*
* @param frame - Frame instance
* @returns Error if operation fails
*/
export function handler_0x58_PC(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, QuickStep);
if (gasErr) return gasErr;
const pushErr = pushStack(frame, BigInt(frame.pc));
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0x58_PC } from './0x58_PC.js';
describe('PC (0x58)', () => {
it('pushes current PC value', () => {
const frame = createFrame({ pc: 42 });
const err = handler_0x58_PC(frame);
expect(err).toBeNull();
expect(frame.stack).toEqual([42n]);
expect(frame.pc).toBe(43);
});
it('pushes 0 at start', () => {
const frame = createFrame({ pc: 0 });
handler_0x58_PC(frame);
expect(frame.stack).toEqual([0n]);
expect(frame.pc).toBe(1);
});
it('increments PC after execution', () => {
const frame = createFrame({ pc: 100 });
handler_0x58_PC(frame);
expect(frame.pc).toBe(101);
});
it('consumes 2 gas', () => {
const frame = createFrame({ gasRemaining: 1000n, pc: 0 });
handler_0x58_PC(frame);
expect(frame.gasRemaining).toBe(998n);
});
it('handles stack overflow', () => {
const frame = createFrame({
stack: new Array(1024).fill(0n),
pc: 0,
});
expect(handler_0x58_PC(frame)).toEqual({ type: 'StackOverflow' });
});
it('handles out of gas', () => {
const frame = createFrame({ gasRemaining: 1n, pc: 0 });
expect(handler_0x58_PC(frame)).toEqual({ type: 'OutOfGas' });
});
});
```
## Security
### Position-Dependent Code
PC enables position-dependent bytecode, which can be fragile:
```solidity theme={null}
assembly {
// FRAGILE: Depends on exact bytecode layout
let current := pc()
let target := add(current, 0x42) // Assumes 0x42 offset
jump(target)
}
```
**Issues:**
* Compiler optimizations can change positions
* Adding code shifts all offsets
* Hard to maintain and debug
**Better approach:**
```solidity theme={null}
assembly {
// ROBUST: Use labels, let compiler handle positions
jump(target)
target:
jumpdest
// Code here
}
```
### Code Obfuscation
PC can be used for code obfuscation:
```solidity theme={null}
assembly {
// Obfuscated jump calculation
let x := pc()
let y := add(x, 0x10)
let z := xor(y, 0x5b)
jump(z) // Hard to analyze statically
}
```
**Security impact:**
* Makes auditing difficult
* Hides control flow
* Red flag for malicious code
* Avoid in production contracts
### Limited Practical Use
PC has few legitimate use cases in modern Solidity:
**Not useful for:**
* Function dispatch (compiler handles this)
* Relative jumps (labels are better)
* Code size (codesize opcode exists)
**Occasionally useful for:**
* Gas optimization (avoid PUSH for position)
* Self-modifying code patterns (advanced, rare)
* Position verification in tests
## Compiler Behavior
### Solidity Avoids PC
Modern Solidity rarely generates PC instructions:
```solidity theme={null}
function example() public pure returns (uint256) {
assembly {
let pos := pc() // Explicit PC usage
}
}
```
Compiles to:
```
PC // 0x58 - explicit from assembly
```
But normal Solidity doesn't use PC - it uses PUSH for constants and labels for jumps.
### Labels vs PC
**Old pattern (PC-based):**
```solidity theme={null}
assembly {
let dest := add(pc(), 0x10)
jump(dest)
}
```
**Modern pattern (label-based):**
```solidity theme={null}
assembly {
jump(target)
target:
jumpdest
}
```
Compiler resolves labels to absolute positions at compile time.
### Optimization
Compilers can optimize PC away:
```solidity theme={null}
assembly {
let x := pc()
let y := add(x, 5)
}
```
Could be optimized to:
```solidity theme={null}
assembly {
let y := // PC value known at compile time
}
```
## Comparison with Other Chains
### EVM (Ethereum)
PC returns bytecode position, 0-indexed.
### WASM
No direct equivalent. WASM uses structured control flow (blocks, loops) rather than position-based jumps.
### x86 Assembly
EIP (Extended Instruction Pointer) register similar to PC, but:
* Hardware register, not stack
* 64-bit on x64, 32-bit on x86
* Can be read/written directly
### JVM
No equivalent. JVM uses structured bytecode with exception tables rather than position-based control flow.
## Historical Context
PC was included in original EVM for:
1. Position-aware code patterns
2. Relative addressing calculations
3. Dynamic jump table construction
**Modern usage:**
* Rarely needed in practice
* Compilers use labels instead
* Maintained for compatibility
* Occasionally useful for gas optimization
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PC instruction)
* [EVM Codes - PC](https://www.evm.codes/#58)
* [Solidity Docs - Assembly](https://docs.soliditylang.org/en/latest/assembly.html)
# RETURN (0xf3)
Source: https://voltaire.tevm.sh/evm/instructions/control-flow/return
Halt execution successfully and return output data
**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:** `0xf3`
**Introduced:** Frontier (EVM genesis)
RETURN halts execution successfully and returns output data to the caller. All state changes are preserved, and the specified memory range is copied to the return buffer.
This is the standard way to complete execution with a return value in the EVM.
## Specification
**Stack Input:**
```
offset (top) - Memory offset of return data
length - Length of return data in bytes
```
**Stack Output:** None
**Gas Cost:** Memory expansion cost (dynamic)
**Operation:**
```
1. Pop offset and length from stack
2. Charge gas for memory expansion
3. Copy memory[offset:offset+length] to output
4. Set stopped = true
5. Return to caller
```
## Behavior
RETURN terminates execution with output:
1. Pops offset from stack (top)
2. Pops length from stack (second)
3. Validates offset and length fit in u32
4. Charges gas for memory expansion to offset+length
5. Copies length bytes from memory\[offset] to output buffer
6. Sets execution state to stopped
7. Returns control to caller with success status
**State Effects:**
* All state changes preserved (storage, logs, balance transfers)
* Output data available to caller
* Remaining gas NOT refunded (consumed by transaction)
* Execution marked as successful
## Examples
### Basic Return
```typescript theme={null}
import { createFrame } from '@tevm/voltaire/evm/Frame';
import { handler_0xf3_RETURN } from '@tevm/voltaire/evm/control';
// Return 32 bytes from memory offset 0
const frame = createFrame({
stack: [32n, 0n], // length=32, offset=0
memory: Bytes64(),
gasRemaining: 1000n
});
// Write data to memory
frame.memory[0] = 0x42;
const err = handler_0xf3_RETURN(frame);
console.log(err); // null (success)
console.log(frame.stopped); // true
console.log(frame.output); // Uint8Array([0x42, 0x00, ...]) (32 bytes)
```
### Return Value
```solidity theme={null}
function getValue() external pure returns (uint256) {
assembly {
// Store return value in memory
mstore(0, 42)
// Return 32 bytes from offset 0
return(0, 32)
}
}
```
Compiled to:
```
PUSH1 42
PUSH1 0
MSTORE // memory[0] = 42
PUSH1 32 // length
PUSH1 0 // offset
RETURN // return memory[0:32]
```
### Return String
```solidity theme={null}
function getString() external pure returns (string memory) {
return "Hello";
}
```
Compiled (simplified):
```
// ABI encoding: offset, length, data
PUSH1 0x20 // offset of string data
PUSH1 0
MSTORE
PUSH1 5 // string length
PUSH1 0x20
MSTORE
PUSH5 "Hello" // string data
PUSH1 0x40
MSTORE
PUSH1 0x60 // total length
PUSH1 0 // offset
RETURN
```
### Empty Return
```typescript theme={null}
// Return 0 bytes (void function)
const frame = createFrame({
stack: [0n, 0n], // length=0, offset=0
gasRemaining: 1000n
});
handler_0xf3_RETURN(frame);
console.log(frame.output); // undefined (no output)
console.log(frame.stopped); // true
```
### Constructor Return
```solidity theme={null}
contract Example {
constructor() {
// Constructor code
}
}
```
Constructor bytecode:
```
// Initialization code
// Return runtime bytecode
PUSH1 runtime_size
PUSH1 runtime_offset
RETURN // Return deployed code
```
## Gas Cost
**Cost:** Memory expansion cost (dynamic)
**Formula:**
```
memory_size_word = (offset + length + 31) / 32
memory_cost = (memory_size_word ^ 2) / 512 + (3 * memory_size_word)
gas = memory_cost - previous_memory_cost
```
**Examples:**
Return 32 bytes (1 word):
```typescript theme={null}
const frame = createFrame({
stack: [32n, 0n],
memorySize: 0,
});
// New memory size: 32 bytes = 1 word
// Cost: (1^2)/512 + 3*1 = 0 + 3 = 3 gas
```
Return 256 bytes (8 words):
```typescript theme={null}
const frame = createFrame({
stack: [256n, 0n],
memorySize: 0,
});
// New memory size: 256 bytes = 8 words
// Cost: (8^2)/512 + 3*8 = 0.125 + 24 = 24 gas (rounded)
```
Return from existing memory (no expansion):
```typescript theme={null}
const frame = createFrame({
stack: [32n, 0n],
memorySize: 64, // Already expanded
});
// No expansion needed: 0 gas
```
## Edge Cases
### Zero Length Return
```typescript theme={null}
// Return 0 bytes
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 1000n
});
handler_0xf3_RETURN(frame);
console.log(frame.output); // undefined
console.log(frame.stopped); // true
console.log(frame.gasRemaining); // ~1000n (minimal gas consumed)
```
### Large Return Data
```typescript theme={null}
// Return 1 KB
const frame = createFrame({
stack: [1024n, 0n],
memory: new Uint8Array(2048),
gasRemaining: 10000n
});
handler_0xf3_RETURN(frame);
console.log(frame.output.length); // 1024
// Gas consumed for 32 words memory expansion
```
### Out of Bounds
```typescript theme={null}
// Offset + length overflow u32
const frame = createFrame({
stack: [0x100000000n, 0n], // length > u32::MAX
gasRemaining: 1000n
});
const err = handler_0xf3_RETURN(frame);
console.log(err); // { type: "OutOfBounds" }
```
### Offset Overflow
```typescript theme={null}
// offset + length causes overflow
const frame = createFrame({
stack: [100n, 0xffffffffn], // offset + length overflows
gasRemaining: 1000n
});
const err = handler_0xf3_RETURN(frame);
console.log(err); // { type: "OutOfBounds" }
```
### Stack Underflow
```typescript theme={null}
// Need 2 stack items
const frame = createFrame({
stack: [32n], // Only 1 item
gasRemaining: 1000n
});
const err = handler_0xf3_RETURN(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas for memory expansion
const frame = createFrame({
stack: [1000n, 0n], // Large return data
gasRemaining: 1n, // Insufficient gas
});
const err = handler_0xf3_RETURN(frame);
console.log(err); // { type: "OutOfGas" }
```
## Common Usage
### Function Return Values
```solidity theme={null}
function add(uint256 a, uint256 b) external pure returns (uint256) {
return a + b;
}
```
Compiled to:
```
// Add a + b
PUSH1 0x04
CALLDATALOAD
PUSH1 0x24
CALLDATALOAD
ADD
// Store result in memory
PUSH1 0
MSTORE
// Return 32 bytes
PUSH1 32
PUSH1 0
RETURN
```
### Multiple Return Values
```solidity theme={null}
function swap(uint256 a, uint256 b) external pure returns (uint256, uint256) {
return (b, a);
}
```
Compiled to:
```
// Store first return value
PUSH1 0x24
CALLDATALOAD
PUSH1 0
MSTORE
// Store second return value
PUSH1 0x04
CALLDATALOAD
PUSH1 0x20
MSTORE
// Return 64 bytes
PUSH1 64
PUSH1 0
RETURN
```
### Constructor Deployment
```solidity theme={null}
contract Example {
uint256 public value;
constructor(uint256 _value) {
value = _value;
}
}
```
Constructor ends with RETURN containing runtime bytecode:
```
// Initialization
PUSH1 _value
PUSH1 0
SSTORE
// Copy runtime code to memory
PUSH1 runtime_size
PUSH1 runtime_offset
PUSH1 0
CODECOPY
// Return runtime code
PUSH1 runtime_size
PUSH1 0
RETURN
```
### View Function
```solidity theme={null}
function getBalance(address account) external view returns (uint256) {
return balances[account];
}
```
Compiled to:
```
// Load balance
PUSH1 0x04
CALLDATALOAD
PUSH1 0
SLOAD
// Return balance
PUSH1 0
MSTORE
PUSH1 32
PUSH1 0
RETURN
```
## Implementation
```typescript theme={null}
import { popStack } from "../Frame/popStack.js";
import { consumeGas } from "../Frame/consumeGas.js";
import { memoryExpansionCost } from "../Frame/memoryExpansionCost.js";
import { readMemory } from "../Frame/readMemory.js";
/**
* RETURN opcode (0xf3) - Halt execution and return output data
*
* @param frame - Frame instance
* @returns Error if operation fails
*/
export function handler_0xf3_RETURN(frame: FrameType): EvmError | null {
const offsetResult = popStack(frame);
if (offsetResult.error) return offsetResult.error;
const offset = offsetResult.value;
const lengthResult = popStack(frame);
if (lengthResult.error) return lengthResult.error;
const length = lengthResult.value;
// Check if offset + length fits in u32
if (offset > 0xffffffffn || length > 0xffffffffn) {
return { type: "OutOfBounds" };
}
const off = Number(offset);
const len = Number(length);
if (length > 0n) {
// Check for overflow
const endOffset = off + len;
if (endOffset < off) {
return { type: "OutOfBounds" };
}
// Charge memory expansion
const memCost = memoryExpansionCost(frame, endOffset);
const gasErr = consumeGas(frame, memCost);
if (gasErr) return gasErr;
const alignedSize = wordAlignedSize(endOffset);
if (alignedSize > frame.memorySize) {
frame.memorySize = alignedSize;
}
// Copy memory to output
frame.output = new Uint8Array(len);
for (let idx = 0; idx < len; idx++) {
const addr = off + idx;
frame.output[idx] = readMemory(frame, addr);
}
}
frame.stopped = true;
return null;
}
function wordAlignedSize(bytes: number): number {
const words = Math.ceil(bytes / 32);
return words * 32;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0xf3_RETURN } from './0xf3_RETURN.js';
describe('RETURN (0xf3)', () => {
it('returns data from memory', () => {
const memory = Bytes64();
memory[0] = 0x42;
memory[1] = 0x43;
const frame = createFrame({
stack: [2n, 0n],
memory,
gasRemaining: 1000n,
});
const err = handler_0xf3_RETURN(frame);
expect(err).toBeNull();
expect(frame.stopped).toBe(true);
expect(frame.output).toEqual(new Uint8Array([0x42, 0x43]));
});
it('handles zero-length return', () => {
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 1000n,
});
handler_0xf3_RETURN(frame);
expect(frame.stopped).toBe(true);
expect(frame.output).toBeUndefined();
});
it('charges memory expansion gas', () => {
const frame = createFrame({
stack: [32n, 0n],
memorySize: 0,
gasRemaining: 1000n,
});
handler_0xf3_RETURN(frame);
expect(frame.gasRemaining).toBeLessThan(1000n);
});
it('rejects out of bounds offset', () => {
const frame = createFrame({
stack: [1n, 0x100000000n],
});
expect(handler_0xf3_RETURN(frame)).toEqual({ type: 'OutOfBounds' });
});
it('rejects overflow', () => {
const frame = createFrame({
stack: [100n, 0xffffffffn],
});
expect(handler_0xf3_RETURN(frame)).toEqual({ type: 'OutOfBounds' });
});
});
```
## Security
### Return Data Size
Large return data consumes significant gas:
```solidity theme={null}
// EXPENSIVE: Return 10 KB
function getLargeData() external pure returns (bytes memory) {
bytes memory data = new bytes(10000);
return data; // High gas cost for RETURN
}
```
**Gas cost grows quadratically** with memory expansion:
* 1 KB: \~100 gas
* 10 KB: \~1,500 gas
* 100 KB: \~150,000 gas
### Memory Expansion Attack
Attacker cannot cause excessive memory expansion via RETURN:
* Gas limit prevents unlimited expansion
* Quadratic cost makes large expansion expensive
* Out-of-gas reverts transaction
### Return Data Validation
Caller must validate returned data:
```solidity theme={null}
// VULNERABLE: Trusts return data
function unsafeCall(address target) external {
(bool success, bytes memory data) = target.call("");
require(success);
uint256 value = abi.decode(data, (uint256)); // DANGEROUS
// No validation - could be malicious
}
```
**Safe pattern:**
```solidity theme={null}
function safeCall(address target) external {
(bool success, bytes memory data) = target.call("");
require(success);
require(data.length == 32, "Invalid return size");
uint256 value = abi.decode(data, (uint256));
require(value <= MAX_VALUE, "Value out of range");
// Validated return data
}
```
### State Finality
RETURN makes all state changes final:
```solidity theme={null}
function unsafeUpdate(uint256 value) external {
balance = value; // State changed
// RETURN makes this final - no further validation possible
assembly {
mstore(0, value)
return(0, 32)
}
}
```
**Better:** Validate before state changes.
## Compiler Behavior
### Function Returns
Solidity encodes return values using ABI encoding:
```solidity theme={null}
function getValues() external pure returns (uint256, address) {
return (42, address(0x123));
}
```
Compiled to:
```
// Encode first return value
PUSH1 42
PUSH1 0
MSTORE
// Encode second return value
PUSH20 0x123...
PUSH1 0x20
MSTORE
// Return 64 bytes
PUSH1 64
PUSH1 0
RETURN
```
### Constructor Pattern
Every constructor ends with RETURN:
```solidity theme={null}
constructor() {
owner = msg.sender;
}
```
Bytecode structure:
```
CODECOPY // Copy runtime code to memory
RETURN // Return runtime code
```
### View Functions
View functions use RETURN to provide read-only data:
```solidity theme={null}
function balanceOf(address account) external view returns (uint256) {
return balances[account];
}
```
Staticcall context + RETURN = gas-efficient reads.
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.4 (RETURN instruction)
* [EVM Codes - RETURN](https://www.evm.codes/#f3)
* [Solidity Docs - ABI Specification](https://docs.soliditylang.org/en/latest/abi-spec.html)
* [Solidity Docs - Assembly](https://docs.soliditylang.org/en/latest/assembly.html)
# REVERT (0xfd)
Source: https://voltaire.tevm.sh/evm/instructions/control-flow/revert
Halt execution, revert state changes, and return error data
**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:** `0xfd`
**Introduced:** Byzantium (EIP-140)
REVERT halts execution, reverts all state changes in the current execution context, and returns error data to the caller. Unlike pre-Byzantium failures, REVERT refunds remaining gas and provides error information.
This enables graceful failure handling with gas efficiency and informative error messages.
## Specification
**Stack Input:**
```
offset (top) - Memory offset of error data
length - Length of error data in bytes
```
**Stack Output:** None
**Gas Cost:** Memory expansion cost (dynamic)
**Operation:**
```
1. Pop offset and length from stack
2. Charge gas for memory expansion
3. Copy memory[offset:offset+length] to output
4. Revert all state changes in current context
5. Set reverted = true
6. Return to caller with failure status
7. Refund remaining gas
```
## Behavior
REVERT terminates execution with error:
1. Pops offset from stack (top)
2. Pops length from stack (second)
3. Validates offset and length fit in u32
4. Charges gas for memory expansion to offset+length
5. Copies length bytes from memory\[offset] to output buffer
6. Reverts all state changes (storage, logs, balance transfers)
7. Sets execution state to reverted
8. Returns control to caller with failure status
9. Refunds remaining gas to transaction
**State Effects:**
* All state changes reverted in current call context
* Error data available to caller
* Remaining gas refunded (not consumed like INVALID)
* Execution marked as failed
**Hardfork Requirement:**
* Byzantium or later: REVERT available
* Pre-Byzantium: REVERT triggers InvalidOpcode error
## Examples
### Basic Revert
```typescript theme={null}
import { createFrame } from '@tevm/voltaire/evm/Frame';
import { handler_0xfd_REVERT } from '@tevm/voltaire/evm/control';
// Revert with error message
const frame = createFrame({
stack: [32n, 0n], // length=32, offset=0
memory: Bytes64(),
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM }
});
// Write error data to memory
const errorMsg = Buffer("Insufficient balance");
frame.memory.set(errorMsg, 0);
const err = handler_0xfd_REVERT(frame);
console.log(err); // null (opcode succeeded)
console.log(frame.reverted); // true (execution reverted)
console.log(frame.output); // Uint8Array containing error message
console.log(frame.gasRemaining); // ~1000n (remaining gas preserved)
```
### Require Statement
```solidity theme={null}
function transfer(address to, uint256 amount) external {
require(balances[msg.sender] >= amount, "Insufficient balance");
// ...
}
```
Compiled to (simplified):
```
// Load balance
CALLER
PUSH1 0
SLOAD
// Check balance >= amount
CALLDATA_LOAD 0x24
DUP2
LT
ISZERO
PUSH2 continue
JUMPI
// Revert with error message
PUSH1 error_length
PUSH1 error_offset
REVERT
continue:
JUMPDEST
// Continue execution
```
### Custom Error (Solidity 0.8.4+)
```solidity theme={null}
error InsufficientBalance(uint256 available, uint256 required);
function transfer(address to, uint256 amount) external {
if (balances[msg.sender] < amount) {
revert InsufficientBalance(balances[msg.sender], amount);
}
// ...
}
```
Compiled to:
```
// Check condition
CALLER
PUSH1 0
SLOAD
CALLDATA_LOAD 0x24
DUP2
LT
ISZERO
PUSH2 continue
JUMPI
// Encode custom error
PUSH4 0x12345678 // Error selector
PUSH1 0
MSTORE
CALLER
PUSH1 0
SLOAD
PUSH1 0x04
MSTORE // available parameter
CALLDATA_LOAD 0x24
PUSH1 0x24
MSTORE // required parameter
// Revert with error data
PUSH1 0x44 // 4 + 32 + 32 bytes
PUSH1 0
REVERT
continue:
JUMPDEST
```
### Empty Revert
```typescript theme={null}
// Revert with no error data
const frame = createFrame({
stack: [0n, 0n], // length=0, offset=0
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM }
});
handler_0xfd_REVERT(frame);
console.log(frame.output); // undefined (no error data)
console.log(frame.reverted); // true
```
### Pre-Byzantium Error
```typescript theme={null}
// REVERT before Byzantium hardfork
const frame = createFrame({
stack: [0n, 0n],
evm: { hardfork: Hardfork.HOMESTEAD } // Before Byzantium
});
const err = handler_0xfd_REVERT(frame);
console.log(err); // { type: "InvalidOpcode" }
// REVERT not available pre-Byzantium
```
## Gas Cost
**Cost:** Memory expansion cost (dynamic) + remaining gas refunded
**Memory Expansion Formula:**
```
memory_size_word = (offset + length + 31) / 32
memory_cost = (memory_size_word ^ 2) / 512 + (3 * memory_size_word)
gas_consumed = memory_cost - previous_memory_cost
remaining_gas = refunded to transaction
```
**Key Difference from INVALID:**
* REVERT: Refunds remaining gas
* INVALID (0xfe): Consumes all gas
**Example:**
```typescript theme={null}
const frame = createFrame({
stack: [32n, 0n],
gasRemaining: 10000n,
evm: { hardfork: Hardfork.BYZANTIUM }
});
handler_0xfd_REVERT(frame);
// Memory expansion: ~3 gas consumed
// Remaining: ~9997 gas refunded to transaction
```
## Edge Cases
### Zero Length Revert
```typescript theme={null}
// Revert with no error data
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM }
});
handler_0xfd_REVERT(frame);
console.log(frame.output); // undefined
console.log(frame.reverted); // true
console.log(frame.gasRemaining); // ~1000n (minimal gas consumed)
```
### Large Error Data
```typescript theme={null}
// Revert with 1 KB error message
const frame = createFrame({
stack: [1024n, 0n],
memory: new Uint8Array(2048),
gasRemaining: 10000n,
evm: { hardfork: Hardfork.BYZANTIUM }
});
handler_0xfd_REVERT(frame);
console.log(frame.output.length); // 1024
console.log(frame.reverted); // true
// Gas consumed for memory expansion, rest refunded
```
### Out of Bounds
```typescript theme={null}
// Offset + length overflow u32
const frame = createFrame({
stack: [0x100000000n, 0n], // length > u32::MAX
evm: { hardfork: Hardfork.BYZANTIUM }
});
const err = handler_0xfd_REVERT(frame);
console.log(err); // { type: "OutOfBounds" }
```
### Stack Underflow
```typescript theme={null}
// Need 2 stack items
const frame = createFrame({
stack: [32n], // Only 1 item
evm: { hardfork: Hardfork.BYZANTIUM }
});
const err = handler_0xfd_REVERT(frame);
console.log(err); // { type: "StackUnderflow" }
```
### State Reversion
```typescript theme={null}
// State changes are reverted
const frame = createFrame({
stack: [0n, 0n],
storage: new Map([[0n, 42n]]),
evm: { hardfork: Hardfork.BYZANTIUM }
});
// Make state change
frame.storage.set(1n, 123n);
handler_0xfd_REVERT(frame);
// State changes reverted by EVM executor
// storage[1] not persisted
```
## Common Usage
### Input Validation
```solidity theme={null}
function withdraw(uint256 amount) external {
require(amount > 0, "Amount must be positive");
require(balances[msg.sender] >= amount, "Insufficient balance");
balances[msg.sender] -= amount;
payable(msg.sender).transfer(amount);
}
```
Each `require` compiles to conditional REVERT.
### Access Control
```solidity theme={null}
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
function updateConfig() external onlyOwner {
// ...
}
```
### Business Logic Checks
```solidity theme={null}
function buy(uint256 tokenId) external payable {
require(!sold[tokenId], "Already sold");
require(msg.value >= price, "Insufficient payment");
sold[tokenId] = true;
// ...
}
```
### Custom Errors (Gas Efficient)
```solidity theme={null}
error Unauthorized(address caller);
error InsufficientFunds(uint256 available, uint256 required);
function withdraw(uint256 amount) external {
if (msg.sender != owner) {
revert Unauthorized(msg.sender);
}
if (balances[msg.sender] < amount) {
revert InsufficientFunds(balances[msg.sender], amount);
}
// ...
}
```
Custom errors are more gas efficient than string messages:
* String: \~50 gas per character
* Custom error: \~4 gas (function selector) + parameter encoding
## Implementation
```typescript theme={null}
import { popStack } from "../Frame/popStack.js";
import { consumeGas } from "../Frame/consumeGas.js";
import { memoryExpansionCost } from "../Frame/memoryExpansionCost.js";
import { readMemory } from "../Frame/readMemory.js";
/**
* REVERT opcode (0xfd) - Halt execution and revert state changes
*
* Note: REVERT was introduced in Byzantium hardfork (EIP-140).
* Hardfork validation should be handled by the EVM executor.
*
* @param frame - Frame instance
* @returns Error if operation fails
*/
export function handler_0xfd_REVERT(frame: FrameType): EvmError | null {
const offsetResult = popStack(frame);
if (offsetResult.error) return offsetResult.error;
const offset = offsetResult.value;
const lengthResult = popStack(frame);
if (lengthResult.error) return lengthResult.error;
const length = lengthResult.value;
// Check if offset + length fits in u32
if (offset > 0xffffffffn || length > 0xffffffffn) {
return { type: "OutOfBounds" };
}
const off = Number(offset);
const len = Number(length);
if (length > 0n) {
// Charge memory expansion
const endBytes = off + len;
const memCost = memoryExpansionCost(frame, endBytes);
const gasErr = consumeGas(frame, memCost);
if (gasErr) return gasErr;
const alignedSize = wordAlignedSize(endBytes);
if (alignedSize > frame.memorySize) {
frame.memorySize = alignedSize;
}
// Copy memory to output
frame.output = new Uint8Array(len);
for (let idx = 0; idx < len; idx++) {
const addr = off + idx;
frame.output[idx] = readMemory(frame, addr);
}
}
frame.reverted = true;
return null;
}
function wordAlignedSize(bytes: number): number {
const words = Math.ceil(bytes / 32);
return words * 32;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0xfd_REVERT } from './0xfd_REVERT.js';
describe('REVERT (0xfd)', () => {
it('reverts with error data', () => {
const memory = Bytes64();
memory[0] = 0x42;
memory[1] = 0x43;
const frame = createFrame({
stack: [2n, 0n],
memory,
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM },
});
const err = handler_0xfd_REVERT(frame);
expect(err).toBeNull();
expect(frame.reverted).toBe(true);
expect(frame.output).toEqual(new Uint8Array([0x42, 0x43]));
});
it('handles zero-length revert', () => {
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM },
});
handler_0xfd_REVERT(frame);
expect(frame.reverted).toBe(true);
expect(frame.output).toBeUndefined();
});
it('refunds remaining gas', () => {
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 10000n,
evm: { hardfork: Hardfork.BYZANTIUM },
});
handler_0xfd_REVERT(frame);
expect(frame.gasRemaining).toBeGreaterThan(9990n);
});
it('rejects pre-Byzantium', () => {
const frame = createFrame({
stack: [0n, 0n],
evm: { hardfork: Hardfork.HOMESTEAD },
});
expect(handler_0xfd_REVERT(frame)).toEqual({ type: 'InvalidOpcode' });
});
it('charges memory expansion gas', () => {
const frame = createFrame({
stack: [1024n, 0n],
memorySize: 0,
gasRemaining: 1000n,
evm: { hardfork: Hardfork.BYZANTIUM },
});
handler_0xfd_REVERT(frame);
expect(frame.gasRemaining).toBeLessThan(1000n);
});
});
```
## Security
### REVERT vs INVALID
**REVERT (0xfd):**
* Refunds remaining gas
* Returns error data
* Graceful failure
* Use for: validation, business logic, access control
**INVALID (0xfe):**
* Consumes all gas
* No error data
* Hard failure
* Use for: should-never-happen, invariant violations
**Example:**
```solidity theme={null}
// GOOD: Use REVERT for expected failures
function withdraw(uint256 amount) external {
require(amount <= balance, "Insufficient balance"); // REVERT
// ...
}
// GOOD: Use INVALID for invariant violations
function criticalOperation() internal {
assert(invariant); // INVALID if false (should never happen)
// ...
}
```
### Gas Refund Implications
REVERT refunds gas - important for:
**Nested calls:**
```solidity theme={null}
contract Parent {
function callChild(address child) external {
// Provide gas stipend
(bool success, ) = child.call{gas: 10000}("");
if (!success) {
// Child may have reverted - gas refunded
// Remaining gas available for error handling
}
}
}
```
**Gas griefing prevention:**
```solidity theme={null}
// SAFE: REVERT refunds gas
function safeOperation() external {
require(condition, "Failed"); // REVERT
// Caller gets unused gas back
}
// DANGEROUS: INVALID consumes all gas
function dangerousOperation() external {
assert(condition); // INVALID - consumes all gas
// Caller loses all provided gas
}
```
### Error Data Validation
Caller must validate error data:
```solidity theme={null}
// VULNERABLE: Trusts error data size
function unsafeCall(address target) external {
(bool success, bytes memory data) = target.call("");
if (!success) {
// data could be arbitrarily large
string memory error = abi.decode(data, (string));
emit Error(error); // Could run out of gas
}
}
```
**Safe pattern:**
```solidity theme={null}
function safeCall(address target) external {
(bool success, bytes memory data) = target.call("");
if (!success) {
// Validate size before decoding
require(data.length <= 1024, "Error too large");
if (data.length >= 4) {
bytes4 errorSig = bytes4(data);
// Handle specific errors
}
}
}
```
### State Reversion Scope
REVERT only reverts current call context:
```solidity theme={null}
contract Parent {
uint256 public value;
function callChild(address child) external {
value = 1; // State change in Parent
try child.doSomething() {
// Success
} catch {
// Child reverted, but Parent's state change persists
}
// value = 1 (Parent state not reverted)
}
}
contract Child {
function doSomething() external {
revert("Failed"); // Only reverts Child's state
}
}
```
### Reentrancy
REVERT doesn't prevent reentrancy:
```solidity theme={null}
// VULNERABLE: Reentrancy still possible
function withdraw() external {
uint256 balance = balances[msg.sender];
// External call before state update
(bool success, ) = msg.sender.call{value: balance}("");
// REVERT doesn't prevent reentrancy if call succeeds
require(success, "Transfer failed");
balances[msg.sender] = 0; // Too late
}
```
**Safe:** Update state before external calls (Checks-Effects-Interactions).
## Compiler Behavior
### Require Statements
```solidity theme={null}
require(condition, "Error message");
```
Compiles to:
```
// Evaluate condition
// Jump if true
PUSH2 continue
JUMPI
// Encode error message
PUSH1 error_offset
PUSH1 error_length
REVERT
continue:
JUMPDEST
```
### Custom Errors
```solidity theme={null}
error CustomError(uint256 value);
if (!condition) {
revert CustomError(42);
}
```
Compiles to:
```
// Evaluate condition
PUSH2 continue
JUMPI
// Encode error selector
PUSH4 0x12345678
PUSH1 0
MSTORE
// Encode parameter
PUSH1 42
PUSH1 0x04
MSTORE
// Revert
PUSH1 0x24
PUSH1 0
REVERT
continue:
JUMPDEST
```
### Try-Catch
```solidity theme={null}
try externalCall() {
// Success
} catch Error(string memory reason) {
// Handle revert with string
} catch (bytes memory lowLevelData) {
// Handle other failures
}
```
Caller receives REVERT data and decodes based on error type.
## Hardfork History
### Pre-Byzantium (Frontier, Homestead, Tangerine Whistle, Spurious Dragon)
**No REVERT opcode:**
* Only INVALID (0xfe) for reverting
* Consumed all gas
* No error data
* Poor UX
### Byzantium (EIP-140)
**REVERT introduced:**
* Opcode 0xfd
* Refunds remaining gas
* Returns error data
* Graceful failure handling
**Impact:**
* Better error messages
* Gas efficiency
* Improved debugging
* Custom errors possible
### Post-Byzantium (Constantinople → Cancun)
**No changes to REVERT:**
* Behavior stable since Byzantium
* Foundation for Solidity 0.8.4+ custom errors
* Essential for modern error handling
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.4 (REVERT instruction)
* [EIP-140: REVERT instruction](https://eips.ethereum.org/EIPS/eip-140)
* [EVM Codes - REVERT](https://www.evm.codes/#fd)
* [Solidity Docs - Error Handling](https://docs.soliditylang.org/en/latest/control-structures.html#error-handling-assert-require-revert-and-exceptions)
* [Solidity Docs - Custom Errors](https://docs.soliditylang.org/en/latest/contracts.html#errors-and-the-revert-statement)
# STOP (0x00)
Source: https://voltaire.tevm.sh/evm/instructions/control-flow/stop
Halt execution successfully with no output data
**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:** `0x00`
**Introduced:** Frontier (EVM genesis)
STOP halts execution successfully without returning any output data. All state changes are preserved, remaining gas is consumed, and execution terminates with a success status.
This is the simplest termination opcode - equivalent to falling off the end of bytecode or explicitly signaling completion without a return value.
## Specification
**Stack Input:** None
**Stack Output:** None
**Gas Cost:** 0 (execution halted before gas consumption)
**Operation:**
```
frame.stopped = true
return success
```
## Behavior
STOP immediately terminates execution:
1. Sets execution state to stopped
2. Preserves all state changes (storage, logs, balance transfers)
3. Returns no output data (empty return buffer)
4. Remaining gas is NOT refunded (consumed by transaction)
5. Control returns to caller with success status
**Key Characteristics:**
* No stack items consumed or produced
* No memory access
* No output data
* Cannot be reverted (final state)
## Examples
### Basic Stop
```typescript theme={null}
import { createFrame } from '@tevm/voltaire/evm/Frame';
import { handler_0x00_STOP } from '@tevm/voltaire/evm/control';
// Stop execution
const frame = createFrame({
stack: [42n, 123n], // Stack unchanged
gasRemaining: 1000n
});
const err = handler_0x00_STOP(frame);
console.log(err); // null (success)
console.log(frame.stopped); // true
console.log(frame.output); // undefined (no output)
console.log(frame.stack); // [42n, 123n] (unchanged)
console.log(frame.gasRemaining); // 1000n (no gas consumed)
```
### Constructor Pattern
```solidity theme={null}
// Contract constructor that stops after initialization
constructor() {
// Initialize state
owner = msg.sender;
// Constructor bytecode ends with STOP
assembly {
stop() // Halt constructor execution
}
}
```
Compiled bytecode (simplified):
```
// Constructor code
CALLER
PUSH1 0x00
SSTORE
// STOP - end constructor
STOP
```
### Function Without Return
```solidity theme={null}
// Function that doesn't return a value
function setOwner(address newOwner) external {
owner = newOwner;
// Implicit STOP at end (or explicit)
assembly {
stop()
}
}
```
### Explicit Termination
```solidity theme={null}
assembly {
// Perform operations
sstore(0, 42)
// Explicitly stop without returning
stop()
// Code after STOP is unreachable
invalid() // Never executed
}
```
## Gas Cost
**Cost:** 0 gas
STOP is technically free because execution halts immediately. However, the transaction still consumes:
* Base transaction gas (21000)
* Gas for executed opcodes before STOP
* Remaining gas is NOT refunded
**Gas Consumption Example:**
```typescript theme={null}
const frame = createFrame({ gasRemaining: 5000n });
// Execute some operations (consume gas)
frame.gasRemaining -= 100n; // Some operation cost
// STOP - remaining gas is lost
handler_0x00_STOP(frame);
// frame.gasRemaining = 4900n (not refunded to transaction)
```
**Comparison:**
* STOP: 0 gas (halts execution)
* RETURN: Memory expansion cost
* REVERT: Memory expansion cost + refunds remaining gas
## Edge Cases
### Empty Stack
```typescript theme={null}
// STOP works with empty stack (no stack interaction)
const frame = createFrame({ stack: [] });
const err = handler_0x00_STOP(frame);
console.log(err); // null (success)
console.log(frame.stopped); // true
```
### Already Stopped
```typescript theme={null}
// STOP on already-stopped frame (no-op in practice)
const frame = createFrame({ stopped: true });
const err = handler_0x00_STOP(frame);
console.log(frame.stopped); // true
// In real EVM, execution wouldn't reach this point
```
### With Output Buffer
```typescript theme={null}
// STOP ignores any existing output
const frame = createFrame({ output: new Uint8Array([1, 2, 3]) });
handler_0x00_STOP(frame);
// Output unchanged but ignored by caller
console.log(frame.output); // Uint8Array([1, 2, 3])
// Caller receives empty return data
```
## Common Usage
### Constructor Termination
Every contract constructor ends with STOP (implicit or explicit):
```solidity theme={null}
contract Example {
address public owner;
constructor() {
owner = msg.sender;
// Implicit STOP here
}
}
```
Bytecode pattern:
```
STOP // End constructor
```
### Fallback Without Return
```solidity theme={null}
// Fallback function that accepts ETH but doesn't return
fallback() external payable {
// Log receipt
emit Received(msg.sender, msg.value);
// Implicit STOP (no return statement)
}
```
### State Update Only
```solidity theme={null}
// Function that only updates state
function incrementCounter() external {
counter++;
// Implicit STOP
}
```
Compiles to:
```
PUSH1 0x00
SLOAD
PUSH1 0x01
ADD
PUSH1 0x00
SSTORE
STOP
```
### Unreachable Code Guard
```solidity theme={null}
assembly {
// Switch statement
switch value
case 0 { /* ... */ }
case 1 { /* ... */ }
default {
// This should never execute
invalid() // Or stop() for graceful fail
}
}
```
## Implementation
```typescript theme={null}
/**
* STOP opcode (0x00) - Halt execution
*
* @param frame - Frame instance
* @returns Error if operation fails
*/
export function handler_0x00_STOP(frame: FrameType): EvmError | null {
frame.stopped = true;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0x00_STOP } from './0x00_STOP.js';
import { createFrame } from '../Frame/index.js';
describe('STOP (0x00)', () => {
it('halts execution', () => {
const frame = createFrame({});
const err = handler_0x00_STOP(frame);
expect(err).toBeNull();
expect(frame.stopped).toBe(true);
});
it('does not consume gas', () => {
const frame = createFrame({ gasRemaining: 1000n });
handler_0x00_STOP(frame);
expect(frame.gasRemaining).toBe(1000n);
});
it('does not modify stack', () => {
const frame = createFrame({ stack: [42n, 123n] });
handler_0x00_STOP(frame);
expect(frame.stack).toEqual([42n, 123n]);
});
it('works with empty stack', () => {
const frame = createFrame({ stack: [] });
const err = handler_0x00_STOP(frame);
expect(err).toBeNull();
expect(frame.stopped).toBe(true);
});
it('does not produce output', () => {
const frame = createFrame({});
handler_0x00_STOP(frame);
expect(frame.output).toBeUndefined();
});
});
```
## Security
### State Finality
STOP makes all state changes final - they cannot be reverted:
```solidity theme={null}
// VULNERABLE: No revert on invalid state
function unsafeUpdate(uint256 value) external {
require(value > 0, "Value must be positive");
balance = value; // State changed
// STOP makes this final - no further validation
assembly { stop() }
}
```
**Better approach:**
```solidity theme={null}
// SAFE: All validation before state changes
function safeUpdate(uint256 value) external {
require(value > 0, "Value must be positive");
require(value < MAX_VALUE, "Value too large");
balance = value; // State changed after all checks
}
```
### Gas Griefing
STOP doesn't refund remaining gas - can be used in gas griefing:
```solidity theme={null}
// VULNERABLE: Gas griefing attack
function griefGas() external {
// Caller provides lots of gas
// Execute minimal code
assembly {
stop() // Remaining gas consumed, not refunded
}
// Caller loses unused gas
}
```
**Not a vulnerability in practice:**
* Gas stipend for external calls (2300) prevents this
* Caller controls gas limit
* Only affects caller, not contract state
### STOP vs RETURN
**STOP:**
* No output data
* Simpler (no memory access)
* Slightly cheaper (no memory expansion)
* Use for: void functions, constructors, state-only operations
**RETURN:**
* Returns output data
* Requires memory operations
* Dynamic gas cost
* Use for: view functions, getter methods, function return values
## Compiler Behavior
### Solidity Implicit STOP
Solidity adds STOP at the end of constructor code:
```solidity theme={null}
contract Example {
uint256 public value;
constructor(uint256 _value) {
value = _value;
// Implicit STOP here (separates constructor from runtime)
}
}
```
Bytecode structure:
```
CODECOPY // Copy runtime code to memory
RETURN // Return runtime code for deployment
// Deployed bytecode
```
### Function Without Return
```solidity theme={null}
function voidFunction() external {
// Do something
}
```
Compiles to:
```
STOP // Implicit at end
```
### Unreachable Code Elimination
Compilers eliminate code after STOP:
```solidity theme={null}
assembly {
stop()
sstore(0, 1) // ELIMINATED: unreachable
}
```
Optimized bytecode:
```
STOP
// Code after STOP removed
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.4 (STOP instruction)
* [EVM Codes - STOP](https://www.evm.codes/#00)
* [Solidity Docs - Assembly](https://docs.soliditylang.org/en/latest/assembly.html)
# EVM Instructions
Source: https://voltaire.tevm.sh/evm/instructions/index
Complete reference for all 166 Ethereum Virtual Machine opcode handlers
**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
EVM instructions are the atomic operations that smart contract bytecode compiles to. Voltaire implements all 166 opcodes from the Ethereum Yellow Paper, organized into 11 functional categories.
Each instruction operates on a 256-bit word stack with precise gas costs and well-defined semantics. All implementations are zero-copy, tree-shakeable, and tested against official Ethereum test vectors.
## Complete Instruction Reference
### Arithmetic Operations (0x01-0x0b)
11 opcodes for integer arithmetic with 256-bit overflow semantics:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ----------------------------------------------------- | ---------- | ------------------ | ----------------------------- |
| 0x01 | [ADD](/evm/instructions/arithmetic/add) | 3 | a, b → a+b | Addition with mod 2^256 |
| 0x02 | [MUL](/evm/instructions/arithmetic/mul) | 5 | a, b → a\*b | Multiplication with mod 2^256 |
| 0x03 | [SUB](/evm/instructions/arithmetic/sub) | 3 | a, b → a-b | Subtraction with mod 2^256 |
| 0x04 | [DIV](/evm/instructions/arithmetic/div) | 5 | a, b → a/b | Unsigned division (0 if b=0) |
| 0x05 | [SDIV](/evm/instructions/arithmetic/sdiv) | 5 | a, b → a/b | Signed division |
| 0x06 | [MOD](/evm/instructions/arithmetic/mod) | 5 | a, b → a%b | Unsigned modulo |
| 0x07 | [SMOD](/evm/instructions/arithmetic/smod) | 5 | a, b → a%b | Signed modulo |
| 0x08 | [ADDMOD](/evm/instructions/arithmetic/addmod) | 8 | a, b, N → (a+b)%N | Addition modulo N |
| 0x09 | [MULMOD](/evm/instructions/arithmetic/mulmod) | 8 | a, b, N → (a\*b)%N | Multiplication modulo N |
| 0x0a | [EXP](/evm/instructions/arithmetic/exp) | 10+50/byte | a, b → a^b | Exponentiation |
| 0x0b | [SIGNEXTEND](/evm/instructions/arithmetic/signextend) | 5 | b, x → y | Sign extension |
### Comparison & Logic (0x10-0x15)
6 opcodes for comparison operations returning 0 or 1:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | --------------------------------------------- | --- | ------------- | --------------------- |
| 0x10 | [LT](/evm/instructions/comparison/lt) | 3 | a, b → a \< b | Unsigned less than |
| 0x11 | [GT](/evm/instructions/comparison/gt) | 3 | a, b → a > b | Unsigned greater than |
| 0x12 | [SLT](/evm/instructions/comparison/slt) | 3 | a, b → a \< b | Signed less than |
| 0x13 | [SGT](/evm/instructions/comparison/sgt) | 3 | a, b → a > b | Signed greater than |
| 0x14 | [EQ](/evm/instructions/comparison/eq) | 3 | a, b → a==b | Equality |
| 0x15 | [ISZERO](/evm/instructions/comparison/iszero) | 3 | a → a==0 | Is zero |
### Bitwise Operations (0x16-0x1d)
8 opcodes for bit manipulation:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | -------------------------------------- | --- | ------------------------- | ---------------------- |
| 0x16 | [AND](/evm/instructions/bitwise/and) | 3 | a, b → a\&b | Bitwise AND |
| 0x17 | [OR](/evm/instructions/bitwise/or) | 3 | a, b → a\|b | Bitwise OR |
| 0x18 | [XOR](/evm/instructions/bitwise/xor) | 3 | a, b → a^b | Bitwise XOR |
| 0x19 | [NOT](/evm/instructions/bitwise/not) | 3 | a → \~a | Bitwise NOT |
| 0x1a | [BYTE](/evm/instructions/bitwise/byte) | 3 | i, x → x\[i] | Byte at index |
| 0x1b | [SHL](/evm/instructions/bitwise/shl) | 3 | shift, val → val\<\>shift | Logical shift right |
| 0x1d | [SAR](/evm/instructions/bitwise/sar) | 3 | shift, val → val>>shift | Arithmetic shift right |
### Keccak (0x20)
1 opcode for cryptographic hashing:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ------------------------------------- | --------- | ------------------ | -------------- |
| 0x20 | [SHA3](/evm/instructions/keccak/sha3) | 30+6/word | offset, len → hash | Keccak256 hash |
### Execution Context (0x30-0x3f)
16 opcodes for accessing transaction and account context:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ---------------------------------------------------------- | --------------- | ------------------------------- | --------------------------- |
| 0x30 | [ADDRESS](/evm/instructions/context/address) | 2 | → addr | Current contract address |
| 0x31 | [BALANCE](/evm/instructions/context/balance) | 100/2600 | addr → balance | Account balance |
| 0x32 | [ORIGIN](/evm/instructions/context/origin) | 2 | → addr | Transaction origin |
| 0x33 | [CALLER](/evm/instructions/context/caller) | 2 | → addr | Message sender |
| 0x34 | [CALLVALUE](/evm/instructions/context/callvalue) | 2 | → value | Wei sent with call |
| 0x35 | [CALLDATALOAD](/evm/instructions/context/calldataload) | 3 | offset → data | Load 32 bytes from calldata |
| 0x36 | [CALLDATASIZE](/evm/instructions/context/calldatasize) | 2 | → size | Size of calldata |
| 0x37 | [CALLDATACOPY](/evm/instructions/context/calldatacopy) | 3+3/word | destOffset, offset, len → | Copy calldata to memory |
| 0x38 | [CODESIZE](/evm/instructions/context/codesize) | 2 | → size | Size of contract code |
| 0x39 | [CODECOPY](/evm/instructions/context/codecopy) | 3+3/word | destOffset, offset, len → | Copy code to memory |
| 0x3a | [GASPRICE](/evm/instructions/context/gasprice) | 2 | → price | Transaction gas price |
| 0x3b | [EXTCODESIZE](/evm/instructions/context/extcodesize) | 100/2600 | addr → size | External contract code size |
| 0x3c | [EXTCODECOPY](/evm/instructions/context/extcodecopy) | 100/2600+3/word | addr, destOffset, offset, len → | Copy external code |
| 0x3d | [RETURNDATASIZE](/evm/instructions/context/returndatasize) | 2 | → size | Size of return data |
| 0x3e | [RETURNDATACOPY](/evm/instructions/context/returndatacopy) | 3+3/word | destOffset, offset, len → | Copy return data to memory |
| 0x3f | [EXTCODEHASH](/evm/instructions/context/extcodehash) | 100/2600 | addr → hash | External contract codehash |
### Block Information (0x40-0x4a)
11 opcodes for accessing block context:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | -------------------------------------------------- | --- | --------------- | ---------------------------------------- |
| 0x40 | [BLOCKHASH](/evm/instructions/block/blockhash) | 20 | blockNum → hash | Block hash of recent block |
| 0x41 | [COINBASE](/evm/instructions/block/coinbase) | 2 | → addr | Block miner address |
| 0x42 | [TIMESTAMP](/evm/instructions/block/timestamp) | 2 | → timestamp | Block timestamp |
| 0x43 | [NUMBER](/evm/instructions/block/number) | 2 | → blockNum | Block number |
| 0x44 | [DIFFICULTY](/evm/instructions/block/difficulty) | 2 | → difficulty | Block difficulty (prevrandao post-merge) |
| 0x45 | [GASLIMIT](/evm/instructions/block/gaslimit) | 2 | → limit | Block gas limit |
| 0x46 | [CHAINID](/evm/instructions/block/chainid) | 2 | → chainId | Chain ID |
| 0x47 | [SELFBALANCE](/evm/instructions/block/selfbalance) | 5 | → balance | Current contract balance |
| 0x48 | [BASEFEE](/evm/instructions/block/basefee) | 2 | → baseFee | Block base fee (EIP-1559) |
| 0x49 | [BLOBHASH](/evm/instructions/block/blobhash) | 3 | index → hash | Blob versioned hash (EIP-4844) |
| 0x4a | [BLOBBASEFEE](/evm/instructions/block/blobbasefee) | 2 | → baseFee | Blob base fee (EIP-4844) |
### Stack Operations (0x50, 0x5f-0x9f)
86 opcodes for stack manipulation:
**POP (0x50):** Remove top item (2 gas)
**PUSH0-PUSH32 (0x5f-0x7f):** Push N-byte value onto stack (3 gas)
* 0x5f: PUSH0 (Cancun+)
* 0x60-0x7f: PUSH1 through PUSH32
**DUP1-DUP16 (0x80-0x8f):** Duplicate Nth stack item (3 gas)
* 0x80: DUP1 (duplicate 1st item)
* 0x8f: DUP16 (duplicate 16th item)
**SWAP1-SWAP16 (0x90-0x9f):** Swap top with Nth item (3 gas)
* 0x90: SWAP1 (swap with 2nd item)
* 0x9f: SWAP16 (swap with 17th item)
See [Stack Operations](/evm/instructions/stack) for complete reference.
### Memory Operations (0x51-0x53, 0x5e)
4 opcodes for volatile memory access:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ------------------------------------------- | ------------------ | ------------------------- | ------------------------- |
| 0x51 | [MLOAD](/evm/instructions/memory/mload) | 3+expansion | offset → value | Load 32 bytes from memory |
| 0x52 | [MSTORE](/evm/instructions/memory/mstore) | 3+expansion | offset, value → | Store 32 bytes to memory |
| 0x53 | [MSTORE8](/evm/instructions/memory/mstore8) | 3+expansion | offset, value → | Store 1 byte to memory |
| 0x5e | [MCOPY](/evm/instructions/memory/mcopy) | 3+3/word+expansion | destOffset, offset, len → | Copy memory (Cancun+) |
### Storage Operations (0x54-0x55, 0x5c-0x5d)
4 opcodes for persistent and transient storage:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ------------------------------------------ | --------- | ------------ | ------------------------------------- |
| 0x54 | [SLOAD](/evm/instructions/storage/sload) | 100/2100 | key → value | Load from persistent storage |
| 0x55 | [SSTORE](/evm/instructions/storage/sstore) | 100-20000 | key, value → | Store to persistent storage |
| 0x5c | [TLOAD](/evm/instructions/storage/tload) | 100 | key → value | Load from transient storage (Cancun+) |
| 0x5d | [TSTORE](/evm/instructions/storage/tstore) | 100 | key, value → | Store to transient storage (Cancun+) |
### Control Flow (0x00, 0x56-0x58, 0x5b, 0xf3, 0xfd)
7 opcodes for program flow control:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | --------------------------------------------------- | --- | ------------- | ----------------------- |
| 0x00 | [STOP](/evm/instructions/control-flow/stop) | 0 | → | Halt execution |
| 0x56 | [JUMP](/evm/instructions/control-flow/jump) | 8 | dest → | Jump to destination |
| 0x57 | [JUMPI](/evm/instructions/control-flow/jumpi) | 10 | dest, cond → | Conditional jump |
| 0x58 | [PC](/evm/instructions/control-flow/pc) | 2 | → counter | Program counter |
| 0x5b | [JUMPDEST](/evm/instructions/control-flow/jumpdest) | 1 | → | Jump destination marker |
| 0xf3 | [RETURN](/evm/instructions/control-flow/return) | 0 | offset, len → | Halt and return data |
| 0xfd | [REVERT](/evm/instructions/control-flow/revert) | 0 | offset, len → | Halt and revert state |
### Logging (0xa0-0xa4)
5 opcodes for event emission:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ---------------------------------- | -------------------- | ------------------------------------- | ----------------- |
| 0xa0 | [LOG0](/evm/instructions/log/log0) | 375+375/topic+8/byte | offset, len → | Log with 0 topics |
| 0xa1 | [LOG1](/evm/instructions/log/log1) | 375+375/topic+8/byte | offset, len, topic1 → | Log with 1 topic |
| 0xa2 | [LOG2](/evm/instructions/log/log2) | 375+375/topic+8/byte | offset, len, topic1, topic2 → | Log with 2 topics |
| 0xa3 | [LOG3](/evm/instructions/log/log3) | 375+375/topic+8/byte | offset, len, topic1, topic2, topic3 → | Log with 3 topics |
| 0xa4 | [LOG4](/evm/instructions/log/log4) | 375+375/topic+8/byte | offset, len, topic1-4 → | Log with 4 topics |
### System Operations (0xf0-0xf2, 0xf4-0xf5, 0xfa, 0xff)
7 opcodes for contract interaction:
| Opcode | Name | Gas | Stack Effect | Description |
| ------ | ----------------------------------------------------- | ---------- | ------------------------------------------------------------------ | -------------------------------------- |
| 0xf0 | [CREATE](/evm/instructions/system/create) | 32000 | value, offset, len → addr | Create contract |
| 0xf1 | [CALL](/evm/instructions/system/call) | 100-9000 | gas, addr, value, argsOffset, argsLen, retOffset, retLen → success | Call contract |
| 0xf2 | [CALLCODE](/evm/instructions/system/callcode) | 100-9000 | gas, addr, value, argsOffset, argsLen, retOffset, retLen → success | Call with current context (deprecated) |
| 0xf4 | [DELEGATECALL](/evm/instructions/system/delegatecall) | 100-9000 | gas, addr, argsOffset, argsLen, retOffset, retLen → success | Call preserving sender/value |
| 0xf5 | [CREATE2](/evm/instructions/system/create2) | 32000 | value, offset, len, salt → addr | Create with deterministic address |
| 0xfa | [STATICCALL](/evm/instructions/system/staticcall) | 100-9000 | gas, addr, argsOffset, argsLen, retOffset, retLen → success | Call without state changes |
| 0xff | [SELFDESTRUCT](/evm/instructions/system/selfdestruct) | 5000-30000 | addr → | Destroy contract |
## Gas Cost Details
### Base Costs
All opcodes have minimum gas costs defined in the Yellow Paper:
* **0 gas:** STOP, RETURN (base), REVERT (base)
* **2 gas:** Most context/block info reads
* **3 gas:** Arithmetic, comparison, bitwise, stack ops
* **5 gas:** MUL, DIV, MOD family
* **8 gas:** ADDMOD, MULMOD, JUMP
### Dynamic Costs
Several instructions have variable costs:
* **Memory expansion:** 3 gas/word + quadratic growth
* **SSTORE:** 100-20,000 based on storage slot state
* **EXP:** 50 gas per byte of exponent
* **LOG:** 375 base + 375/topic + 8/byte
* **CALL/CREATE:** 100 base + value transfer + memory + gas forwarding
### Access Lists (EIP-2929)
Post-Berlin, storage and account access costs vary:
* **Cold access:** First access in transaction (2,600 gas for accounts, 2,100 for storage)
* **Warm access:** Subsequent accesses (100 gas)
* **Precompiles:** Always warm
## Stack Machine Model
### Stack Properties
* **Depth:** 1024 elements maximum
* **Word size:** 256 bits (32 bytes)
* **Access:** Only top 16 elements accessible (via DUP/SWAP)
* **Overflow:** Pushing to full stack causes exception
* **Underflow:** Pop from empty stack causes exception
### Stack Notation
`a, b → c` means:
1. Pop `b` from top
2. Pop `a` from new top
3. Push `c` to stack
Example: `ADD` pops two values, pushes their sum.
## Memory Model
### Memory Properties
* **Size:** Grows dynamically, starts at 0
* **Expansion:** Quadratic cost prevents abuse
* **Volatility:** Cleared after transaction
* **Alignment:** Byte-addressable, no alignment requirements
* **Zero-initialized:** Unwritten memory reads as 0
### Memory Gas
`memory_cost = memory_size_word * 3 + memory_size_word^2 / 512`
Expansion cost is incremental from previous maximum size.
## Storage Model
### Persistent Storage (SLOAD/SSTORE)
* **Key-value:** 256-bit keys and values
* **Initial zero:** All slots start at 0
* **Permanence:** Survives transactions
* **Gas complexity:** SSTORE pricing based on:
* Cold vs. warm access (EIP-2929)
* Original value vs. current value (EIP-2200)
* Zero vs. nonzero transitions
### Transient Storage (TLOAD/TSTORE) - Cancun+
* **Ephemeral:** Cleared after transaction
* **Fixed cost:** 100 gas per operation
* **Use case:** Reentrancy guards, temporary state
* **No refunds:** Unlike persistent storage
## Hardfork Changes
### London (EIP-1559)
* **BASEFEE (0x48):** Access to block base fee
### Shanghai
* **PUSH0 (0x5f):** Push constant zero (cheaper than PUSH1)
### Cancun (Dencun)
* **MCOPY (0x5e):** Efficient memory copying
* **TLOAD (0x5c):** Transient storage read
* **TSTORE (0x5d):** Transient storage write
* **BLOBHASH (0x49):** Access to blob versioned hashes
* **BLOBBASEFEE (0x4a):** Blob gas pricing
### Prague (upcoming)
* **BLS precompiles:** 0x0B-0x13 (see [Precompiles](/evm/precompiles))
## Implementation
### TypeScript
```typescript theme={null}
import * as Instructions from '@tevm/voltaire/evm/instructions';
// Stack operations
const stack = new Stack();
Instructions.Arithmetic.add(stack); // Performs ADD
Instructions.Stack.push(stack, 42n); // Push value
const result = Instructions.Stack.pop(stack);
// Memory operations
const memory = new Memory();
Instructions.Memory.mstore(memory, 0n, value);
const loaded = Instructions.Memory.mload(memory, 0n);
```
### Zig
```zig theme={null}
const std = @import("std");
const instructions = @import("evm").instructions;
pub fn execute(opcode: u8, ctx: *ExecutionContext) !void {
switch (opcode) {
0x01 => try instructions.arithmetic.add(ctx.stack),
0x02 => try instructions.arithmetic.mul(ctx.stack),
// ... handle all 166 opcodes
else => return error.InvalidOpcode,
}
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Formal EVM specification
* **[evm.codes](https://www.evm.codes/)** - Interactive opcode reference
* **[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)** - Gas cost increases for state access
* **[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)** - Base fee and BASEFEE opcode
* **[EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)** - Transient storage (Cancun)
## Related Documentation
* [EVM Overview](/evm) - Complete EVM architecture
* [Precompiles](/evm/precompiles) - Precompiled contracts
* [Bytecode](/primitives/bytecode) - Bytecode analysis and parsing
* [Gas Constants](/primitives/gas-constants) - Gas cost definitions
# Keccak256 (SHA3)
Source: https://voltaire.tevm.sh/evm/instructions/keccak/index
Cryptographic hashing opcodes for computing Keccak-256 digests on arbitrary data
**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
Keccak-256 is the cryptographic hash function at the core of Ethereum. Despite being named "SHA3" in the EVM, it is actually the original Keccak-256 specification (not the NIST-standardized SHA3-256, which differs slightly).
**1 opcode:**
* **0x20** - SHA3/KECCAK256 - Compute Keccak-256 hash of memory region
## Why "SHA3" but Actually Keccak-256?
Ethereum adopted the original Keccak-256 algorithm before NIST finalized and modified the Secure Hash Algorithm 3 (SHA3) standard. NIST's final SHA3-256 includes different padding and constants than Keccak-256.
**Key difference:**
* **Ethereum/Keccak256:** Domain separation suffix = 0x01
* **NIST SHA3-256:** Domain separation suffix = 0x06
This means `keccak256("data")` in Solidity produces a different hash than `SHA3_256("data")` from crypto libraries expecting the NIST standard. Ethereum locked in Keccak-256 permanently at genesis to avoid breaking existing contracts.
## Specifications
| Opcode | Name | Gas | Stack In → Out | Description |
| ------ | ------------------------------------- | -------------------- | ------------------- | --------------------------------------- |
| 0x20 | [SHA3](/evm/instructions/keccak/sha3) | 30 + 6/word + memory | offset, size → hash | Keccak-256(memory\[offset:offset+size]) |
## Usage in Smart Contracts
Keccak-256 is the primary hash function for:
1. **Function Selectors** - First 4 bytes of `keccak256("functionName(argTypes)")`
```solidity theme={null}
bytes4 selector = bytes4(keccak256("transfer(address,uint256)"));
// selector = 0xa9059cbb
```
2. **Event Signatures** - `indexed` topic hashes
```solidity theme={null}
bytes32 eventSig = keccak256("Transfer(address,address,uint256)");
```
3. **Storage Keys** - Deterministic key generation
```solidity theme={null}
mapping(address => uint256) balances;
// Key for balances[0x123...] = keccak256(abi.encode(0x123..., 0))
```
4. **State Root Computation** - Merkle tree hashing for account state
5. **Transaction Hashing** - Hash of transaction data for signatures
6. **Commit-Reveal Schemes** - Hiding data with keccak256(data + secret)
## Gas Model
Base cost: 30 gas
Per-word cost: 6 gas per 32-byte word (rounded up)
Memory expansion: Charged for accessing memory region
**Formula:** `30 + 6 * ceil(size / 32) + memory_expansion_cost`
**Examples:**
* Empty data: 30 gas (base only)
* 1 byte: 30 + 6\*1 = 36 gas (rounded to 1 word)
* 32 bytes: 30 + 6\*1 = 36 gas (exactly 1 word)
* 33 bytes: 30 + 6\*2 = 42 gas (rounded to 2 words)
* 256 bytes: 30 + 6\*8 = 78 gas (8 words)
## Implementation
### TypeScript
```typescript theme={null}
import { sha3 } from '@tevm/voltaire/evm/instructions/keccak';
// Hash arbitrary memory region
const result = sha3(frame);
if (result) {
// Handle error
return result;
}
// Stack now contains: keccak256(memory[offset:offset+size])
const hash = frame.stack[frame.stack.length - 1];
```
### Zig
```zig theme={null}
const evm = @import("evm");
pub fn executeKeccak(frame: *FrameType) FrameType.EvmError!void {
const keccakHandlers = evm.instructions.keccak.Handlers(FrameType);
try keccakHandlers.sha3(frame);
}
```
## Special Cases
### Empty Input
Hashing 0 bytes returns the constant Keccak-256 of empty data:
```
keccak256("") = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
```
This is computed once and cached (no memory access needed).
### Zero Bytes in Memory
Uninitialized memory reads as zeros:
```solidity theme={null}
// Memory not written to
bytes32 hash = keccak256(""); // Only if size=0
// Reading uninitialized memory region
bytes memory empty = new bytes(10); // 10 zero bytes
bytes32 hash2 = keccak256(empty); // Hash of 10 zero bytes (NOT the empty hash)
```
## Security
### Preimage Resistance
Keccak-256 is a cryptographically secure one-way function:
* Given hash `h`, finding data such that `keccak256(data) = h` requires \~2^256 operations
* Used for security-critical operations (transaction hashing, signature verification)
### Collision Resistance
Finding two different inputs with the same Keccak-256 hash requires \~2^128 operations (birthday bound). Ethereum relies on this for state roots and merkle trees.
### Length Extension
Keccak-256 is NOT vulnerable to length extension attacks (unlike SHA-1/SHA-256). Safe to use for:
* Message authentication without additional nonce
* Deterministic key derivation
### Hash-Based Randomness
**⚠️ WARNING:** Do NOT use `keccak256(block.timestamp, block.number)` for randomness—this is predictable:
```solidity theme={null}
// WRONG: Predictable by miners/validators
bytes32 randomness = keccak256(abi.encodePacked(block.timestamp));
// BETTER: Use commit-reveal or VRF
// Requires external oracle or multi-transaction protocol
```
## References
* **[EVM Codes - KECCAK256](https://www.evm.codes/#20)** - Interactive reference
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.1 (Cryptographic Functions)
* **[Keccak Specification](https://keccak.team/keccak_specs_summary.html)** - Official Keccak docs
* **[NIST SHA3 Standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf)** - Shows difference from Ethereum's Keccak
* **[Solidity Docs - keccak256](https://docs.soliditylang.org/en/latest/units-and-global-variables.html#mathematical-and-cryptographic-functions)** - Solidity wrapper
## Related Documentation
* [SHA256 Precompile](/evm/precompiles/sha256) - Alternative hash function (rarely used in Ethereum)
* [Keccak256 Cryptography Module](/crypto/keccak256/index) - Full Keccak-256 implementation details
* [ABI Encoding](/primitives/abi/fundamentals) - Uses Keccak-256 for function selectors
* [Transaction Hashing](/primitives/transaction/hashing) - Keccak-256 of transaction data
# SHA3 (0x20)
Source: https://voltaire.tevm.sh/evm/instructions/keccak/sha3
Keccak-256 opcode that hashes arbitrary memory regions
**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:** `0x20`
**Introduced:** Frontier (EVM genesis)
SHA3/KECCAK256 computes the Keccak-256 cryptographic hash of a memory region. Despite its name referencing SHA3, this opcode implements the original Keccak-256 algorithm, not the NIST-standardized SHA3.
This operation is essential for:
* Computing function selectors (first 4 bytes of `keccak256(signature)`)
* Hashing event data and topics
* Generating storage keys
* Implementing authentication schemes
## Specification
**Stack Input:**
```
offset (top - memory byte offset)
size (number of bytes to hash)
```
**Stack Output:**
```
hash (256-bit Keccak-256 digest as uint256)
```
**Gas Cost:**
```
30 (base) + 6 * ceil(size / 32) (word cost) + memory_expansion_cost
```
**Operation:**
```typescript theme={null}
data = memory[offset : offset + size]
hash = keccak256(data) // Actual Keccak-256, not NIST SHA3-256
push hash to stack
```
## Behavior
SHA3 reads a variable-length byte sequence from memory, computes its Keccak-256 hash, and pushes the result to the stack:
1. **Pop operands:** Remove `offset` and `size` from stack (in that order)
2. **Validate:** Ensure offset/size fit in u32 range; calculate gas costs
3. **Charge gas:** Base (30) + per-word (6 \* ceil(size/32)) + memory expansion
4. **Expand memory:** If accessing memory beyond current size, allocate word-aligned pages
5. **Read data:** Copy bytes `[offset, offset+size)` from memory
6. **Hash:** Compute Keccak-256 digest (32 bytes)
7. **Push result:** Convert hash to u256 (big-endian) and push to stack
8. **Increment PC:** Move to next instruction
Special case: If size=0, return cached hash of empty data (0xc5d2460186f7...) without memory access.
## Examples
### Computing a Function Selector
```typescript theme={null}
import { sha3 } from '@tevm/voltaire/evm/instructions/keccak';
// Hash "transfer(address,uint256)" to get selector
const frame = createFrame();
// Write signature to memory
const sig = "transfer(address,uint256)";
const bytes = new TextEncoder().encode(sig);
for (let i = 0; i < bytes.length; i++) {
frame.memory.set(i, bytes[i]);
}
// Push offset=0, size=25
frame.stack.push(0n); // offset
frame.stack.push(25n); // size
// Execute SHA3
sha3(frame);
// Result: 0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b
// Selector: 0xa9059cbb (first 4 bytes)
```
### Event Topic Hash
```solidity theme={null}
// Computing event signature hash
event Transfer(address indexed from, address indexed to, uint256 value);
// Solidity computes this during compilation
bytes32 eventSig = keccak256("Transfer(address,address,uint256)");
// = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
```
### Storage Key Generation
```solidity theme={null}
// Mapping storage key: keccak256(abi.encode(key, slot))
mapping(address => uint256) balances; // slot 0
// Key for balances[0x123...] is:
// keccak256(abi.encodePacked(0x123..., 0))
// In EVM assembly:
// PUSH20 0x123... // address
// PUSH1 0 // slot
// MSTORE // store address at mem[0:20]
// MSTORE // store slot at mem[20:32]
// PUSH1 32 // size = 32 bytes (address + slot)
// PUSH0 // offset = 0
// SHA3 // compute keccak256(addr || slot)
```
## Gas Cost Calculation
### Base Gas
All SHA3 operations cost minimum 30 gas (GasKeccak256Base).
### Per-Word Gas
Additional 6 gas per 32-byte word (rounded up):
```typescript theme={null}
function wordCount(bytes) {
return Math.ceil(bytes / 32);
}
function sha3Gas(size) {
const baseGas = 30;
const wordGas = 6 * wordCount(size);
return baseGas + wordGas;
}
// Examples:
sha3Gas(0) // 30 + 0 = 30
sha3Gas(1) // 30 + 6 = 36 (rounds up to 1 word)
sha3Gas(32) // 30 + 6 = 36 (exactly 1 word)
sha3Gas(33) // 30 + 12 = 42 (rounds up to 2 words)
sha3Gas(64) // 30 + 12 = 42 (exactly 2 words)
sha3Gas(65) // 30 + 18 = 48 (rounds up to 3 words)
```
### Memory Expansion Cost
Reading memory beyond current size triggers expansion cost:
```typescript theme={null}
function memoryExpansionCost(currentSize, accessEnd) {
const newSize = Math.ceil(accessEnd / 32) * 32; // Word-align
if (newSize <= currentSize) return 0;
// Quadratic cost: (newWords^2 - oldWords^2) / 512 + (newWords - oldWords) * 3
const oldWords = currentSize / 32;
const newWords = newSize / 32;
return (newWords * newWords - oldWords * oldWords) / 512
+ (newWords - oldWords) * 3;
}
// Example: Read 10 bytes at offset 0 (requires 1 word = 32 bytes)
memoryExpansionCost(0, 10) // (1 - 0)/512 + (1 - 0)*3 = 3
// Example: Read 1 byte at offset 1000000 (requires 31251 words)
// Cost is thousands of gas due to quadratic growth
```
### Total Cost
```
totalGas = baseGas + wordGas + memoryExpansionCost
```
## Common Usage
### Event Signatures
```solidity theme={null}
event Transfer(address indexed from, address indexed to, uint256 value);
// Topic 0 = keccak256("Transfer(address,address,uint256)")
event Approval(address indexed owner, address indexed spender, uint256 value);
// Topic 0 = keccak256("Approval(address,address,uint256)")
```
### Function Selectors
```solidity theme={null}
interface ERC20 {
// Selector = keccak256("transfer(address,uint256)")[0:4]
function transfer(address to, uint256 amount) external returns (bool);
// Selector = keccak256("approve(address,uint256)")[0:4]
function approve(address spender, uint256 amount) external returns (bool);
}
```
### State Root Hashing
Merkle tree construction hashes account storage:
```
hash(account) = keccak256(nonce || balance || storageRoot || codeHash)
```
### Commit-Reveal Pattern
Prevents transaction front-running:
```solidity theme={null}
// Phase 1: Commit
bytes32 commitment = keccak256(abi.encode(secret, value));
// Phase 2: Reveal (in later block)
require(keccak256(abi.encode(secret, value)) == commitment, "Invalid reveal");
```
### Access Control (Legacy)
```solidity theme={null}
// Mapping role -> account -> bool
mapping(bytes32 => mapping(address => bool)) roles;
// ADMIN_ROLE = keccak256("ADMIN_ROLE")
bytes32 constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
// Check admin
require(roles[ADMIN_ROLE][msg.sender], "Not admin");
```
## Implementation
```typescript theme={null}
/**
* SHA3/KECCAK256 opcode (0x20) - Hash memory region
*/
export function sha3(frame: FrameType): EvmError | null {
// Pop offset and size from stack
const offsetResult = popStack(frame);
if (offsetResult.error) return offsetResult.error;
const offset = offsetResult.value;
const lengthResult = popStack(frame);
if (lengthResult.error) return lengthResult.error;
const length = lengthResult.value;
// Validate fit in safe integer range
if (offset > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
if (length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const off = Number(offset);
const len = Number(length);
// Calculate gas: base (30) + word_count * per_word (6)
const wordCount = len === 0 ? 0n : BigInt(Math.ceil(len / 32));
const dynamicGas = 30n + 6n * wordCount;
// Charge gas
const gasErr = consumeGas(frame, dynamicGas);
if (gasErr) return gasErr;
// Charge memory expansion
if (len > 0) {
const endBytes = off + len;
const memCost = memoryExpansionCost(frame, endBytes);
const memGasErr = consumeGas(frame, memCost);
if (memGasErr) return memGasErr;
// Update memory size
const alignedSize = Math.ceil(endBytes / 32) * 32;
if (alignedSize > frame.memorySize) {
frame.memorySize = alignedSize;
}
}
// Handle empty data
if (len === 0) {
const emptyHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470n;
const pushErr = pushStack(frame, emptyHash);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
// Read data from memory
const data = new Uint8Array(len);
for (let i = 0; i < len; i++) {
data[i] = readMemory(frame, off + i);
}
// Compute Keccak-256 hash
const hashBytes = hash(data);
// Convert to u256 (big-endian)
let hashValue = 0n;
for (let i = 0; i < 32; i++) {
hashValue = (hashValue << 8n) | BigInt(hashBytes[i]);
}
// Push result
const pushErr = pushStack(frame, hashValue);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { sha3 } from './0x20_SHA3.js';
describe('SHA3 (0x20)', () => {
it('hashes empty data', () => {
const frame = createFrame([0n, 0n]);
expect(sha3(frame)).toBeNull();
expect(frame.stack[0]).toBe(
0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470n
);
});
it('hashes "hello world"', () => {
const frame = createFrame();
const data = new TextEncoder().encode("hello world");
for (let i = 0; i < data.length; i++) {
frame.memory.set(i, data[i]);
}
frame.stack.push(11n, 0n);
expect(sha3(frame)).toBeNull();
expect(frame.stack[0]).toBe(
0x47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fadn
);
});
it('charges correct gas', () => {
const frame = createFrame([32n, 0n], 100n);
sha3(frame);
expect(frame.gasRemaining).toBe(100n - 36n); // 30 + 6*1 word
});
it('expands memory correctly', () => {
const frame = createFrame([10n, 0n]);
expect(frame.memorySize).toBe(0);
sha3(frame);
expect(frame.memorySize).toBe(32); // 1 word
});
it('handles offset correctly', () => {
const frame = createFrame();
const data = new TextEncoder().encode("test");
for (let i = 0; i < data.length; i++) {
frame.memory.set(100 + i, data[i]);
}
frame.stack.push(4n, 100n);
sha3(frame);
expect(frame.stack[0]).toBe(
0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658n
);
});
});
```
## Security
### Preimage Resistance
Keccak-256 is a cryptographic one-way function: finding input `x` given `keccak256(x) = h` requires \~2^256 operations.
Used securely for:
* Transaction hashing and signature verification
* State root computation
* Storage key generation
### Collision Resistance
Finding two different inputs with the same hash requires \~2^128 operations (birthday paradox bound). This guarantees:
* Merkle tree integrity for account storage
* Uniqueness of function selectors (extremely unlikely to collide accidentally)
### Domain Separation (Keccak vs NIST SHA3)
**Critical:** Ethereum uses Keccak-256, NOT NIST SHA3-256. Never assume compatibility:
```typescript theme={null}
// These are DIFFERENT:
const evmHash = keccak256("data"); // Ethereum opcode
const nistHash = sha3_256("data"); // NIST standard (with 0x06 padding)
// evmHash !== nistHash
```
### Predictable Randomness Anti-Pattern
**⚠️ NEVER use for randomness:**
```solidity theme={null}
// WRONG: Predictable by miners/validators
bytes32 randomness = keccak256(abi.encodePacked(block.timestamp, msg.sender));
// Miners can choose when to include transaction, or validator can reorder
// CORRECT: Use Chainlink VRF or similar oracle
```
## Edge Cases
### Maximum Memory Access
```typescript theme={null}
// SHA3 with very large size triggers quadratic memory expansion cost
const frame = createFrame();
frame.stack.push(0x100000n); // 1MB of data
frame.stack.push(0n); // offset 0
// Gas cost is astronomical due to memory expansion
// Even with large gas limit, operation may fail
```
### Uninitialized Memory Reads
```solidity theme={null}
// Reading from uninitialized memory returns zeros
bytes memory empty = new bytes(10); // 10 zero bytes (not the same as "")
bytes32 hash1 = keccak256(""); // = 0xc5d2460186f7...
bytes32 hash2 = keccak256(empty); // Different (hash of 10 zeros)
assert(hash1 != hash2);
```
### Integer Overflow Prevention
Stack values are u256, memory offsets are u32. Validation ensures no overflow:
```typescript theme={null}
// If offset + size > 2^32, operation fails
// This prevents integer overflow in memory address calculation
```
## Benchmarks
Gas costs reflect computational and memory expenses:
| Input Size | Words | Base Gas | Word Gas | Memory | Total | Per Byte |
| ---------- | ----- | -------- | -------- | ------ | ----- | -------- |
| 0 bytes | 0 | 30 | 0 | 3 | 33 | - |
| 1 byte | 1 | 30 | 6 | 3 | 39 | 39.0 |
| 32 bytes | 1 | 30 | 6 | 3 | 39 | 1.2 |
| 64 bytes | 2 | 30 | 12 | 6 | 48 | 0.75 |
| 256 bytes | 8 | 30 | 48 | 12 | 90 | 0.35 |
| 1024 bytes | 32 | 30 | 192 | 48 | 270 | 0.26 |
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.1 (Cryptographic Functions)
* **[evm.codes - SHA3](https://www.evm.codes/#20)** - Interactive reference
* **[Keccak Team](https://keccak.team/)** - Official Keccak documentation
* **[NIST SHA3 Standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf)** - Shows differences from Ethereum's Keccak
## Related Documentation
* [Keccak256 Cryptography](/crypto/keccak256/index) - Full implementation details
* [Arithmetic Operations](/evm/instructions/arithmetic) - Stack-based math
* [Memory Operations](/evm/instructions/memory) - Memory read/write opcodes
* [SHA256 Precompile](/evm/precompiles/sha256) - Alternative hash function
# LOG Instructions (0xa0-0xa4)
Source: https://voltaire.tevm.sh/evm/instructions/log/index
Event logging with 0-4 indexed topics for contract communication
**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
**Opcodes:** `0xa0` (LOG0) to `0xa4` (LOG4)\`
**Introduced:** Frontier (EVM genesis)
The LOG family of instructions emits event logs that external systems (off-chain indexers, monitoring services) can capture and process. Each instruction encodes a fixed number of topics (indexed parameters) and flexible data, enabling efficient event filtering without on-chain computation.
## Instruction Set
| Opcode | Name | Topics | Stack Items |
| ------ | ---- | ------ | -------------------------------------------------- |
| 0xa0 | LOG0 | 0 | 2 (offset, length) |
| 0xa1 | LOG1 | 1 | 3 (offset, length, topic0) |
| 0xa2 | LOG2 | 2 | 4 (offset, length, topic0, topic1) |
| 0xa3 | LOG3 | 3 | 5 (offset, length, topic0, topic1, topic2) |
| 0xa4 | LOG4 | 4 | 6 (offset, length, topic0, topic1, topic2, topic3) |
## Gas Cost
All LOG instructions cost:
```
375 gas (base)
+ 375 gas per topic
+ 8 gas per byte of data
```
**Examples:**
* LOG0 with empty data: 375 gas
* LOG1 with 32 bytes: 375 + 375 + 256 = 1006 gas
* LOG4 with 64 bytes: 375 + (4 × 375) + 512 = 2387 gas
Memory expansion costs apply when reading data beyond current allocation.
## Key Constraints
**EIP-214 (Static Call Protection):**
LOG instructions cannot execute in static call context. Attempting to log during a `STATICCALL` reverts with `StaticCallViolation`.
```solidity theme={null}
// This will revert
function badLog() external view {
// emit event - reverts in view functions
}
```
**Data Limit:**
Data size is limited by available gas and memory. No hard cap exists, but practical limits depend on transaction gas budget.
## Common Usage
### Event Indexing
```solidity theme={null}
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address to, uint256 amount) public {
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount); // Compiler generates LOG2
}
```
### Event Filtering
Off-chain services use topics for fast filtering without parsing all event data:
```typescript theme={null}
// Listen for Transfer events from specific address
const logs = await getLogs({
address: tokenAddress,
topics: [
keccak256("Transfer(address,indexed address,indexed uint256)"),
null, // Match any 'from'
"0xaddressToFilterFor" // Match specific 'to'
]
});
```
### Multiple Events
A transaction can emit multiple logs, which are returned in order:
```solidity theme={null}
event Approval(address indexed owner, address indexed spender, uint256 value);
function approve(address spender, uint256 amount) public {
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount); // LOG2
return true;
}
```
## Implementation Notes
### Topic Encoding
Topics are 256-bit values. For dynamic types (strings, arrays), the keccak256 hash is used:
```solidity theme={null}
event StringLog(string indexed data);
// Topic is keccak256(data), not the string itself
event DynamicLog(uint256[] indexed arr);
// Topic is keccak256(abi.encode(arr)), not individual values
```
### Data vs Topics
* **Topics** (0-4): Indexed parameters, optimized for efficient filtering
* **Data**: Non-indexed parameters, stored but not indexed
```solidity theme={null}
event Transfer(
address indexed from, // Topic 1
address indexed to, // Topic 2
uint256 value // Data (non-indexed)
);
// Generates: LOG2 with topics=[from, to] and data=abi.encode(value)
```
## References
* [LOG Instruction Reference (evm.codes)](https://www.evm.codes/#a0)
* [EIP-214 (New opcode: STATICCALL)](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events Documentation](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9 (Execution Model)
# LOG0 (0xa0)
Source: https://voltaire.tevm.sh/evm/instructions/log/log0
Emit log with no indexed topics
**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:** `0xa0`
**Introduced:** Frontier (EVM genesis)
LOG0 emits a log entry with no indexed topics. Only the event data (non-indexed parameters) is logged, making it useful for simple event tracking where filtering by topics is not needed.
## Specification
**Stack Input:**
```
offset (top)
length
```
**Stack Output:**
```
(none)
```
**Gas Cost:** `375 + (8 × data_length) + memory_expansion_cost`
**Operation:**
```
data = memory[offset : offset + length]
log_entry = { address: msg.sender, topics: [], data: data }
append log_entry to logs
```
## Behavior
LOG0 pops offset and length from the stack, reads data from memory, and appends a log entry:
* **Offset**: Starting position in memory (256-bit value)
* **Length**: Number of bytes to read from memory (256-bit value)
* **Data**: Bytes read from memory, padded with zeros if beyond allocated memory
* **Topics**: Empty array (0 indexed parameters)
### Memory Expansion
If the data range extends beyond current memory allocation, memory expands to word boundaries:
```
new_memory_size = (ceil((offset + length) / 32)) * 32
```
### Static Call Protection
LOG0 cannot execute in static call context (EIP-214):
```solidity theme={null}
function badLog() external view {
// Reverts: StaticCallViolation
}
```
## Examples
### Empty Log
```typescript theme={null}
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)
```
### Log with Data
```typescript theme={null}
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)
```
### Solidity Event with No Topics
```solidity theme={null}
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
```
### Non-Indexed Event Parameters
```solidity theme={null}
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)
}
}
```
## Gas Cost
**Base Cost:** 375 gas
**Data Cost:** 8 gas per byte
**Memory Expansion:** Proportional to new memory range
**Examples:**
* Empty: 375 gas
* 1 byte: 375 + 8 = 383 gas
* 32 bytes: 375 + 256 = 631 gas
* 64 bytes: 375 + 512 + 3 (memory expansion) = 890 gas
## Edge Cases
### Zero-Length Log
```typescript theme={null}
const frame = createFrame({ stack: [100n, 0n] });
handler_0xa0_LOG0(frame);
// Valid: logs empty data, no memory expansion
```
### Large Data
```typescript theme={null}
const frame = createFrame({
stack: [0n, 10000n],
gasRemaining: 100000n,
});
handler_0xa0_LOG0(frame);
// Gas: 375 + 80000 (data) + memory expansion
// Result: OutOfGas (insufficient gas)
```
### Out of Bounds Memory
```typescript theme={null}
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
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({ stack: [0n] }); // Only 1 item
const err = handler_0xa0_LOG0(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({
stack: [0n, 0n],
gasRemaining: 374n, // Not enough for base cost
});
const err = handler_0xa0_LOG0(frame);
console.log(err); // { type: "OutOfGas" }
```
## Common Usage
### Simple State Changes
```solidity theme={null}
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
}
}
```
### Unindexed Data Logging
```solidity theme={null}
event ConfigUpdated(string newConfig);
contract Config {
function updateConfig(string memory newConfig) public {
config = newConfig;
emit ConfigUpdated(newConfig); // LOG0 (newConfig is non-indexed)
}
}
```
### Status Events
```solidity theme={null}
event StatusChanged(string status);
contract Service {
function shutdown() public {
isActive = false;
emit StatusChanged("OFFLINE"); // LOG0
}
}
```
## Security
### Cannot Block On-Chain Filtering
Since LOG0 has no topics, external systems cannot efficiently filter by indexed parameters. This is intentional—use LOG1-LOG4 when filtering capability is needed.
```solidity theme={null}
// INEFFICIENT: No topic filtering
event EventWithoutTopics(address user, uint256 amount);
// BETTER: Use indexed parameters
event EventWithTopics(address indexed user, uint256 amount);
```
### Static Call Context Restrictions
LOG0 reverts in view/pure functions or during staticcall operations:
```solidity theme={null}
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
}
}
```
### Memory Boundaries
LOG0 reads memory up to offset + length. Uninitialized memory is zero-filled:
```solidity theme={null}
// 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();
}
```
## Implementation
```typescript theme={null}
/**
* LOG0 opcode (0xa0) - Emit log with no indexed topics
*/
export function handler_0xa0_LOG0(frame: FrameType): EvmError | null {
// Check static call (EIP-214)
if (frame.isStatic) {
return { type: "WriteProtection" };
}
// Check stack (need offset, length)
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
// Pop offset and length
const offset = frame.stack.pop();
const length = frame.stack.pop();
// Validate bounds (u32 max)
if (offset > Number.MAX_SAFE_INTEGER || length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const offsetNum = Number(offset);
const lengthNum = Number(length);
// Calculate gas: 375 base + 8 per byte
const logGas = 375n;
const dataGas = BigInt(lengthNum) * 8n;
const totalGas = logGas + dataGas;
// Memory expansion cost
if (lengthNum > 0) {
const endByte = offsetNum + lengthNum;
const newMemWords = Math.ceil(endByte / 32);
const newMemSize = newMemWords * 32;
const memExpansion = calculateMemoryExpansion(frame.memorySize, newMemSize);
frame.memorySize = newMemSize;
frame.gasRemaining -= BigInt(memExpansion);
}
// Consume gas
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Read data from memory
const data = new Uint8Array(lengthNum);
for (let i = 0; i < lengthNum; i++) {
data[i] = frame.memory.get(offsetNum + i) ?? 0;
}
// Create and append log entry
const logEntry = {
address: frame.address,
topics: [],
data,
};
if (!frame.logs) frame.logs = [];
frame.logs.push(logEntry);
// Increment PC
frame.pc += 1;
return null;
}
```
## Testing
### Test Cases
```typescript theme={null}
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
});
});
```
## References
* [LOG0 Instruction (evm.codes)](https://www.evm.codes/#a0)
* [EIP-214: New opcode STATICCALL](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Logging)
# LOG1 (0xa1)
Source: https://voltaire.tevm.sh/evm/instructions/log/log1
Emit log with 1 indexed topic
**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:** `0xa1`
**Introduced:** Frontier (EVM genesis)
LOG1 emits a log entry with one indexed topic. This is the most common form for single-parameter event filtering, used extensively in token transfer events and simple state changes.
## Specification
**Stack Input:**
```
offset (top)
length
topic0
```
**Stack Output:**
```
(none)
```
**Gas Cost:** `375 + 375 + (8 × data_length) + memory_expansion_cost`
**Operation:**
```
data = memory[offset : offset + length]
topic = stack.pop()
log_entry = { address: msg.sender, topics: [topic], data: data }
append log_entry to logs
```
## Behavior
LOG1 pops three values from the stack:
1. **Offset**: Starting position in memory (256-bit value)
2. **Length**: Number of bytes to read from memory (256-bit value)
3. **Topic0**: First indexed parameter (256-bit value)
The log entry contains one topic for efficient filtering while supporting arbitrary data.
### Topic Values
Topics are stored as full 256-bit values. For dynamic types (strings, arrays, structs), the keccak256 hash is used as the topic:
```solidity theme={null}
event Transfer(address indexed from, address indexed to, uint256 value);
// Topic = keccak256("Transfer(address,indexed address,indexed uint256)")
event Named(string indexed name);
// Topic = keccak256(abi.encode(name))
```
### Memory Expansion
Memory expands in 32-byte words beyond the current allocation, with associated gas costs.
### Static Call Protection
LOG1 cannot execute in static call context (EIP-214).
## Examples
### Basic Topic Logging
```typescript theme={null}
import { handler_0xa1_LOG1 } from '@tevm/voltaire/evm/log';
const frame = createFrame({
address: "0x1234567890123456789012345678901234567890",
stack: [
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan, // topic0
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
const err = handler_0xa1_LOG1(frame);
console.log(err); // null (success)
console.log(frame.logs[0].topics); // [0xaaa...aaan]
console.log(frame.gasRemaining); // 999250n (1000000 - 375 base - 375 topic)
```
### Topic with Data
```typescript theme={null}
const frame = createFrame({
address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
memory: new Map([
[0, 0x00], [1, 0x00], [2, 0x00], [3, 0x10], // 16 in bytes
]),
stack: [
0x1111111111111111111111111111111111111111111111111111111111111111n,
4n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa1_LOG1(frame);
const log = frame.logs[0];
console.log(log.topics); // [0x1111...1111n]
console.log(log.data); // Uint8Array(4) [0, 0, 0, 16]
console.log(frame.gasRemaining); // 999633n (375 + 375 + 32 data + 3 memory)
```
### Solidity Transfer Event
```solidity theme={null}
contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address to, uint256 amount) public returns (bool) {
require(balances[msg.sender] >= amount);
balances[msg.sender] -= amount;
balances[to] += amount;
// Compiler generates LOG2 or LOG1 depending on indexed params
emit Transfer(msg.sender, to, amount);
return true;
}
}
```
### Named Event Log
```solidity theme={null}
event Named(string indexed name, string description);
contract NameRegistry {
function register(string memory name, string memory description) public {
names[msg.sender] = name;
emit Named(name, description);
// LOG1: topic = keccak256(abi.encode(name))
// data = abi.encode(description)
}
}
```
### ID-Based Event
```solidity theme={null}
event ItemCreated(uint256 indexed itemId);
contract ItemFactory {
function create() public returns (uint256) {
uint256 id = nextId++;
items[id] = Item({ creator: msg.sender, timestamp: block.timestamp });
emit ItemCreated(id); // LOG1 with itemId as topic
return id;
}
}
```
## Gas Cost
**Base Cost:** 375 gas
**Topic Cost:** 375 gas (per topic, 1 for LOG1)
**Data Cost:** 8 gas per byte
**Memory Expansion:** Proportional to new memory range
**Examples:**
* Empty data: 375 + 375 = 750 gas
* 1 byte: 750 + 8 = 758 gas
* 32 bytes: 750 + 256 = 1006 gas
* 64 bytes: 750 + 512 + 3 (memory expansion) = 1265 gas
## Edge Cases
### Topic Boundary Values
```typescript theme={null}
const frame = createFrame({
stack: [
(1n << 256n) - 1n, // Max uint256 topic
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa1_LOG1(frame);
const log = frame.logs[0];
console.log(log.topics[0]); // (1n << 256n) - 1n (preserved)
```
### Zero Topic
```typescript theme={null}
const frame = createFrame({
stack: [0n, 0n, 0n],
gasRemaining: 1000000n,
});
handler_0xa1_LOG1(frame);
const log = frame.logs[0];
console.log(log.topics[0]); // 0n
```
### Large Data
```typescript theme={null}
const frame = createFrame({
stack: [0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 5000n, 0n],
gasRemaining: 100000n,
});
const err = handler_0xa1_LOG1(frame);
// Gas: 750 + 40000 (data) = 40750, exceeds 100000 after memory expansion
// Result: OutOfGas or success depending on memory costs
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({ stack: [0n, 0n] }); // Missing topic
const err = handler_0xa1_LOG1(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({
stack: [0x1111111111111111111111111111111111111111111111111111111111111111n, 0n, 0n],
gasRemaining: 749n, // Not enough for base + topic cost
});
const err = handler_0xa1_LOG1(frame);
console.log(err); // { type: "OutOfGas" }
```
## Common Usage
### Event Filtering in Contracts
```solidity theme={null}
event LogIn(address indexed user);
event LogOut(address indexed user);
contract SessionManager {
mapping(address => bool) public isLoggedIn;
function login() public {
isLoggedIn[msg.sender] = true;
emit LogIn(msg.sender); // LOG1: topic = msg.sender
}
function logout() public {
isLoggedIn[msg.sender] = false;
emit LogOut(msg.sender); // LOG1: topic = msg.sender
}
}
```
### Off-Chain Filtering
```typescript theme={null}
// Listen for LogIn events from specific user
const logs = await getLogs({
address: sessionManager.address,
topics: [
keccak256("LogIn(address)"),
"0x1234567890123456789012345678901234567890",
]
});
// Returns only LogIn events where user matches the address
```
### State Change Events
```solidity theme={null}
event Configured(uint256 indexed configId);
contract ConfigManager {
function setConfig(uint256 id, bytes memory data) public {
configs[id] = data;
emit Configured(id); // LOG1
}
}
```
## Security
### Topic Hashing
For dynamic types, ensure consistent hashing:
```solidity theme={null}
event DataLogged(bytes32 indexed dataHash);
function logData(string memory data) public {
// Correct: topic is keccak256 of the data
emit DataLogged(keccak256(abi.encode(data)));
}
```
### Static Call Context
LOG1 reverts in view/pure functions:
```solidity theme={null}
// WRONG: Reverts
function badView(address user) external view {
emit LogIn(user);
}
// CORRECT: Use non-view function
function actuallyLogin(address user) external {
emit LogIn(user);
}
```
### Topic Value Limits
Topics are stored as full 256-bit values. No truncation or padding:
```solidity theme={null}
event LogSmallValue(uint8 indexed value);
// Topic stores full 256-bit value, not just uint8
// If value = 255, topic = 255n (with leading zeros)
```
## Implementation
```typescript theme={null}
/**
* LOG1 opcode (0xa1) - Emit log with 1 indexed topic
*/
export function handler_0xa1_LOG1(frame: FrameType): EvmError | null {
if (frame.isStatic) {
return { type: "WriteProtection" };
}
if (frame.stack.length < 3) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const length = frame.stack.pop();
const topic0 = frame.stack.pop();
if (offset > Number.MAX_SAFE_INTEGER || length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const offsetNum = Number(offset);
const lengthNum = Number(length);
// Gas: 375 base + 375 topic + 8 per byte data
const logGas = 375n + 375n;
const dataGas = BigInt(lengthNum) * 8n;
const totalGas = logGas + dataGas;
// Memory expansion
if (lengthNum > 0) {
const endByte = offsetNum + lengthNum;
const newMemWords = Math.ceil(endByte / 32);
const newMemSize = newMemWords * 32;
const memExpansion = calculateMemoryExpansion(frame.memorySize, newMemSize);
frame.memorySize = newMemSize;
frame.gasRemaining -= BigInt(memExpansion);
}
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Read data
const data = new Uint8Array(lengthNum);
for (let i = 0; i < lengthNum; i++) {
data[i] = frame.memory.get(offsetNum + i) ?? 0;
}
// Create log entry
const logEntry = {
address: frame.address,
topics: [topic0],
data,
};
if (!frame.logs) frame.logs = [];
frame.logs.push(logEntry);
frame.pc += 1;
return null;
}
```
## Testing
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0xa1_LOG1 } from './0xa1_LOG1.js';
describe('LOG1 (0xa1)', () => {
it('emits log with 1 topic and empty data', () => {
const topic = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan;
const frame = createFrame({
stack: [topic, 0n, 0n],
gasRemaining: 1000000n,
});
const err = handler_0xa1_LOG1(frame);
expect(err).toBeNull();
expect(frame.logs).toHaveLength(1);
expect(frame.logs[0].topics).toEqual([topic]);
expect(frame.gasRemaining).toBe(999250n);
});
it('emits log with topic and data', () => {
const frame = createFrame({
memory: new Map([[0, 0xde], [1, 0xad]]),
stack: [0x1111n, 2n, 0n],
gasRemaining: 1000000n,
});
handler_0xa1_LOG1(frame);
const log = frame.logs[0];
expect(log.topics).toEqual([0x1111n]);
expect(log.data).toEqual(new Uint8Array([0xde, 0xad]));
});
it('returns WriteProtection in static context', () => {
const frame = createFrame({ isStatic: true, stack: [0n, 0n, 0n] });
const err = handler_0xa1_LOG1(frame);
expect(err).toEqual({ type: "WriteProtection" });
});
it('returns StackUnderflow with 2 items', () => {
const frame = createFrame({ stack: [0n, 0n] });
const err = handler_0xa1_LOG1(frame);
expect(err).toEqual({ type: "StackUnderflow" });
});
it('handles max uint256 topic', () => {
const maxUint256 = (1n << 256n) - 1n;
const frame = createFrame({
stack: [maxUint256, 0n, 0n],
gasRemaining: 1000000n,
});
handler_0xa1_LOG1(frame);
expect(frame.logs[0].topics[0]).toBe(maxUint256);
});
});
```
## References
* [LOG1 Instruction (evm.codes)](https://www.evm.codes/#a1)
* [EIP-214: New opcode STATICCALL](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events with Indexed Parameters](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Logging)
# LOG2 (0xa2)
Source: https://voltaire.tevm.sh/evm/instructions/log/log2
Emit log with 2 indexed topics
**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:** `0xa2`
**Introduced:** Frontier (EVM genesis)
LOG2 emits a log entry with two indexed topics. This is the standard form for binary relationships like token transfers (from → to) or state transitions with two parameters.
## Specification
**Stack Input:**
```
offset (top)
length
topic0
topic1
```
**Stack Output:**
```
(none)
```
**Gas Cost:** `375 + (2 × 375) + (8 × data_length) + memory_expansion_cost`
**Operation:**
```
data = memory[offset : offset + length]
topic0 = stack.pop()
topic1 = stack.pop()
log_entry = { address: msg.sender, topics: [topic0, topic1], data: data }
append log_entry to logs
```
## Behavior
LOG2 pops four values from the stack:
1. **Offset**: Starting position in memory (256-bit value)
2. **Length**: Number of bytes to read from memory (256-bit value)
3. **Topic0**: First indexed parameter (256-bit value)
4. **Topic1**: Second indexed parameter (256-bit value)
Topics are stored in the order they're popped, enabling efficient filtering by either or both topics.
### Topic Values
Both topics are preserved as full 256-bit values. For dynamic types, keccak256 hashes are used:
```solidity theme={null}
event Transfer(address indexed from, address indexed to, uint256 value);
// topic0 = from (address, zero-extended to 256 bits)
// topic1 = to (address, zero-extended to 256 bits)
// data = abi.encode(value)
```
### Memory Expansion
Memory expands to word boundaries with associated gas costs.
### Static Call Protection
LOG2 cannot execute in static call context (EIP-214).
## Examples
### Transfer Event (Most Common)
```typescript theme={null}
import { handler_0xa2_LOG2 } from '@tevm/voltaire/evm/log';
const frame = createFrame({
address: "0x1234567890123456789012345678901234567890",
stack: [
0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn, // topic1 (to)
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan, // topic0 (from)
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
const err = handler_0xa2_LOG2(frame);
console.log(err); // null (success)
console.log(frame.logs[0].topics);
// [0xaaa...aaan, 0xbbb...bbbn]
console.log(frame.gasRemaining); // 999000n (375 + 750 topic cost)
```
### Transfer with Value Data
```typescript theme={null}
const frame = createFrame({
address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
memory: new Map([
[0, 0x00], [1, 0x00], [2, 0x00], [3, 0x64], // 100 in decimal
]),
stack: [
0x2222222222222222222222222222222222222222222222222222222222222222n,
0x1111111111111111111111111111111111111111111111111111111111111111n,
4n, // length (value = 100)
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
const log = frame.logs[0];
console.log(log.topics);
// [0x1111...1111n, 0x2222...2222n]
console.log(log.data);
// Uint8Array(4) [0, 0, 0, 100]
console.log(frame.gasRemaining);
// 999383n (375 + 750 + 32 data + 3 memory)
```
### ERC20 Token Transfer
```solidity theme={null}
pragma solidity ^0.8.0;
contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
mapping(address => uint256) public balances;
function transfer(address to, uint256 amount) public returns (bool) {
require(balances[msg.sender] >= amount, "Insufficient balance");
balances[msg.sender] -= amount;
balances[to] += amount;
// Compiler generates LOG2 for this event
// topic0 = from (msg.sender)
// topic1 = to
// data = abi.encode(amount)
emit Transfer(msg.sender, to, amount);
return true;
}
}
```
### Swap Event
```solidity theme={null}
event Swap(
address indexed sender,
address indexed recipient,
uint256 amount0In,
uint256 amount1Out
);
function swap(address to, uint256 minOut) public {
uint256 amountOut = getAmountOut(msg.value);
require(amountOut >= minOut);
// LOG2: topic0=sender, topic1=recipient
// data=abi.encode(amountIn, amountOut)
emit Swap(msg.sender, to, msg.value, amountOut);
}
```
### State Transition Event
```solidity theme={null}
event StateChanged(address indexed from, address indexed to);
contract StateMachine {
mapping(bytes32 => address) public currentState;
function transition(bytes32 id, address newState) public {
address oldState = currentState[id];
currentState[id] = newState;
emit StateChanged(oldState, newState); // LOG2
}
}
```
## Gas Cost
**Base Cost:** 375 gas
**Topic Cost:** 375 gas per topic = 750 gas (for 2 topics)
**Data Cost:** 8 gas per byte
**Memory Expansion:** Proportional to new memory range
**Examples:**
* Empty data: 375 + 750 = 1125 gas
* 1 byte: 1125 + 8 = 1133 gas
* 32 bytes: 1125 + 256 = 1381 gas
* 64 bytes: 1125 + 512 + 3 (memory expansion) = 1640 gas
* 256 bytes: 1125 + 2048 + 6 (memory expansion) = 3179 gas
## Edge Cases
### Topic Boundary Values
```typescript theme={null}
const frame = createFrame({
stack: [
(1n << 256n) - 1n, // Max uint256 topic1
0n, // Min uint256 topic0
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
const log = frame.logs[0];
console.log(log.topics); // [0n, (1n << 256n) - 1n]
```
### Identical Topics
```typescript theme={null}
const topic = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn;
const frame = createFrame({
stack: [topic, topic, 0n, 0n],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
const log = frame.logs[0];
console.log(log.topics); // [topic, topic] (allowed, both identical)
```
### Large Data
```typescript theme={null}
const frame = createFrame({
stack: [0xfffn, 0xfffn, 10000n, 0n],
gasRemaining: 100000n,
});
const err = handler_0xa2_LOG2(frame);
// Gas: 1125 + 80000 (data) + memory expansion ≈ 81125
// Result: OutOfGas (insufficient)
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({ stack: [0n, 0n, 0n] }); // Missing topic1
const err = handler_0xa2_LOG2(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({
stack: [0xfffn, 0xfffn, 0n, 0n],
gasRemaining: 1124n, // Not enough for base + both topics
});
const err = handler_0xa2_LOG2(frame);
console.log(err); // { type: "OutOfGas" }
```
## Common Usage
### Event Filtering
```solidity theme={null}
event Transfer(address indexed from, address indexed to, uint256 value);
contract Token {
function transfer(address to, uint256 amount) public {
// ...
emit Transfer(msg.sender, to, amount);
}
}
```
Off-chain filtering:
```typescript theme={null}
// Listen for all transfers FROM a specific address
const logs = await provider.getLogs({
address: token.address,
topics: [
keccak256("Transfer(address,indexed address,indexed uint256)"),
"0xfrom_address" // First topic filter
]
});
// Listen for all transfers TO a specific address
const logsTo = await provider.getLogs({
address: token.address,
topics: [
keccak256("Transfer(address,indexed address,indexed uint256)"),
null, // Any from
"0xto_address" // Second topic filter
]
});
// Listen for transfers between specific addresses
const logsBetween = await provider.getLogs({
address: token.address,
topics: [
keccak256("Transfer(address,indexed address,indexed uint256)"),
"0xfrom_address", // Specific from
"0xto_address" // Specific to
]
});
```
### Dual Authorization
```solidity theme={null}
event Approved(address indexed owner, address indexed spender, uint256 value);
contract ERC20 {
function approve(address spender, uint256 amount) public returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approved(msg.sender, spender, amount); // LOG2
return true;
}
}
```
### Pair Operations
```solidity theme={null}
event LiquidityAdded(
address indexed provider,
address indexed token,
uint256 amount
);
contract LiquidityPool {
function addLiquidity(address token, uint256 amount) public {
// ...
emit LiquidityAdded(msg.sender, token, amount); // LOG2
}
}
```
## Security
### Topic Filtering Security
Topics enable efficient filtering, but are visible off-chain:
```solidity theme={null}
// Sensitive data should NOT be in topics
event BadPractice(address indexed user, string indexed password);
// password hash is visible to anyone reading logs
// Better: hash dynamic data
event GoodPractice(address indexed user, bytes32 passwordHash);
```
### Address Topic Semantics
When filtering by address topics, ensure zero-extension understanding:
```solidity theme={null}
event Log(address indexed addr);
// Topic = addr as uint256 (20 bytes zero-extended to 256 bits)
// Off-chain filtering must match zero-extended form
const logs = await getLogs({
topics: ["0x0000000000000000000000001234567890123456789012345678901234567890"]
});
```
### Static Call Context
LOG2 reverts in view/pure functions:
```solidity theme={null}
// WRONG
function badView(address a, address b) external view {
emit SomeEvent(a, b); // Reverts
}
// CORRECT
function goodNonView(address a, address b) external {
emit SomeEvent(a, b); // Works
}
```
## Implementation
```typescript theme={null}
/**
* LOG2 opcode (0xa2) - Emit log with 2 indexed topics
*/
export function handler_0xa2_LOG2(frame: FrameType): EvmError | null {
if (frame.isStatic) {
return { type: "WriteProtection" };
}
if (frame.stack.length < 4) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const length = frame.stack.pop();
const topic0 = frame.stack.pop();
const topic1 = frame.stack.pop();
if (offset > Number.MAX_SAFE_INTEGER || length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const offsetNum = Number(offset);
const lengthNum = Number(length);
// Gas: 375 base + 750 topics + 8 per byte data
const logGas = 375n + 750n;
const dataGas = BigInt(lengthNum) * 8n;
const totalGas = logGas + dataGas;
// Memory expansion
if (lengthNum > 0) {
const endByte = offsetNum + lengthNum;
const newMemWords = Math.ceil(endByte / 32);
const newMemSize = newMemWords * 32;
const memExpansion = calculateMemoryExpansion(frame.memorySize, newMemSize);
frame.memorySize = newMemSize;
frame.gasRemaining -= BigInt(memExpansion);
}
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Read data
const data = new Uint8Array(lengthNum);
for (let i = 0; i < lengthNum; i++) {
data[i] = frame.memory.get(offsetNum + i) ?? 0;
}
// Create log entry
const logEntry = {
address: frame.address,
topics: [topic0, topic1],
data,
};
if (!frame.logs) frame.logs = [];
frame.logs.push(logEntry);
frame.pc += 1;
return null;
}
```
## Testing
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0xa2_LOG2 } from './0xa2_LOG2.js';
describe('LOG2 (0xa2)', () => {
it('emits log with 2 topics and empty data', () => {
const topic0 = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan;
const topic1 = 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn;
const frame = createFrame({
stack: [topic1, topic0, 0n, 0n],
gasRemaining: 1000000n,
});
const err = handler_0xa2_LOG2(frame);
expect(err).toBeNull();
expect(frame.logs).toHaveLength(1);
expect(frame.logs[0].topics).toEqual([topic0, topic1]);
expect(frame.gasRemaining).toBe(998875n);
});
it('emits log with 2 topics and data', () => {
const frame = createFrame({
memory: new Map([[0, 0xde], [1, 0xad]]),
stack: [0x2222n, 0x1111n, 2n, 0n],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
const log = frame.logs[0];
expect(log.topics).toEqual([0x1111n, 0x2222n]);
expect(log.data).toEqual(new Uint8Array([0xde, 0xad]));
});
it('returns WriteProtection in static context', () => {
const frame = createFrame({ isStatic: true, stack: [0n, 0n, 0n, 0n] });
const err = handler_0xa2_LOG2(frame);
expect(err).toEqual({ type: "WriteProtection" });
});
it('returns StackUnderflow with 3 items', () => {
const frame = createFrame({ stack: [0n, 0n, 0n] });
const err = handler_0xa2_LOG2(frame);
expect(err).toEqual({ type: "StackUnderflow" });
});
it('handles max values for both topics', () => {
const maxUint256 = (1n << 256n) - 1n;
const frame = createFrame({
stack: [maxUint256, maxUint256, 0n, 0n],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
expect(frame.logs[0].topics).toEqual([maxUint256, maxUint256]);
});
it('expands memory correctly with large data', () => {
const frame = createFrame({
stack: [0xfffn, 0xfffn, 100n, 50n],
gasRemaining: 1000000n,
});
handler_0xa2_LOG2(frame);
// Memory expands to cover offset 50 + length 100 = 150 bytes
// Word-aligned to 160 bytes (5 words * 32)
expect(frame.memorySize).toBe(160);
});
});
```
## References
* [LOG2 Instruction (evm.codes)](https://www.evm.codes/#a2)
* [EIP-214: New opcode STATICCALL](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events with Multiple Indexed Parameters](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Logging)
# LOG3 (0xa3)
Source: https://voltaire.tevm.sh/evm/instructions/log/log3
Emit log with 3 indexed topics
**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:** `0xa3`
**Introduced:** Frontier (EVM genesis)
LOG3 emits a log entry with three indexed topics. This enables filtering complex events with multiple dimensional parameters, such as marketplace events involving buyer, seller, and item.
## Specification
**Stack Input:**
```
offset (top)
length
topic0
topic1
topic2
```
**Stack Output:**
```
(none)
```
**Gas Cost:** `375 + (3 × 375) + (8 × data_length) + memory_expansion_cost`
**Operation:**
```
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
```
## Behavior
LOG3 pops five values from the stack:
1. **Offset**: Starting position in memory (256-bit value)
2. **Length**: Number of bytes to read from memory (256-bit value)
3. **Topic0**: First indexed parameter (256-bit value)
4. **Topic1**: Second indexed parameter (256-bit value)
5. **Topic2**: Third indexed parameter (256-bit value)
Topics enable efficient three-dimensional filtering for complex event relationships.
### Topic Values
All three topics are preserved as full 256-bit values. For dynamic types, keccak256 hashes apply.
### Memory Expansion
Memory expands in 32-byte word increments with proportional gas costs.
### Static Call Protection
LOG3 cannot execute in static call context (EIP-214).
## Examples
### Marketplace Event
```typescript theme={null}
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)
```
### Marketplace Transaction with Price
```typescript theme={null}
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)
```
### NFT Transfer Event
```solidity theme={null}
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);
}
}
```
### Approval with Token Event
```solidity theme={null}
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
}
}
```
### Order Placed Event
```solidity theme={null}
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
}
}
```
## Gas Cost
**Base Cost:** 375 gas
**Topic Cost:** 375 gas per topic = 1125 gas (for 3 topics)
**Data Cost:** 8 gas per byte
**Memory Expansion:** Proportional to new memory range
**Examples:**
* Empty data: 375 + 1125 = 1500 gas
* 1 byte: 1500 + 8 = 1508 gas
* 32 bytes: 1500 + 256 = 1756 gas
* 64 bytes: 1500 + 512 + 3 = 2015 gas
* 256 bytes: 1500 + 2048 + 6 = 3554 gas
## Edge Cases
### All Topics Identical
```typescript theme={null}
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)
```
### Mixed Topic Values
```typescript theme={null}
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]
```
### Large Data with Topics
```typescript theme={null}
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
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({ stack: [0n, 0n, 0n, 0n] }); // Only 4 items
const err = handler_0xa3_LOG3(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
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" }
```
## Common Usage
### Multi-Dimensional Filtering
```solidity theme={null}
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
}
}
```
Off-chain filtering:
```typescript theme={null}
// 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"
]
});
```
### Complex State Transitions
```solidity theme={null}
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
}
}
```
### Authorization Events
```solidity theme={null}
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
}
}
```
## Security
### Topic Visibility
All topics are visible off-chain. Do not include sensitive data:
```solidity theme={null}
// BAD: Private data in topics
event BadLog(address indexed user, string indexed password);
// GOOD: Hash sensitive data
event GoodLog(address indexed user, bytes32 passwordHash);
```
### Filtering Semantics
Ensure consistent topic ordering and filtering:
```solidity theme={null}
event Swap(
address indexed buyer,
address indexed seller,
address indexed token
);
// Off-chain: must match exact parameter order
// Topics: [buyer_hash, seller_hash, token]
```
### Static Call Context
LOG3 reverts in view/pure functions:
```solidity theme={null}
// 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
}
```
## Implementation
```typescript theme={null}
/**
* LOG3 opcode (0xa3) - Emit log with 3 indexed topics
*/
export function handler_0xa3_LOG3(frame: FrameType): EvmError | null {
if (frame.isStatic) {
return { type: "WriteProtection" };
}
if (frame.stack.length < 5) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const length = frame.stack.pop();
const topic0 = frame.stack.pop();
const topic1 = frame.stack.pop();
const topic2 = frame.stack.pop();
if (offset > Number.MAX_SAFE_INTEGER || length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const offsetNum = Number(offset);
const lengthNum = Number(length);
// Gas: 375 base + 1125 topics + 8 per byte data
const logGas = 375n + 1125n;
const dataGas = BigInt(lengthNum) * 8n;
const totalGas = logGas + dataGas;
// Memory expansion
if (lengthNum > 0) {
const endByte = offsetNum + lengthNum;
const newMemWords = Math.ceil(endByte / 32);
const newMemSize = newMemWords * 32;
const memExpansion = calculateMemoryExpansion(frame.memorySize, newMemSize);
frame.memorySize = newMemSize;
frame.gasRemaining -= BigInt(memExpansion);
}
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Read data
const data = new Uint8Array(lengthNum);
for (let i = 0; i < lengthNum; i++) {
data[i] = frame.memory.get(offsetNum + i) ?? 0;
}
// Create log entry
const logEntry = {
address: frame.address,
topics: [topic0, topic1, topic2],
data,
};
if (!frame.logs) frame.logs = [];
frame.logs.push(logEntry);
frame.pc += 1;
return null;
}
```
## Testing
```typescript theme={null}
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]);
});
});
```
## References
* [LOG3 Instruction (evm.codes)](https://www.evm.codes/#a3)
* [EIP-214: New opcode STATICCALL](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events with Three Indexed Parameters](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Logging)
# LOG4 (0xa4)
Source: https://voltaire.tevm.sh/evm/instructions/log/log4
Emit log with 4 indexed topics
**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:** `0xa4`
**Introduced:** Frontier (EVM genesis)
LOG4 emits a log entry with four indexed topics, the maximum allowed. This enables filtering events with up to four indexed parameters, supporting complex multi-dimensional queries like buyer-seller-token-amount combinations.
## Specification
**Stack Input:**
```
offset (top)
length
topic0
topic1
topic2
topic3
```
**Stack Output:**
```
(none)
```
**Gas Cost:** `375 + (4 × 375) + (8 × data_length) + memory_expansion_cost`
**Operation:**
```
data = memory[offset : offset + length]
topic0 = stack.pop()
topic1 = stack.pop()
topic2 = stack.pop()
topic3 = stack.pop()
log_entry = { address: msg.sender, topics: [topic0, topic1, topic2, topic3], data: data }
append log_entry to logs
```
## Behavior
LOG4 pops six values from the stack:
1. **Offset**: Starting position in memory (256-bit value)
2. **Length**: Number of bytes to read from memory (256-bit value)
3. **Topic0**: First indexed parameter (256-bit value)
4. **Topic1**: Second indexed parameter (256-bit value)
5. **Topic2**: Third indexed parameter (256-bit value)
6. **Topic3**: Fourth indexed parameter (256-bit value)
This represents the maximum topic capacity, enabling four-dimensional filtering without on-chain computation.
### Topic Values
All four topics are preserved as full 256-bit values. For dynamic types, keccak256 hashes are used.
### Memory Expansion
Memory expands in 32-byte word increments with proportional gas costs.
### Static Call Protection
LOG4 cannot execute in static call context (EIP-214).
## Examples
### Complex Event with Four Dimensions
```typescript theme={null}
import { handler_0xa4_LOG4 } from '@tevm/voltaire/evm/log';
const frame = createFrame({
address: "0x1234567890123456789012345678901234567890",
stack: [
0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddn, // topic3
0xccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccn, // topic2
0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn, // topic1
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan, // topic0
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
const err = handler_0xa4_LOG4(frame);
console.log(err); // null (success)
console.log(frame.logs[0].topics.length); // 4
console.log(frame.gasRemaining);
// 999000n - 375 (base) - 1500 (4 topics)
```
### Marketplace Event with Full Metadata
```typescript theme={null}
const frame = createFrame({
address: "0xmarketplace",
memory: new Map([
[0, 0x00], [1, 0x00], [2, 0x00], [3, 0x00], // Price/metadata
]),
stack: [
0xtoken_id,
0xcurrency_type,
0xseller,
0xbuyer,
4n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa4_LOG4(frame);
const log = frame.logs[0];
console.log(log.topics.length); // 4
console.log(log.topics);
// [buyer, seller, currency_type, token_id]
```
### Order Book Entry
```solidity theme={null}
event OrderCreated(
address indexed maker,
address indexed taker,
address indexed baseToken,
address indexed quoteToken,
uint256 amount
);
contract OrderBook {
function createOrder(
address taker,
address baseToken,
address quoteToken,
uint256 amount
) public {
uint256 orderId = nextOrderId++;
orders[orderId] = Order({
maker: msg.sender,
taker: taker,
baseToken: baseToken,
quoteToken: quoteToken,
amount: amount
});
// Compiler generates LOG4
emit OrderCreated(msg.sender, taker, baseToken, quoteToken, amount);
}
}
```
### MultiHop Swap Event
```solidity theme={null}
event Swap(
address indexed user,
address indexed tokenIn,
address indexed tokenOut,
address indexed pool,
uint256 amountIn
);
contract MultiHopDEX {
function swapMultiHop(
address[] calldata path,
uint256 amountIn
) external {
require(path.length >= 2, "Invalid path");
address tokenIn = path[0];
address tokenOut = path[path.length - 1];
// Swap through each pool
for (uint i = 0; i < path.length - 1; i++) {
address pool = getPool(path[i], path[i + 1]);
amountIn = executeSwap(pool, path[i], path[i + 1], amountIn);
// LOG4: user, tokenIn, tokenOut, pool, amountIn
emit Swap(msg.sender, path[i], path[i + 1], pool, amountIn);
}
}
}
```
### Cross-Chain Bridge Event
```solidity theme={null}
event BridgeTransfer(
address indexed sender,
address indexed recipient,
address indexed token,
uint256 chainId,
uint256 amount
);
contract Bridge {
function bridgeTransfer(
uint256 destChain,
address recipient,
address token,
uint256 amount
) public {
require(supportedChains[destChain], "Unsupported chain");
bridges[msg.sender][token][destChain] += amount;
escrow.lock(token, amount);
// LOG4: all 4 key parameters are indexed
emit BridgeTransfer(msg.sender, recipient, token, destChain, amount);
}
}
```
### Permission Grant Event
```solidity theme={null}
event PermissionGrant(
address indexed grantor,
address indexed grantee,
address indexed resource,
uint256 roleId,
uint256 permissions
);
contract AccessControl {
function grantPermission(
address grantee,
address resource,
uint256 roleId,
uint256 permissions
) public {
require(hasAdmin(msg.sender), "Not admin");
rolePermissions[grantee][resource][roleId] = permissions;
// LOG4: all parameters indexed for fine-grained filtering
emit PermissionGrant(msg.sender, grantee, resource, roleId, permissions);
}
}
```
## Gas Cost
**Base Cost:** 375 gas
**Topic Cost:** 375 gas per topic = 1500 gas (for 4 topics)
**Data Cost:** 8 gas per byte
**Memory Expansion:** Proportional to new memory range
**Examples:**
* Empty data: 375 + 1500 = 1875 gas
* 1 byte: 1875 + 8 = 1883 gas
* 32 bytes: 1875 + 256 = 2131 gas
* 64 bytes: 1875 + 512 + 3 = 2390 gas
* 256 bytes: 1875 + 2048 + 6 = 3929 gas
* 1024 bytes: 1875 + 8192 + 15 = 10082 gas
## Edge Cases
### All Topics Identical
```typescript theme={null}
const topic = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn;
const frame = createFrame({
stack: [topic, topic, topic, topic, 0n, 0n],
gasRemaining: 1000000n,
});
handler_0xa4_LOG4(frame);
const log = frame.logs[0];
console.log(log.topics); // [topic, topic, topic, topic]
```
### Mixed Topic Values
```typescript theme={null}
const frame = createFrame({
stack: [
(1n << 256n) - 1n, // Max
0xaabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccddne, // Mixed
0x1111111111111111111111111111111111111111111111111111111111111111n, // Custom
0n, // Min
0n, // length
0n, // offset
],
gasRemaining: 1000000n,
});
handler_0xa4_LOG4(frame);
const log = frame.logs[0];
// Topics preserved exactly as provided
```
### Large Data with Maximum Topics
```typescript theme={null}
const frame = createFrame({
stack: [
0xfff, 0xfff, 0xfff, 0xfff,
10000n, // length
0n, // offset
],
gasRemaining: 100000n,
});
const err = handler_0xa4_LOG4(frame);
// Gas: 1875 + 80000 (data) + memory expansion
// Result: OutOfGas
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({ stack: [0n, 0n, 0n, 0n, 0n] }); // Only 5 items
const err = handler_0xa4_LOG4(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({
stack: [0xfff, 0xfff, 0xfff, 0xfff, 0n, 0n],
gasRemaining: 1874n, // Not enough for base + all topics
});
const err = handler_0xa4_LOG4(frame);
console.log(err); // { type: "OutOfGas" }
```
## Common Usage
### Four-Dimensional Event Filtering
```solidity theme={null}
event Transaction(
address indexed user,
address indexed from,
address indexed to,
bytes32 indexed txId,
uint256 amount
);
contract Router {
function route(address from, address to, bytes32 txId, uint256 amount) public {
// ... routing logic
emit Transaction(msg.sender, from, to, txId, amount); // LOG4
}
}
```
Off-chain filtering:
```typescript theme={null}
// Listen for transactions by a specific user and pair
const logs = await provider.getLogs({
address: router.address,
topics: [
keccak256("Transaction(address,indexed address,indexed address,indexed bytes32,uint256)"),
"0xuser_address",
"0xfrom_address",
"0xto_address",
// txId can also be filtered here if needed
]
});
```
### Dimensional Data Warehouse
```solidity theme={null}
event DataPoint(
uint256 indexed dimension1,
uint256 indexed dimension2,
uint256 indexed dimension3,
uint256 indexed dimension4,
bytes value
);
contract DataWarehouse {
function logDataPoint(
uint256 d1,
uint256 d2,
uint256 d3,
uint256 d4,
bytes memory value
) public {
emit DataPoint(d1, d2, d3, d4, value); // LOG4
}
}
```
### Maximum Filtering Capability
```solidity theme={null}
// When all 4 topics are indexed, off-chain systems can efficiently:
// 1. Filter by any subset of topics
// 2. Combine filters with AND logic
// 3. Query without parsing event data
event MultiFilter(
address indexed a,
address indexed b,
address indexed c,
bytes32 indexed d
);
```
## Security
### Topic Visibility and Privacy
All topics are visible off-chain. Maximum topics = maximum visibility:
```solidity theme={null}
// All 4 parameters are filterable, searchable, and visible
event BadPractice(
address indexed user,
address indexed password, // DO NOT: hashed passwords in topics
address indexed privateKey, // DO NOT: sensitive keys
address indexed secret // DO NOT: confidential data
);
// BETTER: Hash sensitive values
event GoodPractice(
address indexed user,
bytes32 passwordHash, // Hash sensitive data
bytes32 keyHash,
bytes32 secretHash
);
```
### Filtering Logic
Ensure consistent topic interpretation:
```solidity theme={null}
// Standard pattern: indexed parameters in function signature order
event Action(
address indexed user,
address indexed resource,
address indexed operator,
uint256 timestamp
);
// Off-chain filtering uses topics in same order:
// topics[0] = event signature hash
// topics[1] = user
// topics[2] = resource
// topics[3] = operator
// topics[4] = timestamp
```
### Static Call Context
LOG4 reverts in view/pure functions:
```solidity theme={null}
// WRONG: Reverts in static context
function badView(address a, address b, address c, bytes32 d) external view {
emit Event(a, b, c, d);
}
// CORRECT: State-changing function
function goodNonView(address a, address b, address c, bytes32 d) external {
emit Event(a, b, c, d);
}
```
## Implementation
```typescript theme={null}
/**
* LOG4 opcode (0xa4) - Emit log with 4 indexed topics (maximum)
*/
export function handler_0xa4_LOG4(frame: FrameType): EvmError | null {
if (frame.isStatic) {
return { type: "WriteProtection" };
}
if (frame.stack.length < 6) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const length = frame.stack.pop();
const topic0 = frame.stack.pop();
const topic1 = frame.stack.pop();
const topic2 = frame.stack.pop();
const topic3 = frame.stack.pop();
if (offset > Number.MAX_SAFE_INTEGER || length > Number.MAX_SAFE_INTEGER) {
return { type: "OutOfBounds" };
}
const offsetNum = Number(offset);
const lengthNum = Number(length);
// Gas: 375 base + 1500 topics + 8 per byte data
const logGas = 375n + 1500n;
const dataGas = BigInt(lengthNum) * 8n;
const totalGas = logGas + dataGas;
// Memory expansion
if (lengthNum > 0) {
const endByte = offsetNum + lengthNum;
const newMemWords = Math.ceil(endByte / 32);
const newMemSize = newMemWords * 32;
const memExpansion = calculateMemoryExpansion(frame.memorySize, newMemSize);
frame.memorySize = newMemSize;
frame.gasRemaining -= BigInt(memExpansion);
}
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Read data
const data = new Uint8Array(lengthNum);
for (let i = 0; i < lengthNum; i++) {
data[i] = frame.memory.get(offsetNum + i) ?? 0;
}
// Create log entry
const logEntry = {
address: frame.address,
topics: [topic0, topic1, topic2, topic3],
data,
};
if (!frame.logs) frame.logs = [];
frame.logs.push(logEntry);
frame.pc += 1;
return null;
}
```
## Testing
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { handler_0xa4_LOG4 } from './0xa4_LOG4.js';
describe('LOG4 (0xa4)', () => {
it('emits log with 4 topics and empty data', () => {
const topic0 = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan;
const topic1 = 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbn;
const topic2 = 0xccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccn;
const topic3 = 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddn;
const frame = createFrame({
stack: [topic3, topic2, topic1, topic0, 0n, 0n],
gasRemaining: 1000000n,
});
const err = handler_0xa4_LOG4(frame);
expect(err).toBeNull();
expect(frame.logs).toHaveLength(1);
expect(frame.logs[0].topics).toEqual([topic0, topic1, topic2, topic3]);
expect(frame.gasRemaining).toBe(998125n);
});
it('emits log with 4 topics and data', () => {
const frame = createFrame({
memory: new Map([[0, 0xde], [1, 0xad], [2, 0xbe], [3, 0xef]]),
stack: [0x4444n, 0x3333n, 0x2222n, 0x1111n, 4n, 0n],
gasRemaining: 1000000n,
});
handler_0xa4_LOG4(frame);
const log = frame.logs[0];
expect(log.topics).toEqual([0x1111n, 0x2222n, 0x3333n, 0x4444n]);
expect(log.data).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
});
it('returns WriteProtection in static context', () => {
const frame = createFrame({ isStatic: true, stack: [0n, 0n, 0n, 0n, 0n, 0n] });
const err = handler_0xa4_LOG4(frame);
expect(err).toEqual({ type: "WriteProtection" });
});
it('returns StackUnderflow with 5 items', () => {
const frame = createFrame({ stack: [0n, 0n, 0n, 0n, 0n] });
const err = handler_0xa4_LOG4(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, 0n],
gasRemaining: 1000000n,
});
handler_0xa4_LOG4(frame);
expect(frame.logs[0].topics).toEqual([0n, max, 0n, max]);
});
it('expands memory correctly with large data', () => {
const frame = createFrame({
stack: [0xffff, 0xffff, 0xffff, 0xffff, 1000n, 0n],
gasRemaining: 100000n,
});
handler_0xa4_LOG4(frame);
// Memory expands to cover offset 0 + length 1000 = 1000 bytes
// Word-aligned to 1024 bytes (32 words * 32)
expect(frame.memorySize).toBe(1024);
});
});
```
## References
* [LOG4 Instruction (evm.codes)](https://www.evm.codes/#a4)
* [EIP-214: New opcode STATICCALL](https://eips.ethereum.org/EIPS/eip-214)
* [Solidity Events with Four Indexed Parameters](https://docs.soliditylang.org/en/latest/contracts.html#events)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Logging)
* [Event Indexing Best Practices](https://docs.soliditylang.org/en/latest/contracts.html#events)
# Memory Operations
Source: https://voltaire.tevm.sh/evm/instructions/memory/index
EVM memory opcodes (0x51-0x5e) for loading, storing, and copying memory
**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
Memory operations provide byte-addressable read/write access to the EVM's transient linear memory. Memory is 256-bit word-aligned, zero-initialized, and expands dynamically with quadratic gas costs.
4 opcodes enable:
* **Load:** MLOAD - Read 32-byte word
* **Store:** MSTORE - Write 32-byte word, MSTORE8 - Write single byte
* **Copy:** MCOPY - Copy memory regions (Cancun+, EIP-5656)
Memory is ephemeral within a transaction context and not persisted to state.
## Opcodes
| Opcode | Name | Gas | Stack In → Out | Description |
| ------ | ------------------------------------------- | -------------- | ---------------- | ----------------------------- |
| 0x51 | [MLOAD](/evm/instructions/memory/mload) | 3 + mem | offset → value | Load 32-byte word from memory |
| 0x52 | [MSTORE](/evm/instructions/memory/mstore) | 3 + mem | offset, value → | Write 32-byte word to memory |
| 0x53 | [MSTORE8](/evm/instructions/memory/mstore8) | 3 + mem | offset, value → | Write single byte to memory |
| 0x5e | [MCOPY](/evm/instructions/memory/mcopy) | 3 + mem + copy | dest, src, len → | Copy memory (Cancun+) |
## Memory Expansion
Memory is byte-addressable and expands in 32-byte words. When an operation accesses memory beyond the current size, expansion cost applies:
**Formula:**
```
words_new = ceil(offset + size) / 32
expansion_cost = (words_new)² / 512 + 3 * (words_new - words_old)
```
**Examples:**
* Access bytes 0-31 (1 word): 0 gas (no expansion)
* Access bytes 0-32 (2 words): 3 + 1 = 3 gas expansion
* Access bytes 0-256 (9 words): Quadratic scaling
Memory is always word-aligned. Reading/writing at offset 1 expands to word boundary.
## Memory Model
* **Size:** Byte-addressable, up to 2^256 bytes theoretically (limited by gas)
* **Initialization:** All bytes zero-initialized
* **Atomicity:** 32-byte word operations are atomic
* **Aliasing:** No restriction - memory fully aliasable
* **Scope:** Ephemeral within transaction/call context
## Overlap Handling
MCOPY handles overlapping source/destination regions correctly using temporary copy:
```typescript theme={null}
// Copy with forward overlap: source and destination overlap
// [A B C D E F] -> copy 3 bytes from offset 1 to offset 2
// Result: [A B B C D F]
```
No special ordering needed - uses temporary buffer to avoid in-place issues.
## Gas Costs
Memory operations charge base cost + memory expansion:
| Operation | Base Gas | Memory Cost | Formula |
| --------- | -------- | ---------------- | ------------------------------------------------- |
| MLOAD | 3 | Expansion | 3 + exp(offset+32) |
| MSTORE | 3 | Expansion | 3 + exp(offset+32) |
| MSTORE8 | 3 | Expansion | 3 + exp(offset+1) |
| MCOPY | 3 | Expansion + copy | 3 + exp(max(src+len, dest+len)) + ceil(len/32)\*3 |
Memory expansion is the dominant cost for large operations.
## Common Patterns
### Free Memory Pointer
Solidity maintains free memory pointer at 0x40:
```solidity theme={null}
// Get free memory pointer
let ptr := mload(0x40)
// Allocate memory
mstore(ptr, value)
// Update free pointer
mstore(0x40, add(ptr, 0x20))
```
### Dynamic Array Construction
```solidity theme={null}
assembly {
let offset := 0
// Array header
mstore(offset, length)
offset := add(offset, 0x20)
// Array elements
for { let i := 0 } lt(i, length) { i := add(i, 1) } {
mstore(add(offset, mul(i, 0x20)), element)
}
}
```
### Memory Copying
```solidity theme={null}
// Before EIP-5656 (pre-Cancun)
let dst := 0x80
let src := 0
let len := 32
// Manual copy
for { let i := 0 } lt(i, len) { i := add(i, 1) } {
mstore8(add(dst, i), mload8(add(src, i)))
}
// With MCOPY (Cancun+)
mcopy(0x80, 0, 32)
```
## Implementation
### TypeScript
```typescript theme={null}
import * as Memory from '@tevm/voltaire/evm/instructions/memory';
// Execute memory operations
Memory.mload(frame); // 0x51
Memory.mstore(frame); // 0x52
Memory.mstore8(frame); // 0x53
Memory.mcopy(frame); // 0x5e
```
### Zig
```zig theme={null}
const evm = @import("evm");
const MemoryHandlers = evm.instructions.memory.Handlers(FrameType);
// Execute operations
try MemoryHandlers.mload(frame);
try MemoryHandlers.mstore(frame);
try MemoryHandlers.mstore8(frame);
try MemoryHandlers.mcopy(frame);
```
## Edge Cases
### Zero-Length Operations
```typescript theme={null}
// MCOPY with length 0: only base gas (no expansion, no copy)
mcopy(dest=1000, src=5000, len=0) // 3 gas only
```
### Large Memory Access
```typescript theme={null}
// Accessing 1MB requires significant gas
const largeOffset = 1024 * 1024;
mload(largeOffset); // Quadratic expansion cost
```
### Byte Alignment
```typescript theme={null}
// MLOAD always reads 32 bytes, even at misaligned offset
mload(1) // Reads bytes 1-32, expands to 2 words (64 bytes)
```
## Memory Safety
Memory is isolated per transaction/call context:
* **No persistence:** Memory cleared between calls
* **No cross-contract visibility:** Each call has independent memory
* **No bounds check in application code:** Out-of-memory accesses just allocate and charge gas
Applications must enforce bounds checking explicitly.
## Hardfork Support
* **MLOAD/MSTORE/MSTORE8:** Frontier (genesis)
* **MCOPY:** Cancun (EIP-5656)
MCOPY reverts with InvalidOpcode before Cancun.
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.2 (Memory)
* **[EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)** - MCOPY (Cancun)
* **[evm.codes](https://www.evm.codes/)** - Interactive memory instruction reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - Memory layout and assembly
## Related Documentation
* [Stack Operations](/evm/instructions/stack) - PUSH, DUP, SWAP
* [Storage Operations](/evm/instructions/storage) - SLOAD, SSTORE
* [Gas Constants](/primitives/gas-constants) - Gas cost definitions
# MCOPY (0x5e)
Source: https://voltaire.tevm.sh/evm/instructions/memory/mcopy
Copy memory region (Cancun+, EIP-5656)
**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:** `0x5e`
**Introduced:** Cancun (EIP-5656)
**Deprecated:** Never
MCOPY copies a region of memory from source to destination. It handles overlapping regions correctly using an internal temporary buffer. This is the first memory-to-memory copy opcode in the EVM, replacing manual byte-by-byte loops with a single atomic operation.
Before Cancun, copying memory required loops with MLOAD/MSTORE or MSTORE8, which was inefficient and error-prone for overlapping regions.
## Specification
**Stack Input:**
```
dest (top) - Destination address
src - Source address
len - Number of bytes to copy
```
**Stack Output:**
```
(empty)
```
**Gas Cost:** 3 + memory expansion cost + copy cost
**Copy cost formula:**
```
copy_cost = ceil(len / 32) * 3 (3 gas per word)
```
**Operation:**
```
for i in range(len):
memory[dest + i] = memory[src + i]
```
## Behavior
MCOPY pops three values from stack: dest (top), src (middle), len (bottom). It copies len bytes from src to dest, expanding memory as needed.
* All addresses interpreted as unsigned 256-bit integers
* Copy handles overlapping regions correctly (atomic, not in-place)
* Memory expansion covers both source AND destination ranges
* Zero-length copy (len=0) charges only base gas, no expansion
* Expansion cost quadratic; copy cost linear in words
Stack order note: Different from most opcodes - destination popped first.
## Examples
### Basic Copy
```typescript theme={null}
import { mcopy } from '@tevm/voltaire/evm/instructions/memory';
import { createFrame } from '@tevm/voltaire/evm/Frame';
const frame = createFrame();
// Write source data (bytes 0-31)
for (let i = 0; i < 32; i++) {
frame.memory.set(i, i + 1);
}
frame.stack.push(32n); // len
frame.stack.push(0n); // src
frame.stack.push(64n); // dest
const err = mcopy(frame);
// Check destination has copied data
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(64 + i)); // i + 1
}
console.log(frame.pc); // 1 (incremented)
```
### Zero-Length Copy
```typescript theme={null}
const frame = createFrame();
frame.stack.push(0n); // len (zero)
frame.stack.push(0n); // src
frame.stack.push(0n); // dest
mcopy(frame);
// No memory expansion
console.log(frame.memorySize); // 0
console.log(frame.gasRemaining); // Original - 3 (only base gas)
```
### Forward Overlap (Non-Destructive)
```typescript theme={null}
const frame = createFrame();
// Source data at offset 0-63
for (let i = 0; i < 64; i++) {
frame.memory.set(i, i);
}
// Copy 32 bytes from offset 0 to offset 16
// Result: bytes 0-15 stay same, bytes 16-31 duplicated, bytes 32-63 stay same
frame.stack.push(32n); // len
frame.stack.push(0n); // src
frame.stack.push(16n); // dest
mcopy(frame);
// Verify: bytes 16-31 now contain copy of bytes 0-15
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(16 + i)); // i (copied from src)
}
```
### Backward Overlap (Non-Destructive)
```typescript theme={null}
const frame = createFrame();
// Source data at offset 16-47
for (let i = 0; i < 64; i++) {
frame.memory.set(16 + i, 100 + i);
}
// Copy 32 bytes from offset 16 to offset 0
// Uses temporary buffer - no in-place issues
frame.stack.push(32n); // len
frame.stack.push(16n); // src
frame.stack.push(0n); // dest
mcopy(frame);
// Bytes 0-31 now contain what was at 16-47
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(i)); // 100 + i
}
```
### Exact Overlap (Same Source and Destination)
```typescript theme={null}
const frame = createFrame();
// Write pattern
for (let i = 0; i < 32; i++) {
frame.memory.set(i, i + 50);
}
// Copy to itself
frame.stack.push(32n); // len
frame.stack.push(0n); // src
frame.stack.push(0n); // dest
mcopy(frame);
// Data unchanged
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(i)); // i + 50
}
```
### Large Copy
```typescript theme={null}
const frame = createFrame();
// Write 256 bytes
for (let i = 0; i < 256; i++) {
frame.memory.set(i, i & 0xFF);
}
// Copy 256 bytes from offset 0 to offset 1000
frame.stack.push(256n); // len
frame.stack.push(0n); // src
frame.stack.push(1000n); // dest
mcopy(frame);
// Verify copy
for (let i = 0; i < 256; i++) {
console.log(frame.memory.get(1000 + i)); // i & 0xFF
}
// Memory expanded to cover both ranges
console.log(frame.memorySize); // >= 1256 (word-aligned)
```
## Gas Cost
**Base cost:** 3 gas
**Memory expansion:** Quadratic, covers max(src+len, dest+len)
**Copy cost:** 3 gas per word (rounded up)
**Formula:**
```
words_required_src = ceil((src + len) / 32)
words_required_dest = ceil((dest + len) / 32)
max_words = max(words_required_src, words_required_dest)
expansion_cost = (max_words)² / 512 + 3 * (max_words - words_old)
copy_words = ceil(len / 32)
copy_cost = copy_words * 3
total_cost = 3 + expansion_cost + copy_cost
```
**Examples:**
* **Copy 32 bytes (1 word), no expansion:** 3 + 0 + 3 = 6 gas
* **Copy 64 bytes (2 words), no expansion:** 3 + 0 + 6 = 9 gas
* **Copy 33 bytes (2 words, rounded up):** 3 + 0 + 6 = 9 gas
* **Copy with large expansion:** 3 + exp(max\_range) + copy\_cost
Zero-length copy charges only 3 gas (no expansion, no copy cost).
## Hardfork Availability
MCOPY is only available on **Cancun** and later:
```typescript theme={null}
// Error before Cancun
frame.evm.hardfork = 'Shanghai';
const err = mcopy(frame);
console.log(err); // { type: "InvalidOpcode" }
// Works on Cancun+
frame.evm.hardfork = 'Cancun';
const err = mcopy(frame);
console.log(err); // null (no error)
```
Attempting MCOPY on pre-Cancun chains reverts with InvalidOpcode.
## Edge Cases
### Uninitialized Source
```typescript theme={null}
const frame = createFrame();
// Copy from uninitialized memory (all zeros)
frame.stack.push(32n); // len
frame.stack.push(0n); // src (uninitialized)
frame.stack.push(64n); // dest
mcopy(frame);
// Destination has zeros
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(64 + i)); // 0
}
```
### Massive Offset
```typescript theme={null}
const frame = createFrame({ gasRemaining: 100000000n });
// Copy from very high offset
frame.stack.push(32n); // len
frame.stack.push(10000000n); // src (huge offset)
frame.stack.push(10000064n); // dest
mcopy(frame);
// Memory expands to accommodate (very expensive)
console.log(frame.gasRemaining); // Significantly reduced
```
### Out of Gas During Expansion
```typescript theme={null}
const frame = createFrame({ gasRemaining: 100n });
// Insufficient gas for memory expansion
frame.stack.push(10000n); // len (large)
frame.stack.push(0n); // src
frame.stack.push(10000n); // dest
const err = mcopy(frame);
console.log(err); // { type: "OutOfGas" }
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame();
// Only two values on stack
frame.stack.push(0n);
frame.stack.push(0n);
const err = mcopy(frame);
console.log(err); // { type: "StackUnderflow" }
```
## Common Usage
### Copy Constructor Arguments
```solidity theme={null}
// Copy calldata to memory for processing
assembly {
let calldata_size := calldatasize()
mcopy(0x20, 0, calldata_size) // Copy calldata to memory at 0x20
}
```
### Cache Optimization
```solidity theme={null}
assembly {
// Copy frequently accessed data to free memory for faster access
let cached_offset := mload(0x40)
mcopy(cached_offset, storageSlot, 0x20) // Cache storage value
// Use cached_offset instead of SLOAD
}
```
### Memory Consolidation
```solidity theme={null}
assembly {
// Compact memory layout
let src1 := 0x100
let src2 := 0x200
let dst := mload(0x40)
mcopy(dst, src1, 0x20) // Copy first chunk
mcopy(add(dst, 0x20), src2, 0x20) // Copy second chunk
mstore(0x40, add(dst, 0x40)) // Update free pointer
}
```
### Memory-to-Memory Transfer
```solidity theme={null}
assembly {
// Efficient data transfer between memory regions
let length := mload(sourceAddr) // Get length prefix
// Copy length + data
mcopy(destAddr, sourceAddr, add(0x20, length))
}
```
## Memory Safety
**Copy safety properties:**
* **Atomic:** Entire copy completes without intermediate states visible
* **Non-destructive for overlaps:** Uses temporary buffer internally
* **Initialization:** Uninitialized source reads as zero
* **No side effects:** Doesn't affect storage or state
Memory layout considerations:
```solidity theme={null}
// Good: Managed memory regions
assembly {
let region1 := mload(0x40)
let region2 := add(region1, 0x100)
mcopy(region2, region1, 0x50) // Safe, non-overlapping
mstore(0x40, add(region2, 0x50))
}
// Risky: Overlapping regions without buffer
assembly {
mcopy(0x00, 0x10, 0x20) // Forward overlap (but handled correctly)
}
```
## Implementation
```typescript theme={null}
/**
* MCOPY opcode (0x5e) - Copy memory (Cancun+, EIP-5656)
*/
export function mcopy(frame: FrameType): EvmError | null {
// Check Cancun availability
if (frame.evm.hardfork.isBefore('CANCUN')) {
return { type: "InvalidOpcode" };
}
// Pop stack values (dest, src, len)
if (frame.stack.length < 3) {
return { type: "StackUnderflow" };
}
const dest = frame.stack.pop();
const src = frame.stack.pop();
const len = frame.stack.pop();
// Cast to u32
const destNum = Number(dest);
const srcNum = Number(src);
const lenNum = Number(len);
if (!Number.isSafeInteger(destNum) || !Number.isSafeInteger(srcNum) ||
!Number.isSafeInteger(lenNum) || destNum < 0 || srcNum < 0 || lenNum < 0) {
return { type: "OutOfBounds" };
}
// Zero-length copy: only base gas
if (lenNum === 0) {
frame.gasRemaining -= 3n;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
frame.pc += 1;
return null;
}
// Calculate memory expansion for both ranges
const maxEnd = Math.max(destNum + lenNum, srcNum + lenNum);
const expansionCost = calculateMemoryExpansion(maxEnd);
// Calculate copy cost (3 gas per word)
const copyWords = Math.ceil(lenNum / 32);
const copyCost = copyWords * 3;
// Total gas
const totalGas = 3n + BigInt(expansionCost) + BigInt(copyCost);
frame.gasRemaining -= totalGas;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Expand memory
const alignedSize = Math.ceil(maxEnd / 32) * 32;
frame.memorySize = Math.max(frame.memorySize, alignedSize);
// Copy using temporary buffer to handle overlaps
const temp = new Uint8Array(lenNum);
for (let i = 0; i < lenNum; i++) {
temp[i] = frame.memory.get(srcNum + i) ?? 0;
}
for (let i = 0; i < lenNum; i++) {
frame.memory.set(destNum + i, temp[i]);
}
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { mcopy } from './0x5e_MCOPY.js';
describe('MCOPY (0x5e)', () => {
it('copies memory from source to destination', () => {
const frame = createFrame();
for (let i = 0; i < 32; i++) {
frame.memory.set(i, i + 1);
}
frame.stack.push(32n); // len
frame.stack.push(0n); // src
frame.stack.push(64n); // dest
expect(mcopy(frame)).toBeNull();
for (let i = 0; i < 32; i++) {
expect(frame.memory.get(64 + i)).toBe(i + 1);
}
expect(frame.pc).toBe(1);
});
it('handles zero-length copy', () => {
const frame = createFrame();
frame.stack.push(0n); // len = 0
frame.stack.push(0n); // src
frame.stack.push(0n); // dest
expect(mcopy(frame)).toBeNull();
expect(frame.memorySize).toBe(0); // No expansion
expect(frame.gasRemaining).toBe(999997n); // Only base gas
});
it('handles forward overlap correctly', () => {
const frame = createFrame();
for (let i = 0; i < 64; i++) {
frame.memory.set(i, i);
}
frame.stack.push(32n); // len
frame.stack.push(0n); // src
frame.stack.push(16n); // dest (overlap)
expect(mcopy(frame)).toBeNull();
for (let i = 0; i < 32; i++) {
expect(frame.memory.get(16 + i)).toBe(i);
}
});
it('handles backward overlap correctly', () => {
const frame = createFrame();
for (let i = 0; i < 64; i++) {
frame.memory.set(16 + i, i + 100);
}
frame.stack.push(32n); // len
frame.stack.push(16n); // src
frame.stack.push(0n); // dest (backward overlap)
expect(mcopy(frame)).toBeNull();
for (let i = 0; i < 32; i++) {
expect(frame.memory.get(i)).toBe(i + 100);
}
});
it('charges correct gas for copy', () => {
const frame = createFrame({ gasRemaining: 1000n, memorySize: 128 });
frame.stack.push(32n); // 1 word
frame.stack.push(0n);
frame.stack.push(64n);
expect(mcopy(frame)).toBeNull();
// Base: 3, Copy: 1 word * 3 = 3
expect(frame.gasRemaining).toBe(994n);
});
it('returns InvalidOpcode before Cancun', () => {
const frame = createFrame();
frame.evm.hardfork = 'Shanghai';
frame.stack.push(32n);
frame.stack.push(0n);
frame.stack.push(0n);
expect(mcopy(frame)).toEqual({ type: "InvalidOpcode" });
});
it('returns OutOfGas when insufficient', () => {
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(32n);
frame.stack.push(0n);
frame.stack.push(0n);
expect(mcopy(frame)).toEqual({ type: "OutOfGas" });
});
it('returns StackUnderflow with only 2 items', () => {
const frame = createFrame();
frame.stack.push(0n);
frame.stack.push(0n);
expect(mcopy(frame)).toEqual({ type: "StackUnderflow" });
});
});
```
### Edge Cases Tested
* Basic copy (32 bytes)
* Zero-length copy
* Forward overlap
* Backward overlap
* Exact overlap (src == dest)
* Uninitialized source (zeros)
* Memory expansion
* Copy cost calculation
* Large copies (256+ bytes)
* Hardfork checking
* Stack underflow/overflow
* Out of gas conditions
## Security Considerations
### Overlap Handling
MCOPY correctly handles all overlap scenarios with internal buffering:
```solidity theme={null}
// Safe: Overlapping regions
assembly {
// Bytes 0-63 contain source pattern
mcopy(32, 0, 64) // Copy bytes 0-63 to 32-95 (forward overlap)
// Result: bytes 0-31 unchanged, bytes 32-95 contain copy
}
```
### Memory Exhaustion
Large copies can trigger quadratic memory expansion costs:
```solidity theme={null}
// Expensive: Very large copy
assembly {
mcopy(1000000, 0, 1000000) // Quadratic gas cost
}
// Better: Validate size before copying
require(len < maxSize, "copy too large");
mcopy(dest, src, len);
```
## Benchmarks
MCOPY efficiency gains over manual loops:
**MLOAD/MSTORE loop (32 bytes):**
```
6 ops × 3 gas = 18 gas (base only, no expansion)
```
**MCOPY (32 bytes):**
```
3 (base) + 0 (expansion) + 3 (copy) = 6 gas
```
**3x more efficient** for single-word copies.
Gains increase for larger copies due to reduced opcode overhead.
## References
* **[EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)** - MCOPY specification
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.2 (Memory)
* **[evm.codes - MCOPY](https://www.evm.codes/#5e)** - Interactive reference
* **[Cancun Upgrade](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)** - Hardfork details
# MLOAD (0x51)
Source: https://voltaire.tevm.sh/evm/instructions/memory/mload
Load 32-byte word from memory at given offset
**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:** `0x51`
**Introduced:** Frontier (EVM genesis)
MLOAD reads a 32-byte word from memory at the specified offset. The value is interpreted as a big-endian 256-bit unsigned integer and pushed to the stack. Uninitialized memory reads as zero.
This is the primary mechanism for reading arbitrary data from memory during execution.
## Specification
**Stack Input:**
```
offset (top)
```
**Stack Output:**
```
value (32 bytes read at offset, as uint256)
```
**Gas Cost:** 3 + memory expansion cost
**Operation:**
```
value = memory[offset:offset+32] (big-endian)
```
## Behavior
MLOAD pops an offset from the stack, reads 32 bytes starting at that offset, and pushes the result as a 256-bit value.
* Offset is interpreted as unsigned 256-bit integer (max 2^256 - 1)
* Reads exactly 32 bytes (1 word)
* Uninitialized bytes read as 0x00
* Memory automatically expands to accommodate read (quadratic cost)
* Bytes are combined in big-endian order (byte 0 = most significant)
## Examples
### Basic Load
```typescript theme={null}
import { mload } from '@tevm/voltaire/evm/instructions/memory';
import { createFrame } from '@tevm/voltaire/evm/Frame';
const frame = createFrame();
// Write test data at offset 0
frame.memory.set(0, 0x12);
frame.memory.set(1, 0x34);
frame.memory.set(2, 0x56);
frame.memory.set(3, 0x78);
// ... bytes 4-31 are zero
frame.stack.push(0n); // offset
const err = mload(frame);
console.log(frame.stack[0]); // 0x12345678_00000000_...00000000n
console.log(frame.pc); // 1 (incremented)
```
### Load from Uninitialized Memory
```typescript theme={null}
const frame = createFrame();
frame.stack.push(0n); // offset
mload(frame);
// Uninitialized memory reads as zero
console.log(frame.stack[0]); // 0n
console.log(frame.memorySize); // 32 (expanded to 1 word)
```
### Load with Non-Zero Offset
```typescript theme={null}
const frame = createFrame();
// Write pattern starting at offset 32
for (let i = 0; i < 32; i++) {
frame.memory.set(32 + i, i);
}
frame.stack.push(32n); // offset
mload(frame);
// Result: bytes 0-31 (each byte contains its index)
console.log(frame.stack[0]); // 0x00010203_...1f n
```
### Multiple Reads
```typescript theme={null}
const frame = createFrame();
// Initialize memory
for (let i = 0; i < 64; i++) {
frame.memory.set(i, i);
}
// Read word 1 (bytes 0-31)
frame.stack.push(0n);
mload(frame);
const word1 = frame.stack.pop();
// Read word 2 (bytes 32-63)
frame.stack.push(32n);
mload(frame);
const word2 = frame.stack.pop();
console.log(word1 !== word2); // true (different data)
```
## Gas Cost
**Base cost:** 3 gas (GasFastestStep)
**Memory expansion:** Quadratic based on access range
**Formula:**
```
words_required = ceil((offset + 32) / 32)
expansion_cost = (words_required)² / 512 + 3 * (words_required - words_old)
total_cost = 3 + expansion_cost
```
**Examples:**
* **Reading bytes 0-31:** 1 word, no prior expansion: 3 gas
* **Reading bytes 1-32:** 2 words (rounds up), 1 word prior: 3 + (4 - 1) = 6 gas
* **Reading bytes 0-4095:** \~125 words: 3 + (125² / 512 + expansion) ≈ 3 + 30 = 33 gas
Memory is expensive for large accesses due to quadratic expansion formula.
## Edge Cases
### Byte Alignment
```typescript theme={null}
// Reading at non-word-aligned offset
const frame = createFrame();
// Write at offset 1
frame.memory.set(1, 0xff);
frame.stack.push(1n);
mload(frame);
// Reads bytes 1-32, expands memory to 2 words (64 bytes)
console.log(frame.memorySize); // 64
console.log(frame.stack[0]); // 0xff000000_...00000000n
```
### Maximum Offset
```typescript theme={null}
const frame = createFrame({ gasRemaining: 1000000000n });
const maxOffset = BigInt(Number.MAX_SAFE_INTEGER);
frame.stack.push(maxOffset);
const err = mload(frame);
console.log(err); // May be OutOfGas if expansion is too large
```
### Out of Bounds
```typescript theme={null}
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0n);
const err = mload(frame);
console.log(err); // { type: "OutOfGas" }
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame();
// No offset on stack
const err = mload(frame);
console.log(err); // { type: "StackUnderflow" }
```
## Common Usage
### Loading ABI-Encoded Data
```solidity theme={null}
// ABI encoding: function selector (4 bytes) + parameters
assembly {
// calldata is in memory starting at offset 0
let selector := mload(0)
// Selector is in high 4 bytes: selector >> 224
let func := selector
}
```
### Reading Function Parameters
```solidity theme={null}
assembly {
// Free memory pointer
let ptr := mload(0x40)
// Load stored value
let value := mload(ptr)
// Load next value
let next := mload(add(ptr, 0x20))
}
```
### Iterating Memory
```solidity theme={null}
assembly {
let offset := 0x20
let ptr := mload(offset)
// Chain loading
let first := mload(ptr)
let second := mload(add(ptr, 0x20))
let third := mload(add(ptr, 0x40))
}
```
## Memory Safety
**Load safety properties:**
* **No side effects:** Reading memory never modifies state or storage
* **Initialization:** Uninitialized memory safely reads as zero
* **Bounds:** Out-of-bounds reads don't error - they just allocate and charge gas
* **Atomicity:** 32-byte load is atomic (no tearing)
Applications must ensure offset validity:
```solidity theme={null}
// Good: Check bounds before reading
require(offset + 32 <= memorySize, "out of bounds");
let value := mload(offset);
// Bad: Assumes bounds checking
let value := mload(userSuppliedOffset); // Can read beyond allocated
```
## Implementation
```typescript theme={null}
/**
* MLOAD opcode (0x51) - Load 32-byte word from memory
*/
export function mload(frame: FrameType): EvmError | null {
// Pop offset from stack
if (frame.stack.length < 1) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
// Cast offset to u32 (check bounds)
const off = Number(offset);
if (!Number.isSafeInteger(off) || off < 0) {
return { type: "OutOfBounds" };
}
// Calculate memory expansion
const endBytes = BigInt(off + 32);
const expansionCost = calculateMemoryExpansion(endBytes);
// Charge gas
frame.gasRemaining -= 3n + expansionCost;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Expand memory
const alignedSize = Math.ceil((off + 32) / 32) * 32;
frame.memorySize = Math.max(frame.memorySize, alignedSize);
// Read 32 bytes in big-endian order
let result = 0n;
for (let i = 0; i < 32; i++) {
const byte = frame.memory.get(off + i) ?? 0;
result = (result << 8n) | BigInt(byte);
}
// Push result to stack
if (frame.stack.length >= 1024) {
return { type: "StackOverflow" };
}
frame.stack.push(result);
// Increment PC
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { mload } from './0x51_MLOAD.js';
describe('MLOAD (0x51)', () => {
it('loads 32 bytes from memory', () => {
const frame = createFrame();
for (let i = 0; i < 32; i++) {
frame.memory.set(i, i + 1);
}
frame.stack.push(0n);
expect(mload(frame)).toBeNull();
expect(frame.stack[0]).toBe(0x0102030405...n);
expect(frame.pc).toBe(1);
});
it('loads from uninitialized memory as zero', () => {
const frame = createFrame();
frame.stack.push(0n);
mload(frame);
expect(frame.stack[0]).toBe(0n);
expect(frame.memorySize).toBe(32);
});
it('expands memory to word boundary', () => {
const frame = createFrame();
frame.stack.push(1n); // Offset 1 -> bytes 1-32 = 2 words
mload(frame);
expect(frame.memorySize).toBe(64);
});
it('charges correct gas for expansion', () => {
const frame = createFrame({ gasRemaining: 1000n });
frame.stack.push(0n);
mload(frame);
// 3 base + memory expansion
expect(frame.gasRemaining).toBeLessThan(1000n);
});
it('returns StackUnderflow when empty', () => {
const frame = createFrame();
expect(mload(frame)).toEqual({ type: "StackUnderflow" });
});
it('returns OutOfGas when insufficient', () => {
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0n);
expect(mload(frame)).toEqual({ type: "OutOfGas" });
});
});
```
### Edge Cases Tested
* Basic load (32 bytes)
* Uninitialized memory (zeros)
* Non-zero offset with word boundary alignment
* Memory expansion costs
* Stack underflow/overflow
* Out of gas conditions
* Endianness verification
## Security Considerations
### Memory Disclosure
Memory is transaction-scoped and doesn't persist to state. However, careful handling needed:
```solidity theme={null}
// Good: Clear sensitive data
assembly {
mstore(offset, 0) // Clear temporary value
}
// Risky: Sensitive data in memory
assembly {
let privateKey := mload(0x80) // Don't do this
}
```
### Out-of-Bounds Reads
Memory expands automatically - reading beyond allocated areas is safe but expensive:
```solidity theme={null}
// Safe but expensive
let value := mload(1000000) // Quadratic gas cost to expand
// Better: Validate before reading
require(offset < endOfData, "invalid offset");
let value := mload(offset);
```
## Benchmarks
MLOAD is among the fastest EVM operations:
**Relative performance:**
* MLOAD (initialized): 1.0x baseline
* MLOAD (uninitialized): 1.0x baseline
* MSTORE: 1.0x (similar cost)
* SLOAD: 100x slower (storage vs memory)
**Gas scaling:**
* First word: 3 gas
* Second word: 3 gas (expansion ≈ 3)
* Large memory: Quadratic scaling beyond practical use
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.2 (Memory)
* **[evm.codes - MLOAD](https://www.evm.codes/#51)** - Interactive reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - Assembly and memory layout
# MSTORE (0x52)
Source: https://voltaire.tevm.sh/evm/instructions/memory/mstore
Write 32-byte word to memory at given offset
**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:** `0x52`
**Introduced:** Frontier (EVM genesis)
MSTORE writes a 32-byte word to memory at the specified offset. The value is taken from the stack as a 256-bit unsigned integer and written in big-endian order. This is the primary mechanism for writing arbitrary data to memory during execution.
## Specification
**Stack Input:**
```
offset (top)
value
```
**Stack Output:**
```
(empty)
```
**Gas Cost:** 3 + memory expansion cost
**Operation:**
```
memory[offset:offset+32] = value (big-endian)
```
## Behavior
MSTORE pops two values: offset (top of stack) and value (next). It writes the 32-byte representation of value to memory starting at offset.
* Offset is interpreted as unsigned 256-bit integer
* Value is written as 32 bytes in big-endian order (most significant byte first)
* Memory automatically expands to accommodate write (quadratic cost)
* Overwrites existing memory without checking
* All 32 bytes are always written (no partial writes)
## Examples
### Basic Store
```typescript theme={null}
import { mstore } from '@tevm/voltaire/evm/instructions/memory';
import { createFrame } from '@tevm/voltaire/evm/Frame';
const frame = createFrame();
const value = 0x12345678n;
frame.stack.push(0n); // offset
frame.stack.push(value); // value
const err = mstore(frame);
// Check written bytes (big-endian)
console.log(frame.memory.get(0)); // 0x00 (leading zeros)
console.log(frame.memory.get(28)); // 0x12
console.log(frame.memory.get(29)); // 0x34
console.log(frame.memory.get(30)); // 0x56
console.log(frame.memory.get(31)); // 0x78
console.log(frame.pc); // 1 (incremented)
```
### Write All Ones
```typescript theme={null}
const frame = createFrame();
const allOnes = (1n << 256n) - 1n; // 0xFFFF...FFFF
frame.stack.push(0n); // offset
frame.stack.push(allOnes); // value
mstore(frame);
// All 32 bytes should be 0xFF
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(i)); // 0xFF
}
```
### Write Zero (Clear Memory)
```typescript theme={null}
const frame = createFrame();
// Pre-populate memory
for (let i = 0; i < 32; i++) {
frame.memory.set(i, 0xAA);
}
// Clear with MSTORE 0
frame.stack.push(0n); // offset
frame.stack.push(0n); // value (zero)
mstore(frame);
// All bytes cleared to 0
for (let i = 0; i < 32; i++) {
console.log(frame.memory.get(i)); // 0
}
```
### Write at Non-Aligned Offset
```typescript theme={null}
const frame = createFrame();
frame.stack.push(16n); // offset 16 (misaligned)
frame.stack.push(0x12345678n); // value
mstore(frame);
// Expands memory to 48 bytes (2 words)
console.log(frame.memorySize); // 64 (next word boundary)
// Bytes 16-47 contain the written value
console.log(frame.memory.get(44)); // 0x12
console.log(frame.memory.get(47)); // 0x78
```
### Sequential Writes
```typescript theme={null}
const frame = createFrame();
// Write first word
frame.stack.push(0n);
frame.stack.push(0x0102030405060708n);
mstore(frame);
// Write second word
frame.stack.push(32n);
frame.stack.push(0x090a0b0c0d0e0f10n);
mstore(frame);
// Check both words written
console.log(frame.memory.get(7)); // 0x08
console.log(frame.memory.get(39)); // 0x10
console.log(frame.memorySize); // 64
```
## Gas Cost
**Base cost:** 3 gas (GasFastestStep)
**Memory expansion:** Quadratic based on access range
**Formula:**
```
words_required = ceil((offset + 32) / 32)
expansion_cost = (words_required)² / 512 + 3 * (words_required - words_old)
total_cost = 3 + expansion_cost
```
**Examples:**
* **Writing bytes 0-31:** 1 word, no prior expansion: 3 gas
* **Writing bytes 1-32:** 2 words (rounds up), 1 word prior: 3 + (4 - 1) = 6 gas
* **Writing bytes 0-4095:** \~125 words: 3 + (125² / 512 + expansion) ≈ 3 + 30 = 33 gas
Memory cost dominates for large writes.
## Edge Cases
### Overwriting Memory
```typescript theme={null}
const frame = createFrame();
// First write
frame.stack.push(0n);
frame.stack.push(0xAAAAAAAAn);
mstore(frame);
// Second write (overwrite)
frame.stack.push(0n);
frame.stack.push(0xBBBBBBBBn);
mstore(frame);
// Second value wins
console.log(frame.memory.get(31)); // 0xBB
```
### Partial Overlap
```typescript theme={null}
const frame = createFrame();
// Write at offset 0
frame.stack.push(0n);
frame.stack.push(0xFFFFFFFFFFFFFFFFn);
mstore(frame);
// Write at offset 16 (overlaps previous)
frame.stack.push(16n);
frame.stack.push(0x0000000000000000n);
mstore(frame);
// Bytes 16-31 cleared, bytes 0-15 unchanged
console.log(frame.memory.get(15)); // 0xFF
console.log(frame.memory.get(16)); // 0x00
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0n);
frame.stack.push(0x42n);
const err = mstore(frame);
console.log(err); // { type: "OutOfGas" }
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame();
// Only one value on stack
frame.stack.push(0n);
const err = mstore(frame);
console.log(err); // { type: "StackUnderflow" }
```
## Common Usage
### Update Free Memory Pointer
```solidity theme={null}
assembly {
let ptr := mload(0x40) // Load free pointer
mstore(ptr, value) // Write value
mstore(0x40, add(ptr, 0x20)) // Update pointer
}
```
### Encode Function Return
```solidity theme={null}
assembly {
// Return a single uint256
let ptr := mload(0x40)
mstore(ptr, value)
return(ptr, 0x20)
}
```
### Build ABI-Encoded Calldata
```solidity theme={null}
assembly {
let offset := 0x20
// Function selector (4 bytes padded)
mstore(offset, shl(224, selector))
// Parameter 1
mstore(add(offset, 0x20), param1)
// Parameter 2
mstore(add(offset, 0x40), param2)
}
```
### Temporary Storage (Local Variables)
```solidity theme={null}
assembly {
let temp := mload(0x40) // Free memory
mstore(temp, value) // Store value
let loaded := mload(temp) // Load back
}
```
## Memory Safety
**Write safety properties:**
* **No side effects:** Writing memory doesn't affect storage or state
* **Atomic writes:** 32-byte write is atomic
* **Initialization:** Uninitialized memory automatically allocated
* **Overwrite safety:** Always replaces all 32 bytes
Applications must ensure offset correctness:
```solidity theme={null}
// Good: Manage free memory pointer
let ptr := mload(0x40)
mstore(ptr, value)
mstore(0x40, add(ptr, 0x20)) // Update for next allocation
// Risky: Fixed offsets
mstore(0x100, value) // Assumes offset 0x100 is free
```
## Implementation
```typescript theme={null}
/**
* MSTORE opcode (0x52) - Write 32-byte word to memory
*/
export function mstore(frame: FrameType): EvmError | null {
// Pop offset and value from stack
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const value = frame.stack.pop();
// Cast offset to u32
const off = Number(offset);
if (!Number.isSafeInteger(off) || off < 0) {
return { type: "OutOfBounds" };
}
// Calculate memory expansion
const endBytes = BigInt(off + 32);
const expansionCost = calculateMemoryExpansion(endBytes);
// Charge gas
frame.gasRemaining -= 3n + expansionCost;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Expand memory
const alignedSize = Math.ceil((off + 32) / 32) * 32;
frame.memorySize = Math.max(frame.memorySize, alignedSize);
// Write 32 bytes in big-endian order
for (let i = 0; i < 32; i++) {
const byte = Number((value >> BigInt((31 - i) * 8)) & 0xFFn);
frame.memory.set(off + i, byte);
}
// Increment PC
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { mstore } from './0x52_MSTORE.js';
describe('MSTORE (0x52)', () => {
it('writes 32 bytes to memory at offset 0', () => {
const frame = createFrame();
const value = 0x0102030405...n;
frame.stack.push(value);
frame.stack.push(0n);
expect(mstore(frame)).toBeNull();
expect(frame.stack.length).toBe(0);
expect(frame.memory.get(0)).toBe(0x01);
expect(frame.memory.get(31)).toBe(0x20);
expect(frame.pc).toBe(1);
});
it('writes zero to clear memory', () => {
const frame = createFrame();
// Pre-populate
for (let i = 0; i < 32; i++) {
frame.memory.set(i, 0xFF);
}
frame.stack.push(0n);
frame.stack.push(0n);
mstore(frame);
for (let i = 0; i < 32; i++) {
expect(frame.memory.get(i)).toBe(0);
}
});
it('expands memory to word boundary', () => {
const frame = createFrame();
frame.stack.push(0xABn);
frame.stack.push(1n);
mstore(frame);
expect(frame.memorySize).toBe(64);
});
it('overwrites existing memory', () => {
const frame = createFrame();
frame.stack.push(0xAAAAn);
frame.stack.push(0n);
mstore(frame);
frame.stack.push(0xBBBBn);
frame.stack.push(0n);
mstore(frame);
expect(frame.memory.get(31)).toBe(0xBB);
});
it('returns OutOfGas when insufficient', () => {
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0xFFn);
frame.stack.push(0n);
expect(mstore(frame)).toEqual({ type: "OutOfGas" });
});
it('returns StackUnderflow when insufficient stack', () => {
const frame = createFrame();
frame.stack.push(0n);
expect(mstore(frame)).toEqual({ type: "StackUnderflow" });
});
});
```
### Edge Cases Tested
* Basic write (32 bytes)
* Zero write (memory clear)
* Non-aligned offset
* Overwrite handling
* Word boundary alignment
* Stack underflow/overflow
* Out of gas conditions
* Big-endian encoding
## Security Considerations
### Incorrect Free Pointer Management
```solidity theme={null}
// Risky: Not updating free pointer
assembly {
let ptr := mload(0x40)
mstore(ptr, value)
// Missing: mstore(0x40, add(ptr, 0x20))
}
// Next allocation overwrites this data!
// Correct: Always update pointer
assembly {
let ptr := mload(0x40)
mstore(ptr, value)
mstore(0x40, add(ptr, 0x20))
}
```
### Memory Overlap Bugs
```solidity theme={null}
// Bad: Assumes memory layout
assembly {
let a := mload(0x80)
let b := mload(0xA0)
mstore(0x80, a + b) // Overwrites a!
}
// Good: Use separate offsets
assembly {
let a := mload(0x80)
let b := mload(0xA0)
mstore(0xC0, a + b) // Safe, no overlap
}
```
## Benchmarks
MSTORE is among the fastest EVM operations:
**Relative performance:**
* MSTORE (new memory): 1.0x baseline
* MSTORE (existing memory): 1.0x baseline
* MLOAD: 1.0x (similar cost)
* SSTORE: 100x slower (storage vs memory)
**Gas scaling:**
* First word: 3 gas
* Second word: 3 gas (small expansion)
* Large memory: Quadratic scaling beyond practical use
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.2 (Memory)
* **[evm.codes - MSTORE](https://www.evm.codes/#52)** - Interactive reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - Assembly and memory layout
# MSTORE8 (0x53)
Source: https://voltaire.tevm.sh/evm/instructions/memory/mstore8
Write single byte to memory at given offset
**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:** `0x53`
**Introduced:** Frontier (EVM genesis)
MSTORE8 writes a single byte to memory at the specified offset. Only the least significant byte (bits 0-7) of the stack value is written; all higher-order bits are truncated. This is the only opcode for single-byte writes in the EVM.
## Specification
**Stack Input:**
```
offset (top)
value
```
**Stack Output:**
```
(empty)
```
**Gas Cost:** 3 + memory expansion cost
**Operation:**
```
memory[offset] = value & 0xFF
```
## Behavior
MSTORE8 pops two values: offset (top) and value (next). It extracts the least significant byte of value and writes it to memory at offset.
* Offset is interpreted as unsigned 256-bit integer
* Only lowest 8 bits of value are written (all other bits ignored)
* Memory automatically expands to accommodate write (quadratic cost)
* Overwrites single byte without affecting adjacent bytes
* More gas-efficient than MSTORE for single-byte writes (same base cost, smaller memory footprint)
## Examples
### Basic Single-Byte Write
```typescript theme={null}
import { mstore8 } from '@tevm/voltaire/evm/instructions/memory';
import { createFrame } from '@tevm/voltaire/evm/Frame';
const frame = createFrame();
frame.stack.push(0n); // offset
frame.stack.push(0x42n); // value (only 0x42 written)
const err = mstore8(frame);
console.log(frame.memory.get(0)); // 0x42
console.log(frame.pc); // 1 (incremented)
```
### Truncation of Multi-Byte Value
```typescript theme={null}
const frame = createFrame();
// Value with multiple bytes - only lowest byte written
const value = 0x123456789ABCDEFn;
frame.stack.push(0n); // offset
frame.stack.push(value); // value
mstore8(frame);
console.log(frame.memory.get(0)); // 0xEF (only lowest byte)
```
### Write All Ones Byte
```typescript theme={null}
const frame = createFrame();
const allOnes = (1n << 256n) - 1n;
frame.stack.push(0n);
frame.stack.push(allOnes);
mstore8(frame);
console.log(frame.memory.get(0)); // 0xFF
```
### Write Zero Byte
```typescript theme={null}
const frame = createFrame();
// Pre-populate memory
frame.memory.set(5, 0xAA);
// Clear single byte
frame.stack.push(5n); // offset
frame.stack.push(0n); // value (zero)
mstore8(frame);
console.log(frame.memory.get(5)); // 0x00
console.log(frame.memory.get(4)); // undefined (adjacent byte unchanged)
console.log(frame.memory.get(6)); // undefined (adjacent byte unchanged)
```
### Sequential Byte Writes
```typescript theme={null}
const frame = createFrame();
// Write ASCII string "ABC"
const bytes = [0x41, 0x42, 0x43]; // 'A', 'B', 'C'
for (let i = 0; i < bytes.length; i++) {
frame.stack.push(BigInt(i)); // offset
frame.stack.push(BigInt(bytes[i])); // value
mstore8(frame);
}
console.log(frame.memory.get(0)); // 0x41
console.log(frame.memory.get(1)); // 0x42
console.log(frame.memory.get(2)); // 0x43
console.log(frame.memorySize); // 32 (word-aligned)
```
### Partial Overwrite
```typescript theme={null}
const frame = createFrame();
// Write full word first
frame.stack.push(0n);
frame.stack.push(0xFFFFFFFFFFFFFFFFn);
mstore8(frame); // Actually writes 0xFF at offset 0, then MSTORE writes full word
// Actually, MSTORE8 behavior: write single byte
frame.stack.push(10n);
frame.stack.push(0xAAn);
mstore8(frame);
// Bytes 0-9: uninitialized (or from previous)
// Byte 10: 0xAA
// Bytes 11-31: uninitialized
console.log(frame.memory.get(10)); // 0xAA
console.log(frame.memorySize); // 32 (expanded to first word)
```
## Gas Cost
**Base cost:** 3 gas (GasFastestStep)
**Memory expansion:** Quadratic based on access range
**Formula:**
```
words_required = ceil((offset + 1) / 32)
expansion_cost = (words_required)² / 512 + 3 * (words_required - words_old)
total_cost = 3 + expansion_cost
```
**Examples:**
* **Writing byte 0:** 1 word, no prior expansion: 3 gas
* **Writing byte 31:** 1 word, no prior expansion: 3 gas (same word)
* **Writing byte 32:** 2 words, 1 word prior: 3 + (4 - 1) = 6 gas
* **Writing bytes 0-255:** 8 words: 3 + (64 - 1) = 66 gas
MSTORE8 is more efficient than MSTORE for single-byte writes since it doesn't force 32-byte alignment in memory updates (though memory is still expanded to word boundaries).
## Edge Cases
### Writing to Word Boundary
```typescript theme={null}
const frame = createFrame();
// Write at byte 31 (last byte of first word)
frame.stack.push(31n);
frame.stack.push(0x99n);
mstore8(frame);
// Expands to 32 bytes (1 word)
console.log(frame.memorySize); // 32
console.log(frame.memory.get(31)); // 0x99
```
### Writing Beyond First Word
```typescript theme={null}
const frame = createFrame();
// Write at byte 32 (first byte of second word)
frame.stack.push(32n);
frame.stack.push(0x77n);
mstore8(frame);
// Expands to 64 bytes (2 words)
console.log(frame.memorySize); // 64
console.log(frame.memory.get(32)); // 0x77
```
### Multiple Writes to Same Word
```typescript theme={null}
const frame = createFrame();
// Write different bytes in same word
frame.stack.push(5n);
frame.stack.push(0x11n);
mstore8(frame);
frame.stack.push(10n);
frame.stack.push(0x22n);
mstore8(frame);
frame.stack.push(15n);
frame.stack.push(0x33n);
mstore8(frame);
console.log(frame.memory.get(5)); // 0x11
console.log(frame.memory.get(10)); // 0x22
console.log(frame.memory.get(15)); // 0x33
```
### Out of Gas
```typescript theme={null}
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0n);
frame.stack.push(0x42n);
const err = mstore8(frame);
console.log(err); // { type: "OutOfGas" }
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame();
// Only one value on stack
frame.stack.push(0n);
const err = mstore8(frame);
console.log(err); // { type: "StackUnderflow" }
```
## Common Usage
### Building Packed Struct in Memory
```solidity theme={null}
assembly {
let offset := 0
// Pack multiple small values
mstore8(offset, byte0) // 1 byte
mstore8(add(offset, 1), byte1)
mstore8(add(offset, 2), byte2)
mstore8(add(offset, 3), byte3)
// Continue with MSTORE for larger values
mstore(add(offset, 4), word4)
}
```
### Encode String Data
```solidity theme={null}
assembly {
// Encode string prefix (length in first slot)
let str := 0x40
mstore(str, stringLength)
// Write individual characters
let offset := add(str, 0x20)
for { let i := 0 } lt(i, stringLength) { i := add(i, 1) } {
mstore8(add(offset, i), charByte)
}
}
```
### Sparse Memory Allocation
```solidity theme={null}
assembly {
// Write sparse bytes without padding full words
mstore8(0x00, 0xAA)
mstore8(0x100, 0xBB) // Skip 256 bytes
mstore8(0x200, 0xCC) // Skip another 256 bytes
// More memory-efficient than MSTORE
}
```
### Low-Level Bit Setting
```solidity theme={null}
assembly {
let byte_offset := 10
let current := mload8(byte_offset)
let updated := or(current, 0x01) // Set lowest bit
mstore8(byte_offset, updated)
}
```
## Memory Safety
**Write safety properties:**
* **No side effects:** Writing memory doesn't affect storage or state
* **Byte-level granularity:** Single-byte writes don't affect adjacent bytes
* **No initialization races:** Single-byte write triggers memory expansion if needed
Applications must ensure offset correctness:
```solidity theme={null}
// Good: Bounds checking
require(offset < memorySize, "out of bounds");
mstore8(offset, value);
// Risky: Assumes free memory layout
mstore8(userOffset, value); // Can overwrite important data
```
## Implementation
```typescript theme={null}
/**
* MSTORE8 opcode (0x53) - Write single byte to memory
*/
export function mstore8(frame: FrameType): EvmError | null {
// Pop offset and value from stack
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
const offset = frame.stack.pop();
const value = frame.stack.pop();
// Cast offset to u32
const off = Number(offset);
if (!Number.isSafeInteger(off) || off < 0) {
return { type: "OutOfBounds" };
}
// Calculate memory expansion (for 1 byte)
const endBytes = BigInt(off + 1);
const expansionCost = calculateMemoryExpansion(endBytes);
// Charge gas
frame.gasRemaining -= 3n + expansionCost;
if (frame.gasRemaining < 0n) {
return { type: "OutOfGas" };
}
// Expand memory
const alignedSize = Math.ceil((off + 1) / 32) * 32;
frame.memorySize = Math.max(frame.memorySize, alignedSize);
// Write single byte (least significant 8 bits only)
const byte = Number(value & 0xFFn);
frame.memory.set(off, byte);
// Increment PC
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { mstore8 } from './0x53_MSTORE8.js';
describe('MSTORE8 (0x53)', () => {
it('writes least significant byte', () => {
const frame = createFrame();
frame.stack.push(0x42n);
frame.stack.push(0n);
expect(mstore8(frame)).toBeNull();
expect(frame.stack.length).toBe(0);
expect(frame.memory.get(0)).toBe(0x42);
expect(frame.pc).toBe(1);
});
it('truncates multi-byte values', () => {
const frame = createFrame();
const value = 0x123456789ABCDEFn;
frame.stack.push(value);
frame.stack.push(0n);
mstore8(frame);
// Only lowest byte (0xEF) written
expect(frame.memory.get(0)).toBe(0xEF);
});
it('writes zero byte', () => {
const frame = createFrame();
frame.memory.set(0, 0x99);
frame.stack.push(0n);
frame.stack.push(0n);
mstore8(frame);
expect(frame.memory.get(0)).toBe(0);
});
it('writes at non-zero offset', () => {
const frame = createFrame();
frame.stack.push(0xABn);
frame.stack.push(10n);
mstore8(frame);
expect(frame.memory.get(10)).toBe(0xAB);
expect(frame.memory.has(5)).toBe(false);
});
it('expands to word boundary', () => {
const frame = createFrame();
frame.stack.push(0x99n);
frame.stack.push(32n);
mstore8(frame);
// Writes at byte 32, expands to 2 words (64 bytes)
expect(frame.memorySize).toBe(64);
});
it('preserves adjacent bytes', () => {
const frame = createFrame();
frame.memory.set(10, 0xAA);
frame.memory.set(12, 0xBB);
frame.stack.push(0xCCn);
frame.stack.push(11n);
mstore8(frame);
expect(frame.memory.get(10)).toBe(0xAA);
expect(frame.memory.get(11)).toBe(0xCC);
expect(frame.memory.get(12)).toBe(0xBB);
});
it('returns OutOfGas when insufficient', () => {
const frame = createFrame({ gasRemaining: 2n });
frame.stack.push(0x33n);
frame.stack.push(0n);
expect(mstore8(frame)).toEqual({ type: "OutOfGas" });
});
it('returns StackUnderflow when insufficient stack', () => {
const frame = createFrame();
frame.stack.push(0n);
expect(mstore8(frame)).toEqual({ type: "StackUnderflow" });
});
it('handles all byte values 0x00-0xFF', () => {
const frame = createFrame();
for (let byte = 0; byte <= 0xFF; byte++) {
frame.stack.push(BigInt(byte));
frame.stack.push(BigInt(byte));
mstore8(frame);
expect(frame.memory.get(byte)).toBe(byte);
}
});
});
```
### Edge Cases Tested
* Single byte write
* Multi-byte truncation
* Zero write
* Non-aligned offset
* Word boundary expansion
* Adjacent byte preservation
* Stack underflow/overflow
* Out of gas conditions
## Security Considerations
### Byte-Level Granularity Bugs
```solidity theme={null}
// Bad: Assuming full-word atomicity
assembly {
let flags := mload(ptr)
mstore8(ptr, 0x01) // Overwrites only 1 byte!
mstore8(add(ptr, 31), 0x02)
// Only bytes 0 and 31 modified, rest unchanged
}
// Good: Track modifications carefully
assembly {
mstore8(flagOffset, newValue)
// Document what adjacent bytes contain
}
```
### Memory Layout Assumptions
```solidity theme={null}
// Risky: Assumes memory layout
assembly {
mstore8(0x00, version)
mstore8(0x01, type)
// If layout changes, breaks
}
// Better: Use consistent offset tracking
assembly {
let offset := freeMemoryPointer
mstore8(offset, version)
mstore8(add(offset, 1), type)
mstore(0x40, add(offset, 2))
}
```
## Benchmarks
MSTORE8 is among the fastest EVM operations:
**Relative performance:**
* MSTORE8: 1.0x baseline
* MSTORE: 1.0x (same base cost)
* MLOAD: 1.0x (similar cost)
* SSTORE: 100x+ slower
**Memory expansion efficiency:**
* Single byte write: Same word-boundary expansion as 32-byte write
* Sequential byte writes more efficient than equivalent MSTORE operations
* Useful for sparse memory allocation
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.2 (Memory)
* **[evm.codes - MSTORE8](https://www.evm.codes/#53)** - Interactive reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - Assembly and memory operations
# DUP1 (0x80)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup1
Duplicate top stack item
**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:** `0x80`
**Introduced:** Frontier (EVM genesis)
DUP1 duplicates the top stack item and pushes it to the top of the stack. The original item remains in place.
## Specification
**Stack Input:**
```
[..., value]
```
**Stack Output:**
```
[..., value, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 1]
stack.push(value)
```
## Behavior
DUP1 copies the top stack item without removing it. Requires stack depth ≥ 1.
Key characteristics:
* Requires stack depth ≥ 1
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 1
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x80_DUP1 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate top item
const frame = createFrame({
stack: [100n],
gasRemaining: 1000n
});
const err = handler_0x80_DUP1(frame);
console.log(frame.stack); // [100n, 100n] - top duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function reuse() public pure returns (uint256, uint256) {
uint256 x = 42;
// Need x twice
return (x, x); // Compiler uses DUP1
// PUSH1 0x2a
// DUP1
// DUP1
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
// Stack: [0x01]
dup1
// Stack: [0x01, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP1 | 3 | Duplicate 1th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Value Reuse
````solidity theme={null}
assembly {
let x := 100
dup1 // Reuse x
dup1 // Reuse again
// Stack: [100, 100, 100]
add // Use first two
// Stack: [200, 100]
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP1 requires 1 items on stack
assembly {
// Only 0 items - DUP1 will fail!
dup1 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
// Exactly 1 items - safe
dup1 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP1 opcode (0x80) - Duplicate 1st stack item
*
* Stack: [..., value] => [..., value, value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x80_DUP1(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 1) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 1];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [] // Only 0 items
});
const err = handler_0x80_DUP1(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x80_DUP1(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x80_DUP1(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [MAX]
});
handler_0x80_DUP1(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP1](https://www.evm.codes/#80?fork=cancun)
* [Solidity Assembly - dup1](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP10 (0x89)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup10
Duplicate 10th stack item
**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:** `0x89`
**Introduced:** Frontier (EVM genesis)
DUP10 duplicates the 10th stack item and pushes it to the top of the stack. The original 10th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item9, ..., item1]
```
**Stack Output:**
```
[..., value, item9, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 10]
stack.push(value)
```
## Behavior
DUP10 copies the 10th-from-top stack item without removing it. Requires stack depth ≥ 10.
Key characteristics:
* Requires stack depth ≥ 10
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 10
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x89_DUP10 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 10th item
const frame = createFrame({
stack: [1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x89_DUP10(frame);
console.log(frame.stack); // [1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 10th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 10 items
dup10 // Duplicate 10th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a]
dup10
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP10 | 3 | Duplicate 10th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
// Access v1 from depth 10
dup10
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP10 requires 10 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Only 9 items - DUP10 will fail!
dup10 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Exactly 10 items - safe
dup10 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP10 opcode (0x89) - Duplicate 10th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x89_DUP10(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 10) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 10];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 9 items
});
const err = handler_0x89_DUP10(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x89_DUP10(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x89_DUP10(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x89_DUP10(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP10](https://www.evm.codes/#89?fork=cancun)
* [Solidity Assembly - dup10](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP11 (0x8A)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup11
Duplicate 11th stack item
**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:** `0x8A`
**Introduced:** Frontier (EVM genesis)
DUP11 duplicates the 11th stack item and pushes it to the top of the stack. The original 11th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item10, ..., item1]
```
**Stack Output:**
```
[..., value, item10, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 11]
stack.push(value)
```
## Behavior
DUP11 copies the 11th-from-top stack item without removing it. Requires stack depth ≥ 11.
Key characteristics:
* Requires stack depth ≥ 11
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 11
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8A_DUP11 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 11th item
const frame = createFrame({
stack: [1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8A_DUP11(frame);
console.log(frame.stack); // [1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 11th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 11 items
dup11 // Duplicate 11th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b]
dup11
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP11 | 3 | Duplicate 11th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
// Access v1 from depth 11
dup11
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP11 requires 11 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Only 10 items - DUP11 will fail!
dup11 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Exactly 11 items - safe
dup11 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP11 opcode (0x8A) - Duplicate 11th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8A_DUP11(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 11) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 11];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 10 items
});
const err = handler_0x8A_DUP11(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8A_DUP11(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8A_DUP11(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8A_DUP11(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP11](https://www.evm.codes/#8a?fork=cancun)
* [Solidity Assembly - dup11](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP12 (0x8B)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup12
Duplicate 12th stack item
**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:** `0x8B`
**Introduced:** Frontier (EVM genesis)
DUP12 duplicates the 12th stack item and pushes it to the top of the stack. The original 12th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item11, ..., item1]
```
**Stack Output:**
```
[..., value, item11, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 12]
stack.push(value)
```
## Behavior
DUP12 copies the 12th-from-top stack item without removing it. Requires stack depth ≥ 12.
Key characteristics:
* Requires stack depth ≥ 12
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 12
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8B_DUP12 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 12th item
const frame = createFrame({
stack: [1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8B_DUP12(frame);
console.log(frame.stack); // [1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 12th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 12 items
dup12 // Duplicate 12th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c]
dup12
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP12 | 3 | Duplicate 12th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
// Access v1 from depth 12
dup12
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP12 requires 12 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Only 11 items - DUP12 will fail!
dup12 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Exactly 12 items - safe
dup12 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP12 opcode (0x8B) - Duplicate 12th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8B_DUP12(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 12) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 12];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 11 items
});
const err = handler_0x8B_DUP12(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8B_DUP12(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8B_DUP12(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8B_DUP12(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP12](https://www.evm.codes/#8b?fork=cancun)
* [Solidity Assembly - dup12](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP13 (0x8C)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup13
Duplicate 13th stack item
**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:** `0x8C`
**Introduced:** Frontier (EVM genesis)
DUP13 duplicates the 13th stack item and pushes it to the top of the stack. The original 13th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item12, ..., item1]
```
**Stack Output:**
```
[..., value, item12, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 13]
stack.push(value)
```
## Behavior
DUP13 copies the 13th-from-top stack item without removing it. Requires stack depth ≥ 13.
Key characteristics:
* Requires stack depth ≥ 13
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 13
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8C_DUP13 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 13th item
const frame = createFrame({
stack: [1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8C_DUP13(frame);
console.log(frame.stack); // [1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 13th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 13 items
dup13 // Duplicate 13th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d]
dup13
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP13 | 3 | Duplicate 13th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
// Access v1 from depth 13
dup13
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP13 requires 13 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Only 12 items - DUP13 will fail!
dup13 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Exactly 13 items - safe
dup13 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP13 opcode (0x8C) - Duplicate 13th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8C_DUP13(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 13) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 13];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 12 items
});
const err = handler_0x8C_DUP13(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8C_DUP13(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8C_DUP13(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8C_DUP13(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP13](https://www.evm.codes/#8c?fork=cancun)
* [Solidity Assembly - dup13](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP14 (0x8D)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup14
Duplicate 14th stack item
**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:** `0x8D`
**Introduced:** Frontier (EVM genesis)
DUP14 duplicates the 14th stack item and pushes it to the top of the stack. The original 14th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item13, ..., item1]
```
**Stack Output:**
```
[..., value, item13, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 14]
stack.push(value)
```
## Behavior
DUP14 copies the 14th-from-top stack item without removing it. Requires stack depth ≥ 14.
Key characteristics:
* Requires stack depth ≥ 14
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 14
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8D_DUP14 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 14th item
const frame = createFrame({
stack: [1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8D_DUP14(frame);
console.log(frame.stack); // [1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 14th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 14 items
dup14 // Duplicate 14th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e]
dup14
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP14 | 3 | Duplicate 14th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
// Access v1 from depth 14
dup14
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP14 requires 14 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Only 13 items - DUP14 will fail!
dup14 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Exactly 14 items - safe
dup14 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP14 opcode (0x8D) - Duplicate 14th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8D_DUP14(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 14) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 14];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 13 items
});
const err = handler_0x8D_DUP14(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8D_DUP14(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8D_DUP14(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8D_DUP14(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP14](https://www.evm.codes/#8d?fork=cancun)
* [Solidity Assembly - dup14](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP15 (0x8E)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup15
Duplicate 15th stack item
**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:** `0x8E`
**Introduced:** Frontier (EVM genesis)
DUP15 duplicates the 15th stack item and pushes it to the top of the stack. The original 15th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item14, ..., item1]
```
**Stack Output:**
```
[..., value, item14, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 15]
stack.push(value)
```
## Behavior
DUP15 copies the 15th-from-top stack item without removing it. Requires stack depth ≥ 15.
Key characteristics:
* Requires stack depth ≥ 15
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 15
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8E_DUP15 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 15th item
const frame = createFrame({
stack: [1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8E_DUP15(frame);
console.log(frame.stack); // [1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 15th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 15 items
dup15 // Duplicate 15th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f]
dup15
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP15 | 3 | Duplicate 15th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
let v15 := 15
// Access v1 from depth 15
dup15
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP15 requires 15 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Only 14 items - DUP15 will fail!
dup15 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Exactly 15 items - safe
dup15 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP15 opcode (0x8E) - Duplicate 15th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8E_DUP15(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 15) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 15];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 14 items
});
const err = handler_0x8E_DUP15(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8E_DUP15(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8E_DUP15(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8E_DUP15(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP15](https://www.evm.codes/#8e?fork=cancun)
* [Solidity Assembly - dup15](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP16 (0x8F)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup16
Duplicate 16th stack item
**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:** `0x8F`
**Introduced:** Frontier (EVM genesis)
DUP16 duplicates the 16th stack item and pushes it to the top of the stack. The original 16th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item15, ..., item1]
```
**Stack Output:**
```
[..., value, item15, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 16]
stack.push(value)
```
## Behavior
DUP16 copies the 16th-from-top stack item without removing it. Requires stack depth ≥ 16.
Key characteristics:
* Requires stack depth ≥ 16
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 16
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x8F_DUP16 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 16th item
const frame = createFrame({
stack: [1600n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x8F_DUP16(frame);
console.log(frame.stack); // [1600n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 16th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 16 items
dup16 // Duplicate 16th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]
dup16
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| DUP16 | 3 | Duplicate 16th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
let v15 := 15
let v16 := 16
// Access v1 from depth 16
dup16
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP16 requires 16 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Only 15 items - DUP16 will fail!
dup16 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
// Exactly 16 items - safe
dup16 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP16 opcode (0x8F) - Duplicate 16th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x8F_DUP16(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 16) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 16];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 15 items
});
const err = handler_0x8F_DUP16(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x8F_DUP16(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x8F_DUP16(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x8F_DUP16(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP16](https://www.evm.codes/#8f?fork=cancun)
* [Solidity Assembly - dup16](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP2 (0x81)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup2
Duplicate 2nd stack item
**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:** `0x81`
**Introduced:** Frontier (EVM genesis)
DUP2 duplicates the 2nd stack item and pushes it to the top of the stack. The original 2th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item1, ..., item1]
```
**Stack Output:**
```
[..., value, item1, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 2]
stack.push(value)
```
## Behavior
DUP2 copies the 2th-from-top stack item without removing it. Requires stack depth ≥ 2.
Key characteristics:
* Requires stack depth ≥ 2
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 2
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x81_DUP2 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 2th item
const frame = createFrame({
stack: [200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x81_DUP2(frame);
console.log(frame.stack); // [200n, 100n, 100n] - 2th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function swap() public pure {
uint256 a = 10;
uint256 b = 20;
// Access a again
// Stack: [b, a]
// DUP2 // Stack: [b, a, a]
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
// Stack: [0x01, 0x02]
dup2
// Stack: [0x01, 0x02, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP2 | 3 | Duplicate 2th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Access Previous Value
````solidity theme={null}
assembly {
let a := 10
let b := 20
dup2 // Get 'a' again
// Stack: [b, a, a]
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP2 requires 2 items on stack
assembly {
push1 0x01
// Only 1 items - DUP2 will fail!
dup2 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
// Exactly 2 items - safe
dup2 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP2 opcode (0x81) - Duplicate 2nd stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x81_DUP2(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 2];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n] // Only 1 item
});
const err = handler_0x81_DUP2(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x81_DUP2(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x81_DUP2(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, MAX]
});
handler_0x81_DUP2(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP2](https://www.evm.codes/#81?fork=cancun)
* [Solidity Assembly - dup2](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP3 (0x82)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup3
Duplicate 3rd stack item
**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:** `0x82`
**Introduced:** Frontier (EVM genesis)
DUP3 duplicates the 3rd stack item and pushes it to the top of the stack. The original 3th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item2, ..., item1]
```
**Stack Output:**
```
[..., value, item2, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 3]
stack.push(value)
```
## Behavior
DUP3 copies the 3th-from-top stack item without removing it. Requires stack depth ≥ 3.
Key characteristics:
* Requires stack depth ≥ 3
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 3
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x82_DUP3 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 3th item
const frame = createFrame({
stack: [300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x82_DUP3(frame);
console.log(frame.stack); // [300n, 200n, 100n, 100n] - 3th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 3 items
dup3 // Duplicate 3th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
// Stack: [0x01, 0x02, 0x03]
dup3
// Stack: [0x01, 0x02, 0x03, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP3 | 3 | Duplicate 3th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
// Access v1 from depth 3
dup3
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP3 requires 3 items on stack
assembly {
push1 0x01
push1 0x02
// Only 2 items - DUP3 will fail!
dup3 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
// Exactly 3 items - safe
dup3 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP3 opcode (0x82) - Duplicate 3rd stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x82_DUP3(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 3) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 3];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n] // Only 2 items
});
const err = handler_0x82_DUP3(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x82_DUP3(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x82_DUP3(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, MAX]
});
handler_0x82_DUP3(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP3](https://www.evm.codes/#82?fork=cancun)
* [Solidity Assembly - dup3](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP4 (0x83)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup4
Duplicate 4th stack item
**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:** `0x83`
**Introduced:** Frontier (EVM genesis)
DUP4 duplicates the 4th stack item and pushes it to the top of the stack. The original 4th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item3, ..., item1]
```
**Stack Output:**
```
[..., value, item3, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 4]
stack.push(value)
```
## Behavior
DUP4 copies the 4th-from-top stack item without removing it. Requires stack depth ≥ 4.
Key characteristics:
* Requires stack depth ≥ 4
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 4
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x83_DUP4 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 4th item
const frame = createFrame({
stack: [400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x83_DUP4(frame);
console.log(frame.stack); // [400n, 300n, 200n, 100n, 100n] - 4th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 4 items
dup4 // Duplicate 4th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Stack: [0x01, 0x02, 0x03, 0x04]
dup4
// Stack: [0x01, 0x02, 0x03, 0x04, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP4 | 3 | Duplicate 4th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
// Access v1 from depth 4
dup4
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP4 requires 4 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
// Only 3 items - DUP4 will fail!
dup4 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Exactly 4 items - safe
dup4 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP4 opcode (0x83) - Duplicate 4th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x83_DUP4(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 4) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 4];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n] // Only 3 items
});
const err = handler_0x83_DUP4(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x83_DUP4(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x83_DUP4(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, MAX]
});
handler_0x83_DUP4(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP4](https://www.evm.codes/#83?fork=cancun)
* [Solidity Assembly - dup4](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP5 (0x84)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup5
Duplicate 5th stack item
**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:** `0x84`
**Introduced:** Frontier (EVM genesis)
DUP5 duplicates the 5th stack item and pushes it to the top of the stack. The original 5th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item4, ..., item1]
```
**Stack Output:**
```
[..., value, item4, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 5]
stack.push(value)
```
## Behavior
DUP5 copies the 5th-from-top stack item without removing it. Requires stack depth ≥ 5.
Key characteristics:
* Requires stack depth ≥ 5
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 5
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x84_DUP5 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 5th item
const frame = createFrame({
stack: [500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x84_DUP5(frame);
console.log(frame.stack); // [500n, 400n, 300n, 200n, 100n, 100n] - 5th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 5 items
dup5 // Duplicate 5th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05]
dup5
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP5 | 3 | Duplicate 5th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
// Access v1 from depth 5
dup5
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP5 requires 5 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Only 4 items - DUP5 will fail!
dup5 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Exactly 5 items - safe
dup5 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP5 opcode (0x84) - Duplicate 5th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x84_DUP5(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 5) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 5];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n] // Only 4 items
});
const err = handler_0x84_DUP5(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x84_DUP5(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x84_DUP5(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, MAX]
});
handler_0x84_DUP5(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP5](https://www.evm.codes/#84?fork=cancun)
* [Solidity Assembly - dup5](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP6 (0x85)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup6
Duplicate 6th stack item
**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:** `0x85`
**Introduced:** Frontier (EVM genesis)
DUP6 duplicates the 6th stack item and pushes it to the top of the stack. The original 6th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item5, ..., item1]
```
**Stack Output:**
```
[..., value, item5, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 6]
stack.push(value)
```
## Behavior
DUP6 copies the 6th-from-top stack item without removing it. Requires stack depth ≥ 6.
Key characteristics:
* Requires stack depth ≥ 6
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 6
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x85_DUP6 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 6th item
const frame = createFrame({
stack: [600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x85_DUP6(frame);
console.log(frame.stack); // [600n, 500n, 400n, 300n, 200n, 100n, 100n] - 6th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 6 items
dup6 // Duplicate 6th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06]
dup6
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP6 | 3 | Duplicate 6th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
// Access v1 from depth 6
dup6
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP6 requires 6 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Only 5 items - DUP6 will fail!
dup6 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Exactly 6 items - safe
dup6 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP6 opcode (0x85) - Duplicate 6th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x85_DUP6(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 6) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 6];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n] // Only 5 items
});
const err = handler_0x85_DUP6(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x85_DUP6(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x85_DUP6(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x85_DUP6(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP6](https://www.evm.codes/#85?fork=cancun)
* [Solidity Assembly - dup6](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP7 (0x86)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup7
Duplicate 7th stack item
**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:** `0x86`
**Introduced:** Frontier (EVM genesis)
DUP7 duplicates the 7th stack item and pushes it to the top of the stack. The original 7th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item6, ..., item1]
```
**Stack Output:**
```
[..., value, item6, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 7]
stack.push(value)
```
## Behavior
DUP7 copies the 7th-from-top stack item without removing it. Requires stack depth ≥ 7.
Key characteristics:
* Requires stack depth ≥ 7
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 7
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x86_DUP7 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 7th item
const frame = createFrame({
stack: [700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x86_DUP7(frame);
console.log(frame.stack); // [700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 7th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 7 items
dup7 // Duplicate 7th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]
dup7
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP7 | 3 | Duplicate 7th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
// Access v1 from depth 7
dup7
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP7 requires 7 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Only 6 items - DUP7 will fail!
dup7 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Exactly 7 items - safe
dup7 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP7 opcode (0x86) - Duplicate 7th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x86_DUP7(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 7) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 7];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n] // Only 6 items
});
const err = handler_0x86_DUP7(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x86_DUP7(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x86_DUP7(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x86_DUP7(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP7](https://www.evm.codes/#86?fork=cancun)
* [Solidity Assembly - dup7](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP8 (0x87)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup8
Duplicate 8th stack item
**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:** `0x87`
**Introduced:** Frontier (EVM genesis)
DUP8 duplicates the 8th stack item and pushes it to the top of the stack. The original 8th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item7, ..., item1]
```
**Stack Output:**
```
[..., value, item7, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 8]
stack.push(value)
```
## Behavior
DUP8 copies the 8th-from-top stack item without removing it. Requires stack depth ≥ 8.
Key characteristics:
* Requires stack depth ≥ 8
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 8
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x87_DUP8 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 8th item
const frame = createFrame({
stack: [800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x87_DUP8(frame);
console.log(frame.stack); // [800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 8th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 8 items
dup8 // Duplicate 8th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
dup8
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP8 | 3 | Duplicate 8th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
// Access v1 from depth 8
dup8
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP8 requires 8 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Only 7 items - DUP8 will fail!
dup8 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Exactly 8 items - safe
dup8 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP8 opcode (0x87) - Duplicate 8th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x87_DUP8(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 8) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 8];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 7 items
});
const err = handler_0x87_DUP8(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x87_DUP8(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x87_DUP8(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x87_DUP8(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP8](https://www.evm.codes/#87?fork=cancun)
* [Solidity Assembly - dup8](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# DUP9 (0x88)
Source: https://voltaire.tevm.sh/evm/instructions/stack/dup9
Duplicate 9th stack item
**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:** `0x88`
**Introduced:** Frontier (EVM genesis)
DUP9 duplicates the 9th stack item and pushes it to the top of the stack. The original 9th item remains in place.
## Specification
**Stack Input:**
```
[..., value, item8, ..., item1]
```
**Stack Output:**
```
[..., value, item8, ..., item1, value]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
value = stack[depth - 9]
stack.push(value)
```
## Behavior
DUP9 copies the 9th-from-top stack item without removing it. Requires stack depth ≥ 9.
Key characteristics:
* Requires stack depth ≥ 9
* Original value unchanged
* New copy pushed to top
* StackUnderflow if depth \< 9
* Stack depth increases by 1
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x88_DUP9 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Duplicate 9th item
const frame = createFrame({
stack: [900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x88_DUP9(frame);
console.log(frame.stack); // [900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n, 100n] - 9th item duplicated
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepAccess() public pure {
// Access deep stack value
assembly {
// Stack has 9 items
dup9 // Duplicate 9th item to top
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09]
dup9
// Stack: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x01] - first item duplicated
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All DUP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| DUP9 | 3 | Duplicate 9th item |
| PUSH1-32 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Access
````solidity theme={null}
function complex() public pure {
assembly {
// Build deep stack
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
// Access v1 from depth 9
dup9
}
}```
### Efficient Copies
```solidity
// Instead of multiple loads
assembly {
let value := sload(slot) // Expensive
// Use value
let value2 := sload(slot) // Wasteful!
}
// Use DUP to reuse
assembly {
let value := sload(slot) // Load once
dup1 // Copy
// Use both copies
}
````
### Conditional Logic
```solidity theme={null}
assembly {
let condition := calldataload(0)
dup1 // Keep condition for later
iszero
jumpi(skip)
// Use condition again
skip:
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// DUP9 requires 9 items on stack
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Only 8 items - DUP9 will fail!
dup9 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Exactly 9 items - safe
dup9 // Success
}
```
## Implementation
```typescript theme={null}
/**
* DUP9 opcode (0x88) - Duplicate 9th stack item
*
* Stack: [..., value, ...] => [..., value, ..., value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x88_DUP9(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length < 9) {
return { type: "StackUnderflow" };
}
const value = frame.stack[frame.stack.length - 9];
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 8 items
});
const err = handler_0x88_DUP9(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum, can't add more
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x88_DUP9(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x88_DUP9(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// Duplicate max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX]
});
handler_0x88_DUP9(frame);
console.log(frame.stack[frame.stack.length - 1]); // MAX (duplicated)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - DUP9](https://www.evm.codes/#88?fork=cancun)
* [Solidity Assembly - dup9](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# Stack Instructions
Source: https://voltaire.tevm.sh/evm/instructions/stack/index
EVM opcodes for stack manipulation - POP, PUSH, DUP, and SWAP operations
**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
Stack instructions (0x50-0x9f) provide fundamental operations for manipulating the EVM's 256-bit word stack. These 86 opcodes form the core of EVM computation, enabling value manipulation, duplication, and reordering necessary for all contract execution.
## Stack Architecture
The EVM stack has strict constraints:
* **Maximum depth**: 1024 items
* **Word size**: 256 bits (32 bytes) per item
* **Access limit**: Only top 16 items accessible via DUP/SWAP
* **Growth**: Downward (item 0 is deepest, item n-1 is top)
* **Errors**: StackOverflow (>1024), StackUnderflow (\ []`
* Use: Discard unneeded values
### Push Operations (0x5f-0x7f)
Push immediate values from bytecode onto stack:
| Opcode | Name | Bytes | Gas | Since |
| ------ | ------ | ----- | --- | ------------------- |
| 0x5f | PUSH0 | 0 | 2 | Shanghai (EIP-3855) |
| 0x60 | PUSH1 | 1 | 3 | Frontier |
| 0x61 | PUSH2 | 2 | 3 | Frontier |
| 0x62 | PUSH3 | 3 | 3 | Frontier |
| 0x63 | PUSH4 | 4 | 3 | Frontier |
| 0x64 | PUSH5 | 5 | 3 | Frontier |
| 0x65 | PUSH6 | 6 | 3 | Frontier |
| 0x66 | PUSH7 | 7 | 3 | Frontier |
| 0x67 | PUSH8 | 8 | 3 | Frontier |
| 0x68 | PUSH9 | 9 | 3 | Frontier |
| 0x69 | PUSH10 | 10 | 3 | Frontier |
| 0x6a | PUSH11 | 11 | 3 | Frontier |
| 0x6b | PUSH12 | 12 | 3 | Frontier |
| 0x6c | PUSH13 | 13 | 3 | Frontier |
| 0x6d | PUSH14 | 14 | 3 | Frontier |
| 0x6e | PUSH15 | 15 | 3 | Frontier |
| 0x6f | PUSH16 | 16 | 3 | Frontier |
| 0x70 | PUSH17 | 17 | 3 | Frontier |
| 0x71 | PUSH18 | 18 | 3 | Frontier |
| 0x72 | PUSH19 | 19 | 3 | Frontier |
| 0x73 | PUSH20 | 20 | 3 | Frontier |
| 0x74 | PUSH21 | 21 | 3 | Frontier |
| 0x75 | PUSH22 | 22 | 3 | Frontier |
| 0x76 | PUSH23 | 23 | 3 | Frontier |
| 0x77 | PUSH24 | 24 | 3 | Frontier |
| 0x78 | PUSH25 | 25 | 3 | Frontier |
| 0x79 | PUSH26 | 26 | 3 | Frontier |
| 0x7a | PUSH27 | 27 | 3 | Frontier |
| 0x7b | PUSH28 | 28 | 3 | Frontier |
| 0x7c | PUSH29 | 29 | 3 | Frontier |
| 0x7d | PUSH30 | 30 | 3 | Frontier |
| 0x7e | PUSH31 | 31 | 3 | Frontier |
| 0x7f | PUSH32 | 32 | 3 | Frontier |
**Characteristics:**
* PUSH0: Pushes constant 0 (no bytecode reading)
* PUSH1-32: Read N bytes immediately following opcode
* Big-endian byte order
* Zero-padded to 256 bits
* PC advances by 1 + N bytes
### Duplicate Operations (0x80-0x8f)
Duplicate stack items at specific depths:
| Opcode | Name | Duplicates | Gas | Stack Effect |
| ------ | ----- | ---------- | --- | --------------------------------------- |
| 0x80 | DUP1 | 1st (top) | 3 | `[a] => [a, a]` |
| 0x81 | DUP2 | 2nd | 3 | `[a, b] => [a, b, b]` |
| 0x82 | DUP3 | 3rd | 3 | `[a, b, c] => [a, b, c, c]` |
| 0x83 | DUP4 | 4th | 3 | `[a, b, c, d] => [a, b, c, d, d]` |
| 0x84 | DUP5 | 5th | 3 | `[a, b, c, d, e] => [a, b, c, d, e, e]` |
| 0x85 | DUP6 | 6th | 3 | Stack depth ≥ 6 |
| 0x86 | DUP7 | 7th | 3 | Stack depth ≥ 7 |
| 0x87 | DUP8 | 8th | 3 | Stack depth ≥ 8 |
| 0x88 | DUP9 | 9th | 3 | Stack depth ≥ 9 |
| 0x89 | DUP10 | 10th | 3 | Stack depth ≥ 10 |
| 0x8a | DUP11 | 11th | 3 | Stack depth ≥ 11 |
| 0x8b | DUP12 | 12th | 3 | Stack depth ≥ 12 |
| 0x8c | DUP13 | 13th | 3 | Stack depth ≥ 13 |
| 0x8d | DUP14 | 14th | 3 | Stack depth ≥ 14 |
| 0x8e | DUP15 | 15th | 3 | Stack depth ≥ 15 |
| 0x8f | DUP16 | 16th | 3 | Stack depth ≥ 16 |
**Characteristics:**
* DUP1: Most common, duplicates top
* DUPn: Requires stack depth ≥ n
* Result pushed to top
* Original value unchanged
* StackUnderflow if depth insufficient
### Swap Operations (0x90-0x9f)
Exchange top stack item with items at specific depths:
| Opcode | Name | Swaps With | Gas | Stack Effect |
| ------ | ------ | ---------- | --- | ------------------------------------ |
| 0x90 | SWAP1 | 2nd | 3 | `[a, b] => [b, a]` |
| 0x91 | SWAP2 | 3rd | 3 | `[a, b, c] => [c, b, a]` |
| 0x92 | SWAP3 | 4th | 3 | `[a, b, c, d] => [d, b, c, a]` |
| 0x93 | SWAP4 | 5th | 3 | `[a, b, c, d, e] => [e, b, c, d, a]` |
| 0x94 | SWAP5 | 6th | 3 | Stack depth ≥ 6 |
| 0x95 | SWAP6 | 7th | 3 | Stack depth ≥ 7 |
| 0x96 | SWAP7 | 8th | 3 | Stack depth ≥ 8 |
| 0x97 | SWAP8 | 9th | 3 | Stack depth ≥ 9 |
| 0x98 | SWAP9 | 10th | 3 | Stack depth ≥ 10 |
| 0x99 | SWAP10 | 11th | 3 | Stack depth ≥ 11 |
| 0x9a | SWAP11 | 12th | 3 | Stack depth ≥ 12 |
| 0x9b | SWAP12 | 13th | 3 | Stack depth ≥ 13 |
| 0x9c | SWAP13 | 14th | 3 | Stack depth ≥ 14 |
| 0x9d | SWAP14 | 15th | 3 | Stack depth ≥ 15 |
| 0x9e | SWAP15 | 16th | 3 | Stack depth ≥ 16 |
| 0x9f | SWAP16 | 17th | 3 | Stack depth ≥ 17 |
**Characteristics:**
* SWAP1: Most common, exchanges top two
* SWAPn: Requires stack depth ≥ n+1
* Only top and nth item change positions
* Middle items unchanged
* StackUnderflow if depth insufficient
## Gas Costs
All stack operations are extremely cheap:
| Operation | Gas | Constant |
| --------- | --- | -------------- |
| POP | 2 | GasQuickStep |
| PUSH0 | 2 | GasQuickStep |
| PUSH1-32 | 3 | GasFastestStep |
| DUP1-16 | 3 | GasFastestStep |
| SWAP1-16 | 3 | GasFastestStep |
**Why so cheap?**
* Pure stack operations (no memory/storage access)
* No external state reads
* Constant-time execution
* Critical for EVM performance
## Common Patterns
### Function Selector Matching
```solidity theme={null}
// Compiler generates PUSH4 for function selectors
function transfer(address to, uint256 amount) public {
// PUSH4 0xa9059cbb (transfer selector)
// CALLDATALOAD
// EQ
// JUMPI
}
```
### Address Literals
```solidity theme={null}
// PUSH20 for address constants
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
```
### Stack Reordering
```solidity theme={null}
assembly {
// Stack: [a, b, c]
swap1 // [a, c, b]
dup2 // [a, c, b, c]
swap2 // [c, c, b, a]
}
```
### Efficient Constants
```solidity theme={null}
assembly {
// Before Shanghai: PUSH1 0x00 (3 gas)
// After Shanghai: PUSH0 (2 gas)
push0 // Most efficient way to get 0
}
```
## Stack Depth Management
### Safe Patterns
```solidity theme={null}
function deepStack() public pure {
uint256 a = 1; // Stack: 1
uint256 b = 2; // Stack: 2
uint256 c = 3; // Stack: 3
// ... up to ~1000 locals possible
// Compiler manages stack depth automatically
return a + b + c;
}
```
### Unsafe Patterns
```solidity theme={null}
// Stack too deep error
function tooManyLocals() public pure returns (uint256) {
uint256 v1 = 1; // Stack slot 1
uint256 v2 = 2; // Stack slot 2
// ...
uint256 v17 = 17; // ERROR: Stack too deep!
// Can only access top 16 items with DUP/SWAP
return v1 + v17;
}
```
### Workarounds
```solidity theme={null}
// Use memory for deep variables
function workaround() public pure returns (uint256) {
uint256 v1 = 1;
uint256 v2 = 2;
// ... v14, v15, v16
// Move to memory before hitting limit
uint256[10] memory extra;
extra[0] = 17;
extra[1] = 18;
return v1 + extra[0];
}
```
## Security Considerations
### Stack Underflow
```solidity theme={null}
assembly {
// DANGEROUS: No validation
pop // Reverts if stack empty
}
```
**Protection:**
```solidity theme={null}
assembly {
// Check stack depth first
if iszero(lt(mload(0x40), 32)) {
pop
}
}
```
### Stack Overflow
```solidity theme={null}
function recursive(uint256 n) public pure returns (uint256) {
if (n == 0) return 1;
// Each recursion adds stack frames
// Can hit 1024 limit
return n * recursive(n - 1);
}
```
**Protection:**
```solidity theme={null}
function iterative(uint256 n) public pure returns (uint256) {
uint256 result = 1;
for (uint256 i = 1; i <= n; i++) {
result *= i;
}
return result;
}
```
### PUSH0 Availability
```solidity theme={null}
// Pre-Shanghai hardfork
assembly {
push0 // InvalidOpcode error!
}
```
**Protection:**
```solidity theme={null}
// Check hardfork or use PUSH1 0
assembly {
push1 0x00 // Works on all hardforks
}
```
## Optimization Techniques
### Minimize Stack Operations
```solidity theme={null}
// Inefficient: Extra DUP/SWAP
function inefficient(uint256 a, uint256 b) pure returns (uint256) {
assembly {
dup1
dup3
add
swap1
pop
}
}
// Efficient: Direct operations
function efficient(uint256 a, uint256 b) pure returns (uint256) {
assembly {
add(a, b)
}
}
```
### Use PUSH0 (Shanghai+)
```solidity theme={null}
// Before Shanghai: PUSH1 0x00 (3 gas)
assembly { push1 0x00 }
// After Shanghai: PUSH0 (2 gas)
assembly { push0 }
```
### Reuse Stack Values
```solidity theme={null}
// Bad: Push same value twice
assembly {
push1 0x20
mstore
push1 0x20 // Wasteful
add
}
// Good: DUP existing value
assembly {
push1 0x20
dup1
mstore
add
}
```
## Implementation Reference
Stack instruction handlers implemented in:
* **TypeScript**: `/src/evm/stack/handlers/`
* **Zig**: `/src/evm/stack/handlers_stack.zig`
Each instruction follows standard handler pattern:
1. Consume gas
2. Validate stack constraints
3. Perform operation (pop/push/duplicate/swap)
4. Increment program counter
5. Return error or null
## All Stack Instructions
Complete opcode reference:
```
0x50: POP
0x5f: PUSH0
0x60-0x7f: PUSH1-PUSH32 (33 opcodes)
0x80-0x8f: DUP1-DUP16 (16 opcodes)
0x90-0x9f: SWAP1-SWAP16 (16 opcodes)
Total: 66 opcodes
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack)
* [EVM Codes - Stack Operations](https://www.evm.codes/#50?fork=cancun)
* [EIP-3855](https://eips.ethereum.org/EIPS/eip-3855) - PUSH0 instruction
* [Solidity Stack Layout](https://docs.soliditylang.org/en/latest/internals/layout_in_memory.html)
* [Stack Too Deep Solutions](https://soliditylang.org/blog/2021/03/02/stack-too-deep/)
# POP (0x50)
Source: https://voltaire.tevm.sh/evm/instructions/stack/pop
Remove top item from 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:** `0x50`
**Introduced:** Frontier (EVM genesis)
POP removes the top item from the stack without using its value. Used to discard unneeded computation results or clean up the stack.
## Specification
**Stack Input:**
```
value (any uint256)
```
**Stack Output:**
```
[]
```
**Gas Cost:** 2 (GasQuickStep)
**Operation:**
```
stack.pop()
```
## Behavior
POP discards the top stack item. The value is not returned or used - it simply removes one item from the stack depth.
Key characteristics:
* Requires stack depth ≥ 1
* Does not return the popped value
* Decreases stack depth by 1
* Cannot fail on empty stack (reverts with StackUnderflow)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x50_POP } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Discard top value
const frame = createFrame({
stack: [42n, 100n],
gasRemaining: 1000n
});
const err = handler_0x50_POP(frame);
console.log(frame.stack); // [42n] - top value removed
console.log(frame.gasRemaining); // 998n
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function discard() public pure returns (uint256) {
uint256 a = 10;
uint256 b = 20;
// b not used - compiler inserts POP
return a;
}
}
// Generated bytecode:
// PUSH1 0x0a (push 10)
// PUSH1 0x14 (push 20)
// POP (discard b)
// ... (return a)
```
### Assembly Usage
```solidity theme={null}
assembly {
// Clean up unused return values
let x := 100
let y := add(x, 50) // Stack: [150]
pop // Discard result
// Stack: []
}
```
## Gas Cost
**Cost:** 2 gas (GasQuickStep)
POP is one of the cheapest stack operations, same tier as:
* PUSH0 (0x5f): 2 gas
Cheaper than:
* PUSH1-32 (0x60-0x7f): 3 gas
* DUP1-16 (0x80-0x8f): 3 gas
* SWAP1-16 (0x90-0x9f): 3 gas
## Common Usage
### Discarding Return Values
```solidity theme={null}
contract TokenSwap {
IERC20 token;
function swap() public {
// Transfer returns bool, but we don't check it
assembly {
// CALL returns success on stack
// If we don't need it:
pop // Discard return value
}
}
}
```
### Stack Cleanup
```solidity theme={null}
assembly {
// After complex computation
let a := add(1, 2) // Stack: [3]
let b := mul(a, 4) // Stack: [3, 12]
let c := div(b, 2) // Stack: [3, 12, 6]
// Only need final result
swap2 // Stack: [6, 12, 3]
pop // Stack: [6, 12]
pop // Stack: [6]
}
```
### Optimizing Storage Reads
```solidity theme={null}
function getBalance(address user) public view returns (uint256) {
assembly {
// Load storage slot
mstore(0, user)
mstore(32, 0)
let slot := keccak256(0, 64)
let balance := sload(slot)
// Clean up memory (optional optimization)
mstore(0, 0) // Stack: [0]
pop // Clean stack
mstore(32, 0) // Stack: [0]
pop // Clean stack
// Return balance
mstore(0, balance)
return(0, 32)
}
}
```
## Security
### Stack Underflow Protection
```solidity theme={null}
// UNSAFE: Assumes stack has value
assembly {
pop // Reverts if stack empty!
}
```
```solidity theme={null}
// SAFE: Check before popping
function safePop() public pure {
assembly {
// Solidity ensures stack safety
let x := 100
pop // Safe, x on stack
}
}
```
### Double Spending Prevention
```solidity theme={null}
// DANGEROUS: Forgetting to pop
contract Vulnerable {
mapping(address => uint256) balances;
function withdraw() public {
assembly {
// Load balance
let bal := sload(balances.slot)
// Transfer (leaves success on stack)
// Forgot to POP success value!
// Next operation uses wrong value!
}
}
}
```
### Gas Waste
```solidity theme={null}
// INEFFICIENT: Unnecessary computation
function waste() public pure returns (uint256) {
uint256 x = expensiveComputation(); // Gas spent
pop(x); // Result discarded!
return 42;
}
// EFFICIENT: Don't compute if not needed
function efficient() public pure returns (uint256) {
return 42;
}
```
## Optimization
### Avoid Unnecessary Pushes
```solidity theme={null}
// BAD: Push then immediately pop
assembly {
push1 0x42
pop
}
// GOOD: Don't push at all
assembly {
// Nothing
}
```
### Reorder to Minimize POPs
```solidity theme={null}
// INEFFICIENT: Many POPs
assembly {
let a := 1
let b := 2
let c := 3
pop // Discard c
pop // Discard b
// Use a
}
// EFFICIENT: Avoid intermediate variables
assembly {
let a := 1
// Use a directly
}
```
## Implementation
```typescript theme={null}
import { consumeGas } from "../../Frame/consumeGas.js";
import { popStack } from "../../Frame/popStack.js";
import { FastestStep } from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* POP opcode (0x50) - Remove top item from stack
*
* Stack: [value] => []
* Gas: 2 (GasQuickStep)
*/
export function handler_0x50_POP(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const { error } = popStack(frame);
if (error) return error;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Empty Stack
```typescript theme={null}
// Stack underflow
const frame = createFrame({ stack: [] });
const err = handler_0x50_POP(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Single Item Stack
```typescript theme={null}
// Success case
const frame = createFrame({ stack: [100n] });
const err = handler_0x50_POP(frame);
console.log(err); // null
console.log(frame.stack); // []
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [42n],
gasRemaining: 1n
});
const err = handler_0x50_POP(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Stack Depth
```typescript theme={null}
// Works at any depth
const frame = createFrame({
stack: new Array(1024).fill(0n)
});
const err = handler_0x50_POP(frame);
console.log(err); // null
console.log(frame.stack.length); // 1023
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - POP](https://www.evm.codes/#50)
* [Solidity Assembly - pop](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH0 (0x5f)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push0
Push constant zero 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:** `0x5f`
**Introduced:** Shanghai (EIP-3855)
PUSH0 pushes the constant value 0 onto the stack. Introduced in Shanghai hardfork as a gas optimization - previously required PUSH1 0x00 (3 gas).
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
0 (uint256)
```
**Gas Cost:** 2 (GasQuickStep)
**Operation:**
```
stack.push(0)
```
## Behavior
PUSH0 pushes constant zero without reading from bytecode. Unlike PUSH1-32, no immediate bytes follow the opcode.
Key characteristics:
* No bytecode reading (pure constant)
* Cheaper than PUSH1 0x00 (2 vs 3 gas)
* Only available Shanghai hardfork onwards
* InvalidOpcode error on earlier hardforks
* Most efficient way to push zero
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x5f_PUSH0 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Push zero
const frame = createFrame({
stack: [],
gasRemaining: 1000n
});
const err = handler_0x5f_PUSH0(frame);
console.log(frame.stack); // [0n]
console.log(frame.gasRemaining); // 998n (2 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function getZero() public pure returns (uint256) {
return 0;
}
// Pre-Shanghai:
// PUSH1 0x00 (3 gas)
// Shanghai+:
// PUSH0 (2 gas)
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Most efficient zero initialization
push0 // 2 gas
// Old way (still works)
push1 0x00 // 3 gas
// Use for memory initialization
push0
push0
mstore // Store 0 at memory offset 0
}
```
## Gas Cost
**Cost:** 2 gas (GasQuickStep)
**Comparison:**
| Opcode | Gas | Bytes | Note |
| ---------- | --- | ----- | -------------- |
| PUSH0 | 2 | 1 | Shanghai+ only |
| PUSH1 0x00 | 3 | 2 | All hardforks |
**Savings:**
* 1 gas per zero value
* 1 byte per zero value in bytecode
* Significant for contracts with many zero constants
## Common Usage
### Memory Initialization
```solidity theme={null}
assembly {
// Clear memory slots
push0
push0
mstore // mem[0] = 0
push0
push1 0x20
mstore // mem[32] = 0
}
```
### Default Return Values
```solidity theme={null}
function maybeValue(bool condition) public pure returns (uint256) {
if (!condition) {
assembly {
push0
push0
mstore
return(0, 32) // Return 0
}
}
return 42;
}
```
### Array Length Initialization
```solidity theme={null}
assembly {
// Create empty array in memory
let ptr := mload(0x40) // Free memory pointer
push0
mstore(ptr, 0) // Length = 0
mstore(0x40, add(ptr, 0x20)) // Update free pointer
}
```
### Comparison Operations
```solidity theme={null}
assembly {
// Check if value is zero
let x := calldataload(0)
push0
eq // x == 0
}
```
## Hardfork Compatibility
### Shanghai Check
```typescript theme={null}
// Zig implementation checks hardfork
if (push_size == 0) {
const evm = frame.getEvm();
if (evm.hardfork.isBefore(.SHANGHAI)) {
return error.InvalidOpcode;
}
try frame.consumeGas(GasConstants.GasQuickStep);
}
```
### Safe Fallback
```solidity theme={null}
// Pre-Shanghai compatible code
assembly {
// Use PUSH1 for compatibility
push1 0x00
}
// Shanghai+ optimized code
assembly {
// Use PUSH0 for efficiency
push0
}
```
## EIP-3855 Rationale
**Problem:**
* PUSH1 0x00 wastes gas (3 instead of 2)
* PUSH1 0x00 wastes bytecode space (2 bytes instead of 1)
* Zero is extremely common in EVM code
**Solution:**
* Dedicated opcode for pushing zero
* Same gas as other constant operations (ADDRESS, CALLER, etc.)
* Saves \~0.1% gas on typical contracts
**Impact:**
```solidity theme={null}
// Example contract
contract Token {
mapping(address => uint256) balances;
function transfer(address to, uint256 amount) public {
// Many zero comparisons and initializations
// Each PUSH0 saves 1 gas compared to PUSH1 0x00
}
}
// Aggregate savings: ~100-500 gas per transaction
```
## Security
### Hardfork Detection
```solidity theme={null}
// UNSAFE: Assumes Shanghai
assembly {
push0 // May revert pre-Shanghai!
}
```
```solidity theme={null}
// SAFE: Check hardfork or use PUSH1
function safeZero() public pure returns (uint256) {
assembly {
// Use PUSH1 0x00 for compatibility
push1 0x00
}
}
```
### Gas Calculation
```solidity theme={null}
// Account for hardfork differences
function estimateGas(bool isShanghai) public pure returns (uint256) {
if (isShanghai) {
return 2; // PUSH0
} else {
return 3; // PUSH1 0x00
}
}
```
## Optimization
### Replace PUSH1 0x00
```solidity theme={null}
// BEFORE (Pre-Shanghai or conservative)
assembly {
push1 0x00
push1 0x00
push1 0x00
// Total: 9 gas, 6 bytes
}
// AFTER (Shanghai+)
assembly {
push0
push0
push0
// Total: 6 gas, 3 bytes
}
```
### Memory Clearing
```solidity theme={null}
// Efficient memory initialization
assembly {
// Clear 5 slots
push0
dup1
dup1
dup1
dup1
// Cost: 2 (PUSH0) + 4*3 (DUP) = 14 gas
// vs PUSH1 0x00 version: 3 + 4*3 = 15 gas
}
```
## Implementation
```typescript theme={null}
import { consumeGas } from "../../Frame/consumeGas.js";
import { pushStack } from "../../Frame/pushStack.js";
import { QuickStep } from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* PUSH0 opcode (0x5f) - Push 0 onto stack
* EIP-3855: Introduced in Shanghai hardfork
*
* Stack: [] => [0]
* Gas: 2 (GasQuickStep)
*/
export function handler_0x5f_PUSH0(frame: FrameType): EvmError | null {
// Note: Add hardfork validation when Hardfork module is available
// if (evm.hardfork.isBefore(.SHANGHAI)) {
// return { type: "InvalidOpcode" };
// }
const gasErr = consumeGas(frame, QuickStep);
if (gasErr) return gasErr;
const pushErr = pushStack(frame, 0n);
if (pushErr) return pushErr;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
gasRemaining: 10n
});
const err = handler_0x5f_PUSH0(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [],
gasRemaining: 1n
});
const err = handler_0x5f_PUSH0(frame);
console.log(err); // { type: "OutOfGas" }
```
### Pre-Shanghai Error
```typescript theme={null}
// Would error on pre-Shanghai hardfork
// (hardfork check not yet implemented in TS)
const frame = createFrame({
hardfork: 'london',
stack: []
});
// Note: Once hardfork check is wired, this should return InvalidOpcode
const err = handler_0x5f_PUSH0(frame);
```
## References
* [EIP-3855: PUSH0 instruction](https://eips.ethereum.org/EIPS/eip-3855)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1
* [EVM Codes - PUSH0](https://www.evm.codes/#5f?fork=shanghai)
* [Shanghai Hardfork Meta](https://eips.ethereum.org/EIPS/eip-3855)
# PUSH1 (0x60)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push1
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
```typescript theme={null}
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
```solidity theme={null}
contract Example {
// Function selectors use PUSH4
function transfer() public {
// PUSH4 0xa9059cbb (4-byte selector)
}
}
```
### Assembly Usage
```solidity theme={null}
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
```solidity theme={null}
assembly {
push1 0x20 // Memory offset (32 bytes)
push1 0x00 // Zero offset
push1 0x01 // Boolean true
push1 0xff // Maximum byte value
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH1 01
// Reads as: 0x01
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 0: 0x01 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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
```typescript theme={null}
// 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
```typescript theme={null}
// 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
```typescript theme={null}
// 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
```typescript theme={null}
// 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](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH1](https://www.evm.codes/#60?fork=cancun)
* [Solidity Assembly - push1](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH10 (0x69)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push10
Push 10-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:** `0x69`
**Introduced:** Frontier (EVM genesis)
PUSH10 pushes a 10-byte immediate value from the bytecode onto the stack. The 10 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 10 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 10 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 10) // Big-endian
stack.push(value)
pc += 11
```
## Behavior
PUSH10 reads 10 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 10 bytes 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 11 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x69_PUSH10 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH10
const bytecode = new Uint8Array([
0x69, // PUSH10
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a // 10 bytes: 0102030405060708090a
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x69_PUSH10(frame);
console.log(frame.stack); // [0x0102030405060708090a00000000000000000000000000000000000000000000n]
console.log(frame.pc); // 11
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 10-byte constant
uint80 constant VALUE = 1.2089258196146292e+24;
// PUSH10 0xffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 10-byte value
push10 0xffffffffffffffffffff
// Example: 10-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH10: 11 bytes (1 opcode + 10 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
### 10-Byte Constants
```solidity theme={null}
assembly {
// 10-byte literal
push10 0xabababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH10 01 02 03 04 05 06 07 08 09 0a
// Reads as: 0x0102030405060708090a
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 9: 0x0a (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH10 opcode (0x69) - Push 10 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x69_PUSH10(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 10);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 11;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 10 bytes read
const bytecode = new Uint8Array([0x69, 0x01]); // Only 1 byte instead of 10
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x69_PUSH10(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x69_PUSH10(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x69_PUSH10(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x69_PUSH10(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffff00000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH10](https://www.evm.codes/#69?fork=cancun)
* [Solidity Assembly - push10](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH11 (0x6A)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push11
Push 11-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:** `0x6A`
**Introduced:** Frontier (EVM genesis)
PUSH11 pushes a 11-byte immediate value from the bytecode onto the stack. The 11 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 11 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 11 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 11) // Big-endian
stack.push(value)
pc += 12
```
## Behavior
PUSH11 reads 11 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 11 bytes 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 12 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6A_PUSH11 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH11
const bytecode = new Uint8Array([
0x6A, // PUSH11
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b // 11 bytes: 0102030405060708090a0b
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6A_PUSH11(frame);
console.log(frame.stack); // [0x0102030405060708090a0b000000000000000000000000000000000000000000n]
console.log(frame.pc); // 12
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 11-byte constant
uint88 constant VALUE = 3.094850098213451e+26;
// PUSH11 0xffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 11-byte value
push11 0xffffffffffffffffffffff
// Example: 11-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH11: 12 bytes (1 opcode + 11 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
### 11-Byte Constants
```solidity theme={null}
assembly {
// 11-byte literal
push11 0xababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH11 01 02 03 04 05 06 07 08 09 0a 0b
// Reads as: 0x0102030405060708090a0b
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 10: 0x0b (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH11 opcode (0x6A) - Push 11 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6A_PUSH11(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 11);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 12;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 11 bytes read
const bytecode = new Uint8Array([0x6A, 0x01]); // Only 1 byte instead of 11
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6A_PUSH11(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6A_PUSH11(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6A, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6A_PUSH11(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6A, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6A_PUSH11(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffff000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH11](https://www.evm.codes/#6a?fork=cancun)
* [Solidity Assembly - push11](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH12 (0x6B)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push12
Push 12-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:** `0x6B`
**Introduced:** Frontier (EVM genesis)
PUSH12 pushes a 12-byte immediate value from the bytecode onto the stack. The 12 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 12 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 12 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 12) // Big-endian
stack.push(value)
pc += 13
```
## Behavior
PUSH12 reads 12 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 12 bytes 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 13 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6B_PUSH12 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH12
const bytecode = new Uint8Array([
0x6B, // PUSH12
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c // 12 bytes: 0102030405060708090a0b0c
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6B_PUSH12(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0000000000000000000000000000000000000000n]
console.log(frame.pc); // 13
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 12-byte constant
uint96 constant VALUE = 7.922816251426434e+28;
// PUSH12 0xffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 12-byte value
push12 0xffffffffffffffffffffffff
// Example: 12-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH12: 13 bytes (1 opcode + 12 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
### 12-Byte Constants
```solidity theme={null}
assembly {
// 12-byte literal
push12 0xabababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH12 01 02 03 04 05 06 07 08 09 0a 0b 0c
// Reads as: 0x0102030405060708090a0b0c
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 11: 0x0c (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH12 opcode (0x6B) - Push 12 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6B_PUSH12(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 12);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 13;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 12 bytes read
const bytecode = new Uint8Array([0x6B, 0x01]); // Only 1 byte instead of 12
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6B_PUSH12(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6B_PUSH12(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6B, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6B_PUSH12(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6B, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6B_PUSH12(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffff0000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH12](https://www.evm.codes/#6b?fork=cancun)
* [Solidity Assembly - push12](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH13 (0x6C)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push13
Push 13-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:** `0x6C`
**Introduced:** Frontier (EVM genesis)
PUSH13 pushes a 13-byte immediate value from the bytecode onto the stack. The 13 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 13 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 13 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 13) // Big-endian
stack.push(value)
pc += 14
```
## Behavior
PUSH13 reads 13 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 13 bytes 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 14 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6C_PUSH13 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH13
const bytecode = new Uint8Array([
0x6C, // PUSH13
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d // 13 bytes: 0102030405060708090a0b0c0d
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6C_PUSH13(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d00000000000000000000000000000000000000n]
console.log(frame.pc); // 14
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 13-byte constant
uint104 constant VALUE = 2.028240960365167e+31;
// PUSH13 0xffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 13-byte value
push13 0xffffffffffffffffffffffffff
// Example: 13-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH13: 14 bytes (1 opcode + 13 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
### 13-Byte Constants
```solidity theme={null}
assembly {
// 13-byte literal
push13 0xababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH13 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d
// Reads as: 0x0102030405060708090a0b0c0d
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 12: 0x0d (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH13 opcode (0x6C) - Push 13 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6C_PUSH13(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 13);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 14;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 13 bytes read
const bytecode = new Uint8Array([0x6C, 0x01]); // Only 1 byte instead of 13
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6C_PUSH13(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6C_PUSH13(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6C, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6C_PUSH13(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6C, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6C_PUSH13(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffff00000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH13](https://www.evm.codes/#6c?fork=cancun)
* [Solidity Assembly - push13](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH14 (0x6D)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push14
Push 14-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:** `0x6D`
**Introduced:** Frontier (EVM genesis)
PUSH14 pushes a 14-byte immediate value from the bytecode onto the stack. The 14 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 14 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 14 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 14) // Big-endian
stack.push(value)
pc += 15
```
## Behavior
PUSH14 reads 14 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 14 bytes 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 15 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6D_PUSH14 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH14
const bytecode = new Uint8Array([
0x6D, // PUSH14
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e // 14 bytes: 0102030405060708090a0b0c0d0e
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6D_PUSH14(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e000000000000000000000000000000000000n]
console.log(frame.pc); // 15
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 14-byte constant
uint112 constant VALUE = 5.192296858534828e+33;
// PUSH14 0xffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 14-byte value
push14 0xffffffffffffffffffffffffffff
// Example: 14-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH14: 15 bytes (1 opcode + 14 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
### 14-Byte Constants
```solidity theme={null}
assembly {
// 14-byte literal
push14 0xabababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH14 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e
// Reads as: 0x0102030405060708090a0b0c0d0e
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 13: 0x0e (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH14 opcode (0x6D) - Push 14 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6D_PUSH14(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 14);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 15;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 14 bytes read
const bytecode = new Uint8Array([0x6D, 0x01]); // Only 1 byte instead of 14
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6D_PUSH14(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6D_PUSH14(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6D, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6D_PUSH14(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6D, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6D_PUSH14(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffff000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH14](https://www.evm.codes/#6d?fork=cancun)
* [Solidity Assembly - push14](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH15 (0x6E)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push15
Push 15-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:** `0x6E`
**Introduced:** Frontier (EVM genesis)
PUSH15 pushes a 15-byte immediate value from the bytecode onto the stack. The 15 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 15 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 15 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 15) // Big-endian
stack.push(value)
pc += 16
```
## Behavior
PUSH15 reads 15 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 15 bytes 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 16 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6E_PUSH15 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH15
const bytecode = new Uint8Array([
0x6E, // PUSH15
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f // 15 bytes: 0102030405060708090a0b0c0d0e0f
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6E_PUSH15(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f0000000000000000000000000000000000n]
console.log(frame.pc); // 16
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 15-byte constant
uint120 constant VALUE = 1.329227995784916e+36;
// PUSH15 0xffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 15-byte value
push15 0xffffffffffffffffffffffffffffff
// Example: 15-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH15: 16 bytes (1 opcode + 15 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
### 15-Byte Constants
```solidity theme={null}
assembly {
// 15-byte literal
push15 0xababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH15 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
// Reads as: 0x0102030405060708090a0b0c0d0e0f
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 14: 0x0f (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH15 opcode (0x6E) - Push 15 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6E_PUSH15(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 15);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 16;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 15 bytes read
const bytecode = new Uint8Array([0x6E, 0x01]); // Only 1 byte instead of 15
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6E_PUSH15(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6E_PUSH15(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6E, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6E_PUSH15(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6E, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6E_PUSH15(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffff0000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH15](https://www.evm.codes/#6e?fork=cancun)
* [Solidity Assembly - push15](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH16 (0x6F)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push16
Push 16-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:** `0x6F`
**Introduced:** Frontier (EVM genesis)
PUSH16 pushes a 16-byte immediate value from the bytecode onto the stack. The 16 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 16 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 16 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 16) // Big-endian
stack.push(value)
pc += 17
```
## Behavior
PUSH16 reads 16 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 16 bytes 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 17 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x6F_PUSH16 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH16
const bytecode = new Uint8Array([
0x6F, // PUSH16
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 // 16 bytes: 0102030405060708090a0b0c0d0e0f10
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x6F_PUSH16(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1000000000000000000000000000000000n]
console.log(frame.pc); // 17
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 16-byte constant
uint128 constant VALUE = 3.402823669209385e+38;
// PUSH16 0xffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 16-byte value
push16 0xffffffffffffffffffffffffffffffff
// Example: 16-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH16: 17 bytes (1 opcode + 16 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
### 16-Byte Constants
```solidity theme={null}
assembly {
// 16-byte literal
push16 0xabababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH16 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10
// Reads as: 0x0102030405060708090a0b0c0d0e0f10
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 15: 0x10 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH16 opcode (0x6F) - Push 16 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x6F_PUSH16(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 16);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 17;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 16 bytes read
const bytecode = new Uint8Array([0x6F, 0x01]); // Only 1 byte instead of 16
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x6F_PUSH16(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x6F_PUSH16(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x6F, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x6F_PUSH16(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x6F, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x6F_PUSH16(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH16](https://www.evm.codes/#6f?fork=cancun)
* [Solidity Assembly - push16](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH17 (0x70)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push17
Push 17-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:** `0x70`
**Introduced:** Frontier (EVM genesis)
PUSH17 pushes a 17-byte immediate value from the bytecode onto the stack. The 17 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 17 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 17 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 17) // Big-endian
stack.push(value)
pc += 18
```
## Behavior
PUSH17 reads 17 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 17 bytes 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 18 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x70_PUSH17 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH17
const bytecode = new Uint8Array([
0x70, // PUSH17
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11 // 17 bytes: 0102030405060708090a0b0c0d0e0f1011
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x70_PUSH17(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011000000000000000000000000000000n]
console.log(frame.pc); // 18
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 17-byte constant
uint136 constant VALUE = 8.711228593176025e+40;
// PUSH17 0xffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 17-byte value
push17 0xffffffffffffffffffffffffffffffffff
// Example: 17-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH17: 18 bytes (1 opcode + 17 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
### 17-Byte Constants
```solidity theme={null}
assembly {
// 17-byte literal
push17 0xababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH17 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11
// Reads as: 0x0102030405060708090a0b0c0d0e0f1011
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 16: 0x11 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH17 opcode (0x70) - Push 17 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x70_PUSH17(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 17);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 18;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 17 bytes read
const bytecode = new Uint8Array([0x70, 0x01]); // Only 1 byte instead of 17
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x70_PUSH17(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x70_PUSH17(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x70_PUSH17(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x70_PUSH17(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffff000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH17](https://www.evm.codes/#70?fork=cancun)
* [Solidity Assembly - push17](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH18 (0x71)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push18
Push 18-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:** `0x71`
**Introduced:** Frontier (EVM genesis)
PUSH18 pushes a 18-byte immediate value from the bytecode onto the stack. The 18 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 18 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 18 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 18) // Big-endian
stack.push(value)
pc += 19
```
## Behavior
PUSH18 reads 18 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 18 bytes 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 19 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x71_PUSH18 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH18
const bytecode = new Uint8Array([
0x71, // PUSH18
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12 // 18 bytes: 0102030405060708090a0b0c0d0e0f101112
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x71_PUSH18(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011120000000000000000000000000000n]
console.log(frame.pc); // 19
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 18-byte constant
uint144 constant VALUE = 2.2300745198530623e+43;
// PUSH18 0xffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 18-byte value
push18 0xffffffffffffffffffffffffffffffffffff
// Example: 18-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH18: 19 bytes (1 opcode + 18 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
### 18-Byte Constants
```solidity theme={null}
assembly {
// 18-byte literal
push18 0xabababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH18 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 17: 0x12 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH18 opcode (0x71) - Push 18 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x71_PUSH18(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 18);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 19;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 18 bytes read
const bytecode = new Uint8Array([0x71, 0x01]); // Only 1 byte instead of 18
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x71_PUSH18(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x71_PUSH18(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x71, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x71_PUSH18(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x71, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x71_PUSH18(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH18](https://www.evm.codes/#71?fork=cancun)
* [Solidity Assembly - push18](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH19 (0x72)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push19
Push 19-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:** `0x72`
**Introduced:** Frontier (EVM genesis)
PUSH19 pushes a 19-byte immediate value from the bytecode onto the stack. The 19 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 19 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 19 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 19) // Big-endian
stack.push(value)
pc += 20
```
## Behavior
PUSH19 reads 19 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 19 bytes 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 20 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x72_PUSH19 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH19
const bytecode = new Uint8Array([
0x72, // PUSH19
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 // 19 bytes: 0102030405060708090a0b0c0d0e0f10111213
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x72_PUSH19(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121300000000000000000000000000n]
console.log(frame.pc); // 20
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 19-byte constant
uint152 constant VALUE = 5.70899077082384e+45;
// PUSH19 0xffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 19-byte value
push19 0xffffffffffffffffffffffffffffffffffffff
// Example: 19-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH19: 20 bytes (1 opcode + 19 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
### 19-Byte Constants
```solidity theme={null}
assembly {
// 19-byte literal
push19 0xababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH19 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
// Reads as: 0x0102030405060708090a0b0c0d0e0f10111213
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 18: 0x13 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH19 opcode (0x72) - Push 19 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x72_PUSH19(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 19);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 20;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 19 bytes read
const bytecode = new Uint8Array([0x72, 0x01]); // Only 1 byte instead of 19
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x72_PUSH19(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x72_PUSH19(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x72_PUSH19(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x72, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x72_PUSH19(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffff00000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH19](https://www.evm.codes/#72?fork=cancun)
* [Solidity Assembly - push19](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH2 (0x61)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push2
Push 2-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:** `0x61`
**Introduced:** Frontier (EVM genesis)
PUSH2 pushes a 2-byte immediate value from the bytecode onto the stack. The 2 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 2 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 2 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 2) // Big-endian
stack.push(value)
pc += 3
```
## Behavior
PUSH2 reads 2 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 2 bytes 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 3 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x61_PUSH2 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH2
const bytecode = new Uint8Array([
0x61, // PUSH2
0x01, 0x02 // 2 bytes: 0102
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x61_PUSH2(frame);
console.log(frame.stack); // [0x0102000000000000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 3
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// Function selectors use PUSH4
function transfer() public {
// PUSH4 0xa9059cbb (4-byte selector)
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 2-byte value
push2 0xffff
// Example: 2-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH2: 3 bytes (1 opcode + 2 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
### 2-Byte Constants
```solidity theme={null}
assembly {
// 2-byte literal
push2 0xabab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH2 01 02
// Reads as: 0x0102
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 1: 0x02 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH2 opcode (0x61) - Push 2 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x61_PUSH2(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 2);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 3;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 2 bytes read
const bytecode = new Uint8Array([0x61, 0x01]); // Only 1 byte instead of 2
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x61_PUSH2(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x61, 0x00, 0x00])
});
const err = handler_0x61_PUSH2(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x61, 0xff, 0xff])
});
const err = handler_0x61_PUSH2(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x61, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x61_PUSH2(frame);
console.log(frame.stack[0]); // 0xffff000000000000000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH2](https://www.evm.codes/#61?fork=cancun)
* [Solidity Assembly - push2](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH20 (0x73)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push20
Push 20-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:** `0x73`
**Introduced:** Frontier (EVM genesis)
PUSH20 pushes a 20-byte immediate value from the bytecode onto the stack. The 20 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 20 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 20 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 20) // Big-endian
stack.push(value)
pc += 21
```
## Behavior
PUSH20 reads 20 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 20 bytes 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 21 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x73_PUSH20 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH20
const bytecode = new Uint8Array([
0x73, // PUSH20
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 // 20 bytes: 0102030405060708090a0b0c0d0e0f1011121314
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x73_PUSH20(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314000000000000000000000000n]
console.log(frame.pc); // 21
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// Addresses use PUSH20
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
// PUSH20 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 20-byte value
push20 0xffffffffffffffffffffffffffffffffffffffff
// Example: address literal
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH20: 21 bytes (1 opcode + 20 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) |
\| PUSH20 | 3 | 21 | Address literals |
## Common Usage
### Address Constants
```solidity theme={null}
contract Uniswap {
// WETH address
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
// Compiled to:
// PUSH20 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH20 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14
// Reads as: 0x0102030405060708090a0b0c0d0e0f1011121314
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 19: 0x14 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH20 opcode (0x73) - Push 20 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x73_PUSH20(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 20);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 21;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 20 bytes read
const bytecode = new Uint8Array([0x73, 0x01]); // Only 1 byte instead of 20
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x73_PUSH20(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x73_PUSH20(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x73_PUSH20(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x73_PUSH20(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH20](https://www.evm.codes/#73?fork=cancun)
* [Solidity Assembly - push20](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH21 (0x74)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push21
Push 21-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:** `0x74`
**Introduced:** Frontier (EVM genesis)
PUSH21 pushes a 21-byte immediate value from the bytecode onto the stack. The 21 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 21 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 21 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 21) // Big-endian
stack.push(value)
pc += 22
```
## Behavior
PUSH21 reads 21 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 21 bytes 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 22 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x74_PUSH21 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH21
const bytecode = new Uint8Array([
0x74, // PUSH21
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 // 21 bytes: 0102030405060708090a0b0c0d0e0f101112131415
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x74_PUSH21(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314150000000000000000000000n]
console.log(frame.pc); // 22
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 21-byte constant
uint168 constant VALUE = 3.7414441915671115e+50;
// PUSH21 0xffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 21-byte value
push21 0xffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH21: 22 bytes (1 opcode + 21 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
### 21-Byte Constants
```solidity theme={null}
assembly {
// 21-byte literal
push21 0xababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH21 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 20: 0x15 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH21 opcode (0x74) - Push 21 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x74_PUSH21(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 21);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 22;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 21 bytes read
const bytecode = new Uint8Array([0x74, 0x01]); // Only 1 byte instead of 21
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x74_PUSH21(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x74_PUSH21(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x74_PUSH21(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x74, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x74_PUSH21(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffff0000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH21](https://www.evm.codes/#74?fork=cancun)
* [Solidity Assembly - push21](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH22 (0x75)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push22
Push 22-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:** `0x75`
**Introduced:** Frontier (EVM genesis)
PUSH22 pushes a 22-byte immediate value from the bytecode onto the stack. The 22 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 22 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 22 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 22) // Big-endian
stack.push(value)
pc += 23
```
## Behavior
PUSH22 reads 22 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 22 bytes 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 23 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x75_PUSH22 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH22
const bytecode = new Uint8Array([
0x75, // PUSH22
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 // 22 bytes: 0102030405060708090a0b0c0d0e0f10111213141516
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x75_PUSH22(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314151600000000000000000000n]
console.log(frame.pc); // 23
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 22-byte constant
uint176 constant VALUE = 9.578097130411805e+52;
// PUSH22 0xffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 22-byte value
push22 0xffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH22: 23 bytes (1 opcode + 22 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
### 22-Byte Constants
```solidity theme={null}
assembly {
// 22-byte literal
push22 0xabababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH22 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16
// Reads as: 0x0102030405060708090a0b0c0d0e0f10111213141516
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 21: 0x16 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH22 opcode (0x75) - Push 22 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x75_PUSH22(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 22);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 23;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 22 bytes read
const bytecode = new Uint8Array([0x75, 0x01]); // Only 1 byte instead of 22
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x75_PUSH22(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x75_PUSH22(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x75_PUSH22(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x75_PUSH22(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffff00000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH22](https://www.evm.codes/#75?fork=cancun)
* [Solidity Assembly - push22](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH23 (0x76)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push23
Push 23-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:** `0x76`
**Introduced:** Frontier (EVM genesis)
PUSH23 pushes a 23-byte immediate value from the bytecode onto the stack. The 23 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 23 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 23 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 23) // Big-endian
stack.push(value)
pc += 24
```
## Behavior
PUSH23 reads 23 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 23 bytes 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 24 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x76_PUSH23 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH23
const bytecode = new Uint8Array([
0x76, // PUSH23
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 // 23 bytes: 0102030405060708090a0b0c0d0e0f1011121314151617
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x76_PUSH23(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314151617000000000000000000n]
console.log(frame.pc); // 24
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 23-byte constant
uint184 constant VALUE = 2.4519928653854222e+55;
// PUSH23 0xffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 23-byte value
push23 0xffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH23: 24 bytes (1 opcode + 23 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
### 23-Byte Constants
```solidity theme={null}
assembly {
// 23-byte literal
push23 0xababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH23 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17
// Reads as: 0x0102030405060708090a0b0c0d0e0f1011121314151617
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 22: 0x17 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH23 opcode (0x76) - Push 23 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x76_PUSH23(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 23);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 24;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 23 bytes read
const bytecode = new Uint8Array([0x76, 0x01]); // Only 1 byte instead of 23
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x76_PUSH23(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x76_PUSH23(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x76_PUSH23(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x76_PUSH23(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH23](https://www.evm.codes/#76?fork=cancun)
* [Solidity Assembly - push23](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH24 (0x77)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push24
Push 24-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:** `0x77`
**Introduced:** Frontier (EVM genesis)
PUSH24 pushes a 24-byte immediate value from the bytecode onto the stack. The 24 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 24 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 24 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 24) // Big-endian
stack.push(value)
pc += 25
```
## Behavior
PUSH24 reads 24 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 24 bytes 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 25 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x77_PUSH24 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH24
const bytecode = new Uint8Array([
0x77, // PUSH24
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 // 24 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x77_PUSH24(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314151617180000000000000000n]
console.log(frame.pc); // 25
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 24-byte constant
uint192 constant VALUE = 6.277101735386681e+57;
// PUSH24 0xffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 24-byte value
push24 0xffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH24: 25 bytes (1 opcode + 24 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
### 24-Byte Constants
```solidity theme={null}
assembly {
// 24-byte literal
push24 0xabababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH24 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 23: 0x18 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH24 opcode (0x77) - Push 24 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x77_PUSH24(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 24);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 25;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 24 bytes read
const bytecode = new Uint8Array([0x77, 0x01]); // Only 1 byte instead of 24
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x77_PUSH24(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x77_PUSH24(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x77, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x77_PUSH24(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x77, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x77_PUSH24(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH24](https://www.evm.codes/#77?fork=cancun)
* [Solidity Assembly - push24](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH25 (0x78)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push25
Push 25-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:** `0x78`
**Introduced:** Frontier (EVM genesis)
PUSH25 pushes a 25-byte immediate value from the bytecode onto the stack. The 25 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 25 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 25 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 25) // Big-endian
stack.push(value)
pc += 26
```
## Behavior
PUSH25 reads 25 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 25 bytes 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 26 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x78_PUSH25 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH25
const bytecode = new Uint8Array([
0x78, // PUSH25
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 // 25 bytes: 0102030405060708090a0b0c0d0e0f10111213141516171819
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x78_PUSH25(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f1011121314151617181900000000000000n]
console.log(frame.pc); // 26
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 25-byte constant
uint200 constant VALUE = 1.6069380442589903e+60;
// PUSH25 0xffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 25-byte value
push25 0xffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH25: 26 bytes (1 opcode + 25 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
### 25-Byte Constants
```solidity theme={null}
assembly {
// 25-byte literal
push25 0xababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH25 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19
// Reads as: 0x0102030405060708090a0b0c0d0e0f10111213141516171819
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 24: 0x19 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH25 opcode (0x78) - Push 25 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x78_PUSH25(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 25);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 26;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 25 bytes read
const bytecode = new Uint8Array([0x78, 0x01]); // Only 1 byte instead of 25
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x78_PUSH25(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x78_PUSH25(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x78_PUSH25(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x78_PUSH25(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffff00000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH25](https://www.evm.codes/#78?fork=cancun)
* [Solidity Assembly - push25](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH26 (0x79)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push26
Push 26-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:** `0x79`
**Introduced:** Frontier (EVM genesis)
PUSH26 pushes a 26-byte immediate value from the bytecode onto the stack. The 26 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 26 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 26 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 26) // Big-endian
stack.push(value)
pc += 27
```
## Behavior
PUSH26 reads 26 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 26 bytes 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 27 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x79_PUSH26 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH26
const bytecode = new Uint8Array([
0x79, // PUSH26
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a // 26 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x79_PUSH26(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a000000000000n]
console.log(frame.pc); // 27
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 26-byte constant
uint208 constant VALUE = 4.113761393303015e+62;
// PUSH26 0xffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 26-byte value
push26 0xffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH26: 27 bytes (1 opcode + 26 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
### 26-Byte Constants
```solidity theme={null}
assembly {
// 26-byte literal
push26 0xabababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH26 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 25: 0x1a (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH26 opcode (0x79) - Push 26 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x79_PUSH26(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 26);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 27;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 26 bytes read
const bytecode = new Uint8Array([0x79, 0x01]); // Only 1 byte instead of 26
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x79_PUSH26(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH26](https://www.evm.codes/#79?fork=cancun)
* [Solidity Assembly - push26](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH27 (0x7A)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push27
Push 27-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:** `0x7A`
**Introduced:** Frontier (EVM genesis)
PUSH27 pushes a 27-byte immediate value from the bytecode onto the stack. The 27 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 27 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 27 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 27) // Big-endian
stack.push(value)
pc += 28
```
## Behavior
PUSH27 reads 27 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 27 bytes 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 28 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7A_PUSH27 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH27
const bytecode = new Uint8Array([
0x7A, // PUSH27
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b // 27 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7A_PUSH27(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b0000000000n]
console.log(frame.pc); // 28
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 27-byte constant
uint216 constant VALUE = 1.0531229166855719e+65;
// PUSH27 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 27-byte value
push27 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH27: 28 bytes (1 opcode + 27 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
### 27-Byte Constants
```solidity theme={null}
assembly {
// 27-byte literal
push27 0xababababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH27 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 26: 0x1b (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH27 opcode (0x7A) - Push 27 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7A_PUSH27(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 27);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 28;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 27 bytes read
const bytecode = new Uint8Array([0x7A, 0x01]); // Only 1 byte instead of 27
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7A_PUSH27(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7A_PUSH27(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7A, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7A_PUSH27(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7A, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7A_PUSH27(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH27](https://www.evm.codes/#7a?fork=cancun)
* [Solidity Assembly - push27](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH28 (0x7B)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push28
Push 28-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:** `0x7B`
**Introduced:** Frontier (EVM genesis)
PUSH28 pushes a 28-byte immediate value from the bytecode onto the stack. The 28 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 28 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 28 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 28) // Big-endian
stack.push(value)
pc += 29
```
## Behavior
PUSH28 reads 28 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 28 bytes 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 29 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7B_PUSH28 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH28
const bytecode = new Uint8Array([
0x7B, // PUSH28
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c // 28 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7B_PUSH28(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c00000000n]
console.log(frame.pc); // 29
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 28-byte constant
uint224 constant VALUE = 2.695994666715064e+67;
// PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 28-byte value
push28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH28: 29 bytes (1 opcode + 28 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
### 28-Byte Constants
```solidity theme={null}
assembly {
// 28-byte literal
push28 0xabababababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH28 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 27: 0x1c (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH28 opcode (0x7B) - Push 28 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7B_PUSH28(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 28);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 29;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 28 bytes read
const bytecode = new Uint8Array([0x7B, 0x01]); // Only 1 byte instead of 28
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7B_PUSH28(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7B_PUSH28(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7B, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7B_PUSH28(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7B, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7B_PUSH28(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH28](https://www.evm.codes/#7b?fork=cancun)
* [Solidity Assembly - push28](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH29 (0x7C)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push29
Push 29-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:** `0x7C`
**Introduced:** Frontier (EVM genesis)
PUSH29 pushes a 29-byte immediate value from the bytecode onto the stack. The 29 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 29 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 29 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 29) // Big-endian
stack.push(value)
pc += 30
```
## Behavior
PUSH29 reads 29 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 29 bytes 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 30 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7C_PUSH29 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH29
const bytecode = new Uint8Array([
0x7C, // PUSH29
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d // 29 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7C_PUSH29(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d000000n]
console.log(frame.pc); // 30
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 29-byte constant
uint232 constant VALUE = 6.901746346790564e+69;
// PUSH29 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 29-byte value
push29 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH29: 30 bytes (1 opcode + 29 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
### 29-Byte Constants
```solidity theme={null}
assembly {
// 29-byte literal
push29 0xababababababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH29 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 28: 0x1d (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH29 opcode (0x7C) - Push 29 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7C_PUSH29(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 29);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 30;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 29 bytes read
const bytecode = new Uint8Array([0x7C, 0x01]); // Only 1 byte instead of 29
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7C_PUSH29(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7C_PUSH29(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7C, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7C_PUSH29(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7C, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7C_PUSH29(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH29](https://www.evm.codes/#7c?fork=cancun)
* [Solidity Assembly - push29](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH3 (0x62)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push3
Push 3-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:** `0x62`
**Introduced:** Frontier (EVM genesis)
PUSH3 pushes a 3-byte immediate value from the bytecode onto the stack. The 3 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 3 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 3 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 3) // Big-endian
stack.push(value)
pc += 4
```
## Behavior
PUSH3 reads 3 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 3 bytes 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 4 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x62_PUSH3 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH3
const bytecode = new Uint8Array([
0x62, // PUSH3
0x01, 0x02, 0x03 // 3 bytes: 010203
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x62_PUSH3(frame);
console.log(frame.stack); // [0x0102030000000000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 4
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// Function selectors use PUSH4
function transfer() public {
// PUSH4 0xa9059cbb (4-byte selector)
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 3-byte value
push3 0xffffff
// Example: 3-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH3: 4 bytes (1 opcode + 3 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
### 3-Byte Constants
```solidity theme={null}
assembly {
// 3-byte literal
push3 0xababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH3 01 02 03
// Reads as: 0x010203
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 2: 0x03 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH3 opcode (0x62) - Push 3 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x62_PUSH3(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 3);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 4;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 3 bytes read
const bytecode = new Uint8Array([0x62, 0x01]); // Only 1 byte instead of 3
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x62_PUSH3(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x62, 0x00, 0x00, 0x00])
});
const err = handler_0x62_PUSH3(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x62, 0xff, 0xff, 0xff])
});
const err = handler_0x62_PUSH3(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x62, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x62_PUSH3(frame);
console.log(frame.stack[0]); // 0xffffff0000000000000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH3](https://www.evm.codes/#62?fork=cancun)
* [Solidity Assembly - push3](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH30 (0x7D)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push30
Push 30-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:** `0x7D`
**Introduced:** Frontier (EVM genesis)
PUSH30 pushes a 30-byte immediate value from the bytecode onto the stack. The 30 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 30 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 30 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 30) // Big-endian
stack.push(value)
pc += 31
```
## Behavior
PUSH30 reads 30 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 30 bytes 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 31 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7D_PUSH30 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH30
const bytecode = new Uint8Array([
0x7D, // PUSH30
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e // 30 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7D_PUSH30(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e0000n]
console.log(frame.pc); // 31
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 30-byte constant
uint240 constant VALUE = 1.7668470647783843e+72;
// PUSH30 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 30-byte value
push30 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH30: 31 bytes (1 opcode + 30 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
### 30-Byte Constants
```solidity theme={null}
assembly {
// 30-byte literal
push30 0xabababababababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH30 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 29: 0x1e (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH30 opcode (0x7D) - Push 30 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7D_PUSH30(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 30);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 31;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 30 bytes read
const bytecode = new Uint8Array([0x7D, 0x01]); // Only 1 byte instead of 30
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7D_PUSH30(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7D_PUSH30(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7D, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7D_PUSH30(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7D, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7D_PUSH30(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH30](https://www.evm.codes/#7d?fork=cancun)
* [Solidity Assembly - push30](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH31 (0x7E)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push31
Push 31-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:** `0x7E`
**Introduced:** Frontier (EVM genesis)
PUSH31 pushes a 31-byte immediate value from the bytecode onto the stack. The 31 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 31 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 31 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 31) // Big-endian
stack.push(value)
pc += 32
```
## Behavior
PUSH31 reads 31 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 31 bytes 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 32 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7E_PUSH31 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH31
const bytecode = new Uint8Array([
0x7E, // PUSH31
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f // 31 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7E_PUSH31(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f00n]
console.log(frame.pc); // 32
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 31-byte constant
uint248 constant VALUE = 4.523128485832664e+74;
// PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 31-byte value
push31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH31: 32 bytes (1 opcode + 31 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
### 31-Byte Constants
```solidity theme={null}
assembly {
// 31-byte literal
push31 0xababababababababababababababababababababababababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH31 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 30: 0x1f (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH31 opcode (0x7E) - Push 31 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7E_PUSH31(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 31);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 32;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 31 bytes read
const bytecode = new Uint8Array([0x7E, 0x01]); // Only 1 byte instead of 31
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7E_PUSH31(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7E_PUSH31(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7E, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7E_PUSH31(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7E, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7E_PUSH31(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH31](https://www.evm.codes/#7e?fork=cancun)
* [Solidity Assembly - push31](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH32 (0x7F)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push32
Push 32-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:** `0x7F`
**Introduced:** Frontier (EVM genesis)
PUSH32 pushes a 32-byte immediate value from the bytecode onto the stack. The 32 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 32 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 32 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 32) // Big-endian
stack.push(value)
pc += 33
```
## Behavior
PUSH32 reads 32 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 32 bytes 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 33 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x7F_PUSH32 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH32
const bytecode = new Uint8Array([
0x7F, // PUSH32
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 // 32 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x7F_PUSH32(frame);
console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20n]
console.log(frame.pc); // 33
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// Large constants use PUSH32
uint256 constant MAX = type(uint256).max;
// PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 32-byte value
push32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* 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) |
\| PUSH32 | 3 | 33 | Large constants |
## Common Usage
### Maximum Values
```solidity theme={null}
contract Constants {
uint256 constant MAX_UINT256 = type(uint256).max;
// Compiled to:
// PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH32 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 31: 0x20 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH32 opcode (0x7F) - Push 32 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x7F_PUSH32(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 32);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 33;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 32 bytes read
const bytecode = new Uint8Array([0x7F, 0x01]); // Only 1 byte instead of 32
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x7F_PUSH32(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x7F_PUSH32(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x7F, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x7F_PUSH32(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x7F, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x7F_PUSH32(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH32](https://www.evm.codes/#7f?fork=cancun)
* [Solidity Assembly - push32](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH4 (0x63)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push4
Push 4-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:** `0x63`
**Introduced:** Frontier (EVM genesis)
PUSH4 pushes a 4-byte immediate value from the bytecode onto the stack. The 4 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 4 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 4 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 4) // Big-endian
stack.push(value)
pc += 5
```
## Behavior
PUSH4 reads 4 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 4 bytes 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 5 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x63_PUSH4 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH4
const bytecode = new Uint8Array([
0x63, // PUSH4
0x01, 0x02, 0x03, 0x04 // 4 bytes: 01020304
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x63_PUSH4(frame);
console.log(frame.stack); // [0x0102030400000000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 5
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// Function selectors use PUSH4
function transfer() public {
// PUSH4 0xa9059cbb (4-byte selector)
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 4-byte value
push4 0xffffffff
// Example: function selector
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH4: 5 bytes (1 opcode + 4 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) |
| PUSH4 | 3 | 5 | Function selectors |
## Common Usage
### Function Selectors
```solidity theme={null}
// Function selector is first 4 bytes of keccak256("transfer(address,uint256)")
function checkSelector() public pure {
assembly {
let selector := shr(224, calldataload(0))
push4 0xa9059cbb // transfer selector
eq // Compare
}
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH4 01 02 03 04
// Reads as: 0x01020304
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 3: 0x04 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH4 opcode (0x63) - Push 4 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x63_PUSH4(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 4);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 5;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 4 bytes read
const bytecode = new Uint8Array([0x63, 0x01]); // Only 1 byte instead of 4
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x63_PUSH4(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x63, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x63_PUSH4(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x63, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x63_PUSH4(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x63, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x63_PUSH4(frame);
console.log(frame.stack[0]); // 0xffffffff00000000000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH4](https://www.evm.codes/#63?fork=cancun)
* [Solidity Assembly - push4](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH5 (0x64)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push5
Push 5-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:** `0x64`
**Introduced:** Frontier (EVM genesis)
PUSH5 pushes a 5-byte immediate value from the bytecode onto the stack. The 5 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 5 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 5 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 5) // Big-endian
stack.push(value)
pc += 6
```
## Behavior
PUSH5 reads 5 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 5 bytes 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 6 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x64_PUSH5 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH5
const bytecode = new Uint8Array([
0x64, // PUSH5
0x01, 0x02, 0x03, 0x04, 0x05 // 5 bytes: 0102030405
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x64_PUSH5(frame);
console.log(frame.stack); // [0x0102030405000000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 6
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 5-byte constant
uint40 constant VALUE = 1099511627775;
// PUSH5 0xffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 5-byte value
push5 0xffffffffff
// Example: 5-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH5: 6 bytes (1 opcode + 5 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
### 5-Byte Constants
```solidity theme={null}
assembly {
// 5-byte literal
push5 0xababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH5 01 02 03 04 05
// Reads as: 0x0102030405
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 4: 0x05 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH5 opcode (0x64) - Push 5 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x64_PUSH5(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 5);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 6;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 5 bytes read
const bytecode = new Uint8Array([0x64, 0x01]); // Only 1 byte instead of 5
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x64_PUSH5(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x64, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x64_PUSH5(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x64, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x64_PUSH5(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x64, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x64_PUSH5(frame);
console.log(frame.stack[0]); // 0xffffffffff000000000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH5](https://www.evm.codes/#64?fork=cancun)
* [Solidity Assembly - push5](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH6 (0x65)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push6
Push 6-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:** `0x65`
**Introduced:** Frontier (EVM genesis)
PUSH6 pushes a 6-byte immediate value from the bytecode onto the stack. The 6 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 6 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 6 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 6) // Big-endian
stack.push(value)
pc += 7
```
## Behavior
PUSH6 reads 6 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 6 bytes 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 7 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x65_PUSH6 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH6
const bytecode = new Uint8Array([
0x65, // PUSH6
0x01, 0x02, 0x03, 0x04, 0x05, 0x06 // 6 bytes: 010203040506
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x65_PUSH6(frame);
console.log(frame.stack); // [0x0102030405060000000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 7
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 6-byte constant
uint48 constant VALUE = 281474976710655;
// PUSH6 0xffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 6-byte value
push6 0xffffffffffff
// Example: 6-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH6: 7 bytes (1 opcode + 6 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
### 6-Byte Constants
```solidity theme={null}
assembly {
// 6-byte literal
push6 0xabababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH6 01 02 03 04 05 06
// Reads as: 0x010203040506
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 5: 0x06 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH6 opcode (0x65) - Push 6 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x65_PUSH6(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 6);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 7;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 6 bytes read
const bytecode = new Uint8Array([0x65, 0x01]); // Only 1 byte instead of 6
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x65_PUSH6(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x65_PUSH6(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x65, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x65_PUSH6(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x65, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x65_PUSH6(frame);
console.log(frame.stack[0]); // 0xffffffffffff0000000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH6](https://www.evm.codes/#65?fork=cancun)
* [Solidity Assembly - push6](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH7 (0x66)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push7
Push 7-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:** `0x66`
**Introduced:** Frontier (EVM genesis)
PUSH7 pushes a 7-byte immediate value from the bytecode onto the stack. The 7 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 7 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 7 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 7) // Big-endian
stack.push(value)
pc += 8
```
## Behavior
PUSH7 reads 7 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 7 bytes 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 8 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x66_PUSH7 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH7
const bytecode = new Uint8Array([
0x66, // PUSH7
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 // 7 bytes: 01020304050607
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x66_PUSH7(frame);
console.log(frame.stack); // [0x0102030405060700000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 8
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 7-byte constant
uint56 constant VALUE = 72057594037927940;
// PUSH7 0xffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 7-byte value
push7 0xffffffffffffff
// Example: 7-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH7: 8 bytes (1 opcode + 7 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
### 7-Byte Constants
```solidity theme={null}
assembly {
// 7-byte literal
push7 0xababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH7 01 02 03 04 05 06 07
// Reads as: 0x01020304050607
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 6: 0x07 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH7 opcode (0x66) - Push 7 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x66_PUSH7(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 7);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 8;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 7 bytes read
const bytecode = new Uint8Array([0x66, 0x01]); // Only 1 byte instead of 7
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x66_PUSH7(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x66_PUSH7(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x66, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x66_PUSH7(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x66, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x66_PUSH7(frame);
console.log(frame.stack[0]); // 0xffffffffffffff00000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH7](https://www.evm.codes/#66?fork=cancun)
* [Solidity Assembly - push7](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH8 (0x67)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push8
Push 8-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:** `0x67`
**Introduced:** Frontier (EVM genesis)
PUSH8 pushes a 8-byte immediate value from the bytecode onto the stack. The 8 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 8 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 8 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 8) // Big-endian
stack.push(value)
pc += 9
```
## Behavior
PUSH8 reads 8 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 8 bytes 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 9 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x67_PUSH8 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH8
const bytecode = new Uint8Array([
0x67, // PUSH8
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 // 8 bytes: 0102030405060708
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x67_PUSH8(frame);
console.log(frame.stack); // [0x0102030405060708000000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 9
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 8-byte constant
uint64 constant VALUE = 18446744073709552000;
// PUSH8 0xffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 8-byte value
push8 0xffffffffffffffff
// Example: 8-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH8: 9 bytes (1 opcode + 8 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
### 8-Byte Constants
```solidity theme={null}
assembly {
// 8-byte literal
push8 0xabababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH8 01 02 03 04 05 06 07 08
// Reads as: 0x0102030405060708
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 7: 0x08 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH8 opcode (0x67) - Push 8 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x67_PUSH8(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 8);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 9;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 8 bytes read
const bytecode = new Uint8Array([0x67, 0x01]); // Only 1 byte instead of 8
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x67_PUSH8(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x67_PUSH8(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x67, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x67_PUSH8(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x67, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x67_PUSH8(frame);
console.log(frame.stack[0]); // 0xffffffffffffffff000000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH8](https://www.evm.codes/#67?fork=cancun)
* [Solidity Assembly - push8](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# PUSH9 (0x68)
Source: https://voltaire.tevm.sh/evm/instructions/stack/push9
Push 9-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:** `0x68`
**Introduced:** Frontier (EVM genesis)
PUSH9 pushes a 9-byte immediate value from the bytecode onto the stack. The 9 bytes immediately following the opcode are read and zero-padded to 256 bits.
## Specification
**Stack Input:**
```
[]
```
**Stack Output:**
```
value (uint256, 9 bytes from bytecode)
```
**Gas Cost:** 3 (GasFastestStep)
**Bytecode:** 1 byte opcode + 9 bytes immediate data
**Operation:**
```
value = read_bytes(pc + 1, 9) // Big-endian
stack.push(value)
pc += 10
```
## Behavior
PUSH9 reads 9 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.
Key characteristics:
* Reads exactly 9 bytes 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 10 (opcode + data)
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x68_PUSH9 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Bytecode with PUSH9
const bytecode = new Uint8Array([
0x68, // PUSH9
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 // 9 bytes: 010203040506070809
]);
const frame = createFrame({
bytecode,
pc: 0,
stack: [],
gasRemaining: 1000n
});
const err = handler_0x68_PUSH9(frame);
console.log(frame.stack); // [0x0102030405060708090000000000000000000000000000000000000000000000n]
console.log(frame.pc); // 10
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
// 9-byte constant
uint72 constant VALUE = 4.722366482869645e+21;
// PUSH9 0xffffffffffffffffff
}
```
### Assembly Usage
```solidity theme={null}
assembly {
// Push 9-byte value
push9 0xffffffffffffffffff
// Example: 9-byte constant
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:
* PUSH9: 10 bytes (1 opcode + 9 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
### 9-Byte Constants
```solidity theme={null}
assembly {
// 9-byte literal
push9 0xababababababababab
}
```
### Big-Endian Encoding
```typescript theme={null}
// Bytecode: PUSH9 01 02 03 04 05 06 07 08 09
// Reads as: 0x010203040506070809
// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 8: 0x09 (lowest significance)
```
## Implementation
```typescript theme={null}
/**
* 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;
}
/**
* PUSH9 opcode (0x68) - Push 9 bytes onto stack
*
* Stack: [] => [value]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x68_PUSH9(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
const value = readImmediate(frame.bytecode, frame.pc, 9);
if (value === null) {
return { type: "InvalidOpcode" };
}
const pushErr = pushStack(frame, value);
if (pushErr) return pushErr;
frame.pc += 10;
return null;
}
```
## Edge Cases
### Insufficient Bytecode
```typescript theme={null}
// Bytecode ends before 9 bytes read
const bytecode = new Uint8Array([0x68, 0x01]); // Only 1 byte instead of 9
const frame = createFrame({ bytecode, pc: 0 });
const err = handler_0x68_PUSH9(frame);
console.log(err); // { type: "InvalidOpcode" }
```
### Stack Overflow
```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
stack: new Array(1024).fill(0n),
bytecode: new Uint8Array([0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});
const err = handler_0x68_PUSH9(frame);
console.log(err); // { type: "StackOverflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
gasRemaining: 2n, // Need 3 gas
bytecode: new Uint8Array([0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});
const err = handler_0x68_PUSH9(frame);
console.log(err); // { type: "OutOfGas" }
```
### Maximum Value
```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });
handler_0x68_PUSH9(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffff0000000000000000000000000000000000000000000000n
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH9](https://www.evm.codes/#68?fork=cancun)
* [Solidity Assembly - push9](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP1 (0x90)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap1
Swap top with 2nd stack item
**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:** `0x90`
**Introduced:** Frontier (EVM genesis)
SWAP1 exchanges the top stack item with the 2nd item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, top]
```
**Stack Output:**
```
[..., top, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 2]
stack[top - 2] = temp
```
## Behavior
SWAP1 exchanges positions of the top item and the item at position 2 from top. Requires stack depth ≥ 2.
Key characteristics:
* Requires stack depth ≥ 2
* Only two items change positions
* Middle items unchanged
* StackUnderflow if depth \< 2
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x90_SWAP1 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 2nd item
const frame = createFrame({
stack: [200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x90_SWAP1(frame);
console.log(frame.stack); // [100n, 200n] - positions 0 and 1 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function simpleSwap(uint256 a, uint256 b) public pure returns (uint256, uint256) {
// Return in reverse order
return (b, a); // Compiler uses SWAP1
// Stack: [a, b] => [b, a]
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
// Stack: ['a', 'b']
swap1
// Stack: ['b', 'a'] - 'a' and 'b' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP1 | 3 | Swap with 2nd item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Argument Reordering
````solidity theme={null}
// Function expects (b, a) but has (a, b)
assembly {
// Stack: [a, b]
swap1
// Stack: [b, a]
call(...)
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP1 requires 2 items
assembly {
push1 0x01
// Only 1 items - SWAP1 will fail!
swap1 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
// Exactly 2 items - safe
swap1 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP1 opcode (0x90) - Swap top with 2nd item
*
* Stack: [..., valueN, top] => [..., top, valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x90_SWAP1(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 1) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 2;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n] // Only 1 items, need 2
});
const err = handler_0x90_SWAP1(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x90_SWAP1(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(2).fill(42n)
});
handler_0x90_SWAP1(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, MAX, 1n]
});
handler_0x90_SWAP1(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[1]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP1](https://www.evm.codes/#90?fork=cancun)
* [Solidity Assembly - swap1](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP10 (0x99)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap10
Swap top with 11th stack item
**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:** `0x99`
**Introduced:** Frontier (EVM genesis)
SWAP10 exchanges the top stack item with the 11th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item9, ..., item1, top]
```
**Stack Output:**
```
[..., top, item9, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 11]
stack[top - 11] = temp
```
## Behavior
SWAP10 exchanges positions of the top item and the item at position 11 from top. Requires stack depth ≥ 11.
Key characteristics:
* Requires stack depth ≥ 11
* Only two items change positions
* Middle items (items 1-10) unchanged
* StackUnderflow if depth \< 11
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x99_SWAP10 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 11th item
const frame = createFrame({
stack: [1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x99_SWAP10(frame);
console.log(frame.stack); // [100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1100n] - positions 0 and 10 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
swap10
// Stack: [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
swap10
// Stack: ['k', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'a'] - 'a' and 'k' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP10 | 3 | Swap with 11th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
// Need v0 at top
swap10
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP10 requires 11 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Only 10 items - SWAP10 will fail!
swap10 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Exactly 11 items - safe
swap10 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP10 opcode (0x99) - Swap top with 11th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x99_SWAP10(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 10) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 11;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 10 items, need 11
});
const err = handler_0x99_SWAP10(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x99_SWAP10(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(11).fill(42n)
});
handler_0x99_SWAP10(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x99_SWAP10(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[10]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP10](https://www.evm.codes/#99?fork=cancun)
* [Solidity Assembly - swap10](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP11 (0x9A)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap11
Swap top with 12th stack item
**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:** `0x9A`
**Introduced:** Frontier (EVM genesis)
SWAP11 exchanges the top stack item with the 12th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item10, ..., item1, top]
```
**Stack Output:**
```
[..., top, item10, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 12]
stack[top - 12] = temp
```
## Behavior
SWAP11 exchanges positions of the top item and the item at position 12 from top. Requires stack depth ≥ 12.
Key characteristics:
* Requires stack depth ≥ 12
* Only two items change positions
* Middle items (items 1-11) unchanged
* StackUnderflow if depth \< 12
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9A_SWAP11 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 12th item
const frame = createFrame({
stack: [1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9A_SWAP11(frame);
console.log(frame.stack); // [100n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1200n] - positions 0 and 11 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
swap11
// Stack: [12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
swap11
// Stack: ['l', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'a'] - 'a' and 'l' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP11 | 3 | Swap with 12th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
// Need v0 at top
swap11
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP11 requires 12 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
// Only 11 items - SWAP11 will fail!
swap11 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Exactly 12 items - safe
swap11 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP11 opcode (0x9A) - Swap top with 12th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9A_SWAP11(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 11) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 12;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 11 items, need 12
});
const err = handler_0x9A_SWAP11(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9A_SWAP11(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(12).fill(42n)
});
handler_0x9A_SWAP11(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9A_SWAP11(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[11]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP11](https://www.evm.codes/#9a?fork=cancun)
* [Solidity Assembly - swap11](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP12 (0x9B)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap12
Swap top with 13th stack item
**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:** `0x9B`
**Introduced:** Frontier (EVM genesis)
SWAP12 exchanges the top stack item with the 13th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item11, ..., item1, top]
```
**Stack Output:**
```
[..., top, item11, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 13]
stack[top - 13] = temp
```
## Behavior
SWAP12 exchanges positions of the top item and the item at position 13 from top. Requires stack depth ≥ 13.
Key characteristics:
* Requires stack depth ≥ 13
* Only two items change positions
* Middle items (items 1-12) unchanged
* StackUnderflow if depth \< 13
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9B_SWAP12 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 13th item
const frame = createFrame({
stack: [1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9B_SWAP12(frame);
console.log(frame.stack); // [100n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1300n] - positions 0 and 12 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
swap12
// Stack: [13, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
push1 0xm
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm']
swap12
// Stack: ['m', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'a'] - 'a' and 'm' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP12 | 3 | Swap with 13th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
// Need v0 at top
swap12
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP12 requires 13 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
// Only 12 items - SWAP12 will fail!
swap12 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Exactly 13 items - safe
swap12 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP12 opcode (0x9B) - Swap top with 13th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9B_SWAP12(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 12) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 13;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 12 items, need 13
});
const err = handler_0x9B_SWAP12(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9B_SWAP12(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(13).fill(42n)
});
handler_0x9B_SWAP12(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9B_SWAP12(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[12]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP12](https://www.evm.codes/#9b?fork=cancun)
* [Solidity Assembly - swap12](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP13 (0x9C)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap13
Swap top with 14th stack item
**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:** `0x9C`
**Introduced:** Frontier (EVM genesis)
SWAP13 exchanges the top stack item with the 14th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item12, ..., item1, top]
```
**Stack Output:**
```
[..., top, item12, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 14]
stack[top - 14] = temp
```
## Behavior
SWAP13 exchanges positions of the top item and the item at position 14 from top. Requires stack depth ≥ 14.
Key characteristics:
* Requires stack depth ≥ 14
* Only two items change positions
* Middle items (items 1-13) unchanged
* StackUnderflow if depth \< 14
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9C_SWAP13 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 14th item
const frame = createFrame({
stack: [1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9C_SWAP13(frame);
console.log(frame.stack); // [100n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1400n] - positions 0 and 13 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
swap13
// Stack: [14, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
push1 0xm
push1 0xn
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n']
swap13
// Stack: ['n', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'a'] - 'a' and 'n' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP13 | 3 | Swap with 14th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
// Need v0 at top
swap13
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP13 requires 14 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
// Only 13 items - SWAP13 will fail!
swap13 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Exactly 14 items - safe
swap13 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP13 opcode (0x9C) - Swap top with 14th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9C_SWAP13(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 13) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 14;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 13 items, need 14
});
const err = handler_0x9C_SWAP13(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9C_SWAP13(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(14).fill(42n)
});
handler_0x9C_SWAP13(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9C_SWAP13(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[13]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP13](https://www.evm.codes/#9c?fork=cancun)
* [Solidity Assembly - swap13](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP14 (0x9D)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap14
Swap top with 15th stack item
**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:** `0x9D`
**Introduced:** Frontier (EVM genesis)
SWAP14 exchanges the top stack item with the 15th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item13, ..., item1, top]
```
**Stack Output:**
```
[..., top, item13, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 15]
stack[top - 15] = temp
```
## Behavior
SWAP14 exchanges positions of the top item and the item at position 15 from top. Requires stack depth ≥ 15.
Key characteristics:
* Requires stack depth ≥ 15
* Only two items change positions
* Middle items (items 1-14) unchanged
* StackUnderflow if depth \< 15
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9D_SWAP14 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 15th item
const frame = createFrame({
stack: [1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9D_SWAP14(frame);
console.log(frame.stack); // [100n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1500n] - positions 0 and 14 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
swap14
// Stack: [15, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
push1 0xm
push1 0xn
push1 0xo
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o']
swap14
// Stack: ['o', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'a'] - 'a' and 'o' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP14 | 3 | Swap with 15th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
// Need v0 at top
swap14
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP14 requires 15 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
// Only 14 items - SWAP14 will fail!
swap14 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Exactly 15 items - safe
swap14 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP14 opcode (0x9D) - Swap top with 15th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9D_SWAP14(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 14) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 15;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 14 items, need 15
});
const err = handler_0x9D_SWAP14(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9D_SWAP14(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(15).fill(42n)
});
handler_0x9D_SWAP14(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9D_SWAP14(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[14]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP14](https://www.evm.codes/#9d?fork=cancun)
* [Solidity Assembly - swap14](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP15 (0x9E)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap15
Swap top with 16th stack item
**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:** `0x9E`
**Introduced:** Frontier (EVM genesis)
SWAP15 exchanges the top stack item with the 16th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item14, ..., item1, top]
```
**Stack Output:**
```
[..., top, item14, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 16]
stack[top - 16] = temp
```
## Behavior
SWAP15 exchanges positions of the top item and the item at position 16 from top. Requires stack depth ≥ 16.
Key characteristics:
* Requires stack depth ≥ 16
* Only two items change positions
* Middle items (items 1-15) unchanged
* StackUnderflow if depth \< 16
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9E_SWAP15 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 16th item
const frame = createFrame({
stack: [1600n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9E_SWAP15(frame);
console.log(frame.stack); // [100n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1600n] - positions 0 and 15 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
swap15
// Stack: [16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
push1 0xm
push1 0xn
push1 0xo
push1 0xp
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
swap15
// Stack: ['p', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'a'] - 'a' and 'p' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP15 | 3 | Swap with 16th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
let v15 := 15
// Need v0 at top
swap15
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP15 requires 16 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
// Only 15 items - SWAP15 will fail!
swap15 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
// Exactly 16 items - safe
swap15 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP15 opcode (0x9E) - Swap top with 16th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9E_SWAP15(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 15) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 16;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 15 items, need 16
});
const err = handler_0x9E_SWAP15(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9E_SWAP15(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(16).fill(42n)
});
handler_0x9E_SWAP15(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9E_SWAP15(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[15]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP15](https://www.evm.codes/#9e?fork=cancun)
* [Solidity Assembly - swap15](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP16 (0x9F)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap16
Swap top with 17th stack item
**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:** `0x9F`
**Introduced:** Frontier (EVM genesis)
SWAP16 exchanges the top stack item with the 17th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item15, ..., item1, top]
```
**Stack Output:**
```
[..., top, item15, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 17]
stack[top - 17] = temp
```
## Behavior
SWAP16 exchanges positions of the top item and the item at position 17 from top. Requires stack depth ≥ 17.
Key characteristics:
* Requires stack depth ≥ 17
* Only two items change positions
* Middle items (items 1-16) unchanged
* StackUnderflow if depth \< 17
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x9F_SWAP16 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 17th item
const frame = createFrame({
stack: [1700n, 1600n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x9F_SWAP16(frame);
console.log(frame.stack); // [100n, 1600n, 1500n, 1400n, 1300n, 1200n, 1100n, 1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1700n] - positions 0 and 16 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
push1 0x11
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
swap16
// Stack: [17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
push1 0xk
push1 0xl
push1 0xm
push1 0xn
push1 0xo
push1 0xp
push1 0xq
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q']
swap16
// Stack: ['q', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'a'] - 'a' and 'q' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP16 | 3 | Swap with 17th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
let v10 := 10
let v11 := 11
let v12 := 12
let v13 := 13
let v14 := 14
let v15 := 15
let v16 := 16
// Need v0 at top
swap16
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP16 requires 17 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
// Only 16 items - SWAP16 will fail!
swap16 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
push1 0x0b
push1 0x0c
push1 0x0d
push1 0x0e
push1 0x0f
push1 0x10
push1 0x11
// Exactly 17 items - safe
swap16 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP16 opcode (0x9F) - Swap top with 17th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x9F_SWAP16(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 16) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 17;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 16 items, need 17
});
const err = handler_0x9F_SWAP16(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x9F_SWAP16(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(17).fill(42n)
});
handler_0x9F_SWAP16(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x9F_SWAP16(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[16]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP16](https://www.evm.codes/#9f?fork=cancun)
* [Solidity Assembly - swap16](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP2 (0x91)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap2
Swap top with 3rd stack item
**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:** `0x91`
**Introduced:** Frontier (EVM genesis)
SWAP2 exchanges the top stack item with the 3rd item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item1, ..., item1, top]
```
**Stack Output:**
```
[..., top, item1, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 3]
stack[top - 3] = temp
```
## Behavior
SWAP2 exchanges positions of the top item and the item at position 3 from top. Requires stack depth ≥ 3.
Key characteristics:
* Requires stack depth ≥ 3
* Only two items change positions
* Middle items (items 1-2) unchanged
* StackUnderflow if depth \< 3
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x91_SWAP2 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 3rd item
const frame = createFrame({
stack: [300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x91_SWAP2(frame);
console.log(frame.stack); // [100n, 200n, 300n] - positions 0 and 2 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function reorder() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
// Stack: [1, 2, 3]
swap2
// Stack: [3, 2, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
// Stack: ['a', 'b', 'c']
swap2
// Stack: ['c', 'b', 'a'] - 'a' and 'c' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP2 | 3 | Swap with 3rd item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Triple Reordering
````solidity theme={null}
assembly {
let a := 1
let b := 2
let c := 3
// Stack: [a, b, c]
swap2
// Stack: [c, b, a]
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP2 requires 3 items
assembly {
push1 0x01
push1 0x02
// Only 2 items - SWAP2 will fail!
swap2 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
// Exactly 3 items - safe
swap2 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP2 opcode (0x91) - Swap top with 3rd item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x91_SWAP2(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 2) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 3;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n] // Only 2 items, need 3
});
const err = handler_0x91_SWAP2(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x91_SWAP2(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(3).fill(42n)
});
handler_0x91_SWAP2(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, MAX, 1n]
});
handler_0x91_SWAP2(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[2]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP2](https://www.evm.codes/#91?fork=cancun)
* [Solidity Assembly - swap2](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP3 (0x92)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap3
Swap top with 4th stack item
**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:** `0x92`
**Introduced:** Frontier (EVM genesis)
SWAP3 exchanges the top stack item with the 4th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item2, ..., item1, top]
```
**Stack Output:**
```
[..., top, item2, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 4]
stack[top - 4] = temp
```
## Behavior
SWAP3 exchanges positions of the top item and the item at position 4 from top. Requires stack depth ≥ 4.
Key characteristics:
* Requires stack depth ≥ 4
* Only two items change positions
* Middle items (items 1-3) unchanged
* StackUnderflow if depth \< 4
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x92_SWAP3 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 4th item
const frame = createFrame({
stack: [400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x92_SWAP3(frame);
console.log(frame.stack); // [100n, 300n, 200n, 400n] - positions 0 and 3 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Stack: [1, 2, 3, 4]
swap3
// Stack: [4, 2, 3, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
// Stack: ['a', 'b', 'c', 'd']
swap3
// Stack: ['d', 'b', 'c', 'a'] - 'a' and 'd' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP3 | 3 | Swap with 4th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
// Need v0 at top
swap3
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP3 requires 4 items
assembly {
push1 0x01
push1 0x02
push1 0x03
// Only 3 items - SWAP3 will fail!
swap3 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Exactly 4 items - safe
swap3 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP3 opcode (0x92) - Swap top with 4th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x92_SWAP3(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 3) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 4;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n] // Only 3 items, need 4
});
const err = handler_0x92_SWAP3(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x92_SWAP3(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(4).fill(42n)
});
handler_0x92_SWAP3(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, MAX, 1n]
});
handler_0x92_SWAP3(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[3]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP3](https://www.evm.codes/#92?fork=cancun)
* [Solidity Assembly - swap3](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP4 (0x93)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap4
Swap top with 5th stack item
**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:** `0x93`
**Introduced:** Frontier (EVM genesis)
SWAP4 exchanges the top stack item with the 5th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item3, ..., item1, top]
```
**Stack Output:**
```
[..., top, item3, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 5]
stack[top - 5] = temp
```
## Behavior
SWAP4 exchanges positions of the top item and the item at position 5 from top. Requires stack depth ≥ 5.
Key characteristics:
* Requires stack depth ≥ 5
* Only two items change positions
* Middle items (items 1-4) unchanged
* StackUnderflow if depth \< 5
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x93_SWAP4 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 5th item
const frame = createFrame({
stack: [500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x93_SWAP4(frame);
console.log(frame.stack); // [100n, 400n, 300n, 200n, 500n] - positions 0 and 4 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Stack: [1, 2, 3, 4, 5]
swap4
// Stack: [5, 2, 3, 4, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
// Stack: ['a', 'b', 'c', 'd', 'e']
swap4
// Stack: ['e', 'b', 'c', 'd', 'a'] - 'a' and 'e' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP4 | 3 | Swap with 5th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
// Need v0 at top
swap4
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP4 requires 5 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
// Only 4 items - SWAP4 will fail!
swap4 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Exactly 5 items - safe
swap4 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP4 opcode (0x93) - Swap top with 5th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x93_SWAP4(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 4) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 5;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n] // Only 4 items, need 5
});
const err = handler_0x93_SWAP4(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x93_SWAP4(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(5).fill(42n)
});
handler_0x93_SWAP4(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x93_SWAP4(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[4]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP4](https://www.evm.codes/#93?fork=cancun)
* [Solidity Assembly - swap4](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP5 (0x94)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap5
Swap top with 6th stack item
**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:** `0x94`
**Introduced:** Frontier (EVM genesis)
SWAP5 exchanges the top stack item with the 6th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item4, ..., item1, top]
```
**Stack Output:**
```
[..., top, item4, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 6]
stack[top - 6] = temp
```
## Behavior
SWAP5 exchanges positions of the top item and the item at position 6 from top. Requires stack depth ≥ 6.
Key characteristics:
* Requires stack depth ≥ 6
* Only two items change positions
* Middle items (items 1-5) unchanged
* StackUnderflow if depth \< 6
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x94_SWAP5 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 6th item
const frame = createFrame({
stack: [600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x94_SWAP5(frame);
console.log(frame.stack); // [100n, 500n, 400n, 300n, 200n, 600n] - positions 0 and 5 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Stack: [1, 2, 3, 4, 5, 6]
swap5
// Stack: [6, 2, 3, 4, 5, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
// Stack: ['a', 'b', 'c', 'd', 'e', 'f']
swap5
// Stack: ['f', 'b', 'c', 'd', 'e', 'a'] - 'a' and 'f' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP5 | 3 | Swap with 6th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
// Need v0 at top
swap5
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP5 requires 6 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
// Only 5 items - SWAP5 will fail!
swap5 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Exactly 6 items - safe
swap5 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP5 opcode (0x94) - Swap top with 6th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x94_SWAP5(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 5) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 6;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n] // Only 5 items, need 6
});
const err = handler_0x94_SWAP5(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x94_SWAP5(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(6).fill(42n)
});
handler_0x94_SWAP5(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x94_SWAP5(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[5]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP5](https://www.evm.codes/#94?fork=cancun)
* [Solidity Assembly - swap5](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP6 (0x95)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap6
Swap top with 7th stack item
**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:** `0x95`
**Introduced:** Frontier (EVM genesis)
SWAP6 exchanges the top stack item with the 7th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item5, ..., item1, top]
```
**Stack Output:**
```
[..., top, item5, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 7]
stack[top - 7] = temp
```
## Behavior
SWAP6 exchanges positions of the top item and the item at position 7 from top. Requires stack depth ≥ 7.
Key characteristics:
* Requires stack depth ≥ 7
* Only two items change positions
* Middle items (items 1-6) unchanged
* StackUnderflow if depth \< 7
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x95_SWAP6 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 7th item
const frame = createFrame({
stack: [700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x95_SWAP6(frame);
console.log(frame.stack); // [100n, 600n, 500n, 400n, 300n, 200n, 700n] - positions 0 and 6 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Stack: [1, 2, 3, 4, 5, 6, 7]
swap6
// Stack: [7, 2, 3, 4, 5, 6, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g']
swap6
// Stack: ['g', 'b', 'c', 'd', 'e', 'f', 'a'] - 'a' and 'g' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP6 | 3 | Swap with 7th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
// Need v0 at top
swap6
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP6 requires 7 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
// Only 6 items - SWAP6 will fail!
swap6 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Exactly 7 items - safe
swap6 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP6 opcode (0x95) - Swap top with 7th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x95_SWAP6(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 6) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 7;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n] // Only 6 items, need 7
});
const err = handler_0x95_SWAP6(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x95_SWAP6(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(7).fill(42n)
});
handler_0x95_SWAP6(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x95_SWAP6(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[6]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP6](https://www.evm.codes/#95?fork=cancun)
* [Solidity Assembly - swap6](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP7 (0x96)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap7
Swap top with 8th stack item
**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:** `0x96`
**Introduced:** Frontier (EVM genesis)
SWAP7 exchanges the top stack item with the 8th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item6, ..., item1, top]
```
**Stack Output:**
```
[..., top, item6, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 8]
stack[top - 8] = temp
```
## Behavior
SWAP7 exchanges positions of the top item and the item at position 8 from top. Requires stack depth ≥ 8.
Key characteristics:
* Requires stack depth ≥ 8
* Only two items change positions
* Middle items (items 1-7) unchanged
* StackUnderflow if depth \< 8
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x96_SWAP7 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 8th item
const frame = createFrame({
stack: [800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x96_SWAP7(frame);
console.log(frame.stack); // [100n, 700n, 600n, 500n, 400n, 300n, 200n, 800n] - positions 0 and 7 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Stack: [1, 2, 3, 4, 5, 6, 7, 8]
swap7
// Stack: [8, 2, 3, 4, 5, 6, 7, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
swap7
// Stack: ['h', 'b', 'c', 'd', 'e', 'f', 'g', 'a'] - 'a' and 'h' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP7 | 3 | Swap with 8th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
// Need v0 at top
swap7
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP7 requires 8 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
// Only 7 items - SWAP7 will fail!
swap7 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Exactly 8 items - safe
swap7 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP7 opcode (0x96) - Swap top with 8th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x96_SWAP7(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 7) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 8;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 7 items, need 8
});
const err = handler_0x96_SWAP7(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x96_SWAP7(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(8).fill(42n)
});
handler_0x96_SWAP7(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x96_SWAP7(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[7]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP7](https://www.evm.codes/#96?fork=cancun)
* [Solidity Assembly - swap7](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP8 (0x97)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap8
Swap top with 9th stack item
**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:** `0x97`
**Introduced:** Frontier (EVM genesis)
SWAP8 exchanges the top stack item with the 9th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item7, ..., item1, top]
```
**Stack Output:**
```
[..., top, item7, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 9]
stack[top - 9] = temp
```
## Behavior
SWAP8 exchanges positions of the top item and the item at position 9 from top. Requires stack depth ≥ 9.
Key characteristics:
* Requires stack depth ≥ 9
* Only two items change positions
* Middle items (items 1-8) unchanged
* StackUnderflow if depth \< 9
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x97_SWAP8 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 9th item
const frame = createFrame({
stack: [900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x97_SWAP8(frame);
console.log(frame.stack); // [100n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 900n] - positions 0 and 8 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9]
swap8
// Stack: [9, 2, 3, 4, 5, 6, 7, 8, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
swap8
// Stack: ['i', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'a'] - 'a' and 'i' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------ |
| SWAP8 | 3 | Swap with 9th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
// Need v0 at top
swap8
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP8 requires 9 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
// Only 8 items - SWAP8 will fail!
swap8 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Exactly 9 items - safe
swap8 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP8 opcode (0x97) - Swap top with 9th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x97_SWAP8(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 8) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 9;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 8 items, need 9
});
const err = handler_0x97_SWAP8(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x97_SWAP8(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(9).fill(42n)
});
handler_0x97_SWAP8(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x97_SWAP8(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[8]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP8](https://www.evm.codes/#97?fork=cancun)
* [Solidity Assembly - swap8](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# SWAP9 (0x98)
Source: https://voltaire.tevm.sh/evm/instructions/stack/swap9
Swap top with 10th stack item
**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:** `0x98`
**Introduced:** Frontier (EVM genesis)
SWAP9 exchanges the top stack item with the 10th item from the top. Only these two positions change - all other items remain in place.
## Specification
**Stack Input:**
```
[..., valueN, item8, ..., item1, top]
```
**Stack Output:**
```
[..., top, item8, ..., item1, valueN]
```
**Gas Cost:** 3 (GasFastestStep)
**Operation:**
```
temp = stack[top]
stack[top] = stack[top - 10]
stack[top - 10] = temp
```
## Behavior
SWAP9 exchanges positions of the top item and the item at position 10 from top. Requires stack depth ≥ 10.
Key characteristics:
* Requires stack depth ≥ 10
* Only two items change positions
* Middle items (items 1-9) unchanged
* StackUnderflow if depth \< 10
* Stack depth unchanged
## Examples
### Basic Usage
```typescript theme={null}
import { handler_0x98_SWAP9 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';
// Swap top with 10th item
const frame = createFrame({
stack: [1000n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
gasRemaining: 1000n
});
const err = handler_0x98_SWAP9(frame);
console.log(frame.stack); // [100n, 900n, 800n, 700n, 600n, 500n, 400n, 300n, 200n, 1000n] - positions 0 and 9 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```
### Solidity Compilation
```solidity theme={null}
contract Example {
function deepSwap() public pure {
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Stack: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
swap9
// Stack: [10, 2, 3, 4, 5, 6, 7, 8, 9, 1]
}
}
}
```
### Assembly Usage
```solidity theme={null}
assembly {
push1 0xa
push1 0xb
push1 0xc
push1 0xd
push1 0xe
push1 0xf
push1 0xg
push1 0xh
push1 0xi
push1 0xj
// Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
swap9
// Stack: ['j', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'a'] - 'a' and 'j' swapped
}
```
## Gas Cost
**Cost:** 3 gas (GasFastestStep)
All SWAP1-16 operations cost the same despite different stack depths accessed.
**Comparison:**
| Operation | Gas | Note |
| --------- | --- | ------------------- |
| SWAP9 | 3 | Swap with 10th item |
| DUP1-16 | 3 | Same cost tier |
| POP | 2 | Cheaper |
## Common Usage
### Deep Stack Manipulation
````solidity theme={null}
function complex() public pure {
assembly {
let v0 := 0
let v1 := 1
let v2 := 2
let v3 := 3
let v4 := 4
let v5 := 5
let v6 := 6
let v7 := 7
let v8 := 8
let v9 := 9
// Need v0 at top
swap9
// v0 now at top
}
}```
### Efficient Reordering
```solidity
// Reorder for function call
assembly {
// Have: [value, to, token]
// Need: [token, to, value]
swap2 // [token, to, value]
// Call transfer(token, to, value)
call(gas(), target, 0, 0, 100, 0, 0)
}
````
### Storage Optimization
```solidity theme={null}
assembly {
let slot := 0
let value := 42
// Stack: [slot, value]
// SSTORE needs (slot, value) but we have them reversed
// No swap needed in this case, but if we did:
swap1
// Stack: [value, slot]
sstore
}
```
## Stack Depth Requirements
### Minimum Depth
```solidity theme={null}
// SWAP9 requires 10 items
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
// Only 9 items - SWAP9 will fail!
swap9 // StackUnderflow
}
```
### Safe Usage
```solidity theme={null}
assembly {
push1 0x01
push1 0x02
push1 0x03
push1 0x04
push1 0x05
push1 0x06
push1 0x07
push1 0x08
push1 0x09
push1 0x0a
// Exactly 10 items - safe
swap9 // Success
}
```
## Implementation
```typescript theme={null}
/**
* SWAP9 opcode (0x98) - Swap top with 10th item
*
* Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
* Gas: 3 (GasFastestStep)
*/
export function handler_0x98_SWAP9(frame: FrameType): EvmError | null {
const gasErr = consumeGas(frame, FastestStep);
if (gasErr) return gasErr;
if (frame.stack.length <= 9) {
return { type: "StackUnderflow" };
}
const topIdx = frame.stack.length - 1;
const swapIdx = frame.stack.length - 10;
const temp = frame.stack[topIdx];
frame.stack[topIdx] = frame.stack[swapIdx];
frame.stack[swapIdx] = temp;
frame.pc += 1;
return null;
}
```
## Edge Cases
### Stack Underflow
```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n] // Only 9 items, need 10
});
const err = handler_0x98_SWAP9(frame);
console.log(err); // { type: "StackUnderflow" }
```
### Out of Gas
```typescript theme={null}
// Insufficient gas
const frame = createFrame({
stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
gasRemaining: 2n // Need 3
});
const err = handler_0x98_SWAP9(frame);
console.log(err); // { type: "OutOfGas" }
```
### Identity Swap
```typescript theme={null}
// Swap same values
const frame = createFrame({
stack: new Array(10).fill(42n)
});
handler_0x98_SWAP9(frame);
console.log(frame.stack); // All still 42n
```
### Maximum Values
```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});
handler_0x98_SWAP9(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[9]); // MAX (was at bottom)
```
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP9](https://www.evm.codes/#98?fork=cancun)
* [Solidity Assembly - swap9](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)
# Storage Instructions
Source: https://voltaire.tevm.sh/evm/instructions/storage/index
EVM storage and transient storage operations (SLOAD, SSTORE, TLOAD, TSTORE)
**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
Storage instructions provide persistent and transient data access for smart contracts. The EVM supports two distinct storage scopes:
**Persistent Storage (SLOAD/SSTORE)**
* Contract state maintained across transactions
* Account-specific storage per contract instance
* Complex gas metering with refunds (EIP-2200, EIP-2929, EIP-3529)
* Cold/warm access tracking for gas optimization
**Transient Storage (TLOAD/TSTORE)**
* Transaction-scoped temporary storage (Cancun, EIP-1153)
* Cleared at end of transaction, not persisted
* Fixed 100 gas cost (no refunds, no access tracking)
* Common for reentrancy guards and local state
## Instructions
| Opcode | Mnemonic | Name | Gas | Hardfork | Purpose |
| ------ | -------- | --------------- | ---------- | -------- | ----------------------- |
| 0x54 | SLOAD | Storage Load | 100/2100 | Frontier | Load persistent storage |
| 0x55 | SSTORE | Storage Store | 5000-20000 | Frontier | Save persistent storage |
| 0x5c | TLOAD | Transient Load | 100 | Cancun | Load transient storage |
| 0x5d | TSTORE | Transient Store | 100 | Cancun | Save transient storage |
## Storage Model
### Persistent Storage
Each contract account has a key-value store mapping 256-bit keys to 256-bit values:
```
contract MyContract {
uint256 public count; // Storage slot 0
mapping(address => uint) balances; // Slot 1+ (hash-based)
}
```
Storage changes are:
* Committed to blockchain state
* Persisted across transactions and blocks
* Accessible to all transactions and external callers
* Refundable when clearing slots (EIP-3529)
### Transient Storage
Similar structure but transaction-scoped and cleared automatically:
```javascript theme={null}
// During transaction execution
TSTORE(key, value) // Write to transient storage
TLOAD(key) // Read from transient storage
// Transaction ends
// Transient storage cleared (not persisted)
```
Use cases:
* Reentrancy protection (guard flags)
* Call context passing (inter-contract communication)
* Temporary work variables
* Avoiding expensive storage refunds
## Gas Costs
### SLOAD (Persistent Read)
| Condition | Cost | EIP |
| ----------- | -------- | -------- |
| Warm access | 100 gas | EIP-2929 |
| Cold access | 2100 gas | EIP-2929 |
Cold/warm tracking per transaction. First access to a slot: cold (2100). Subsequent accesses: warm (100).
### SSTORE (Persistent Write)
Complex metering based on current/original values and access history:
| Case | Cost | Refund | Notes |
| --------------------- | ----- | --------------- | ------------------------------- |
| Sentry check fail | None | 0 | Requires >= 2300 gas remaining |
| Zero to non-zero | 20000 | 0 | Setting new value |
| Non-zero to different | 5000 | 0 | Modifying existing |
| Any to zero | 5000 | 4800 (EIP-3529) | Clearing slot |
| Reset to original | 5000 | 4800 | Restoring pre-transaction value |
**EIP-2200 Rules (Istanbul+):**
* Sentry: SSTORE requires >= 2300 gas remaining
* Gas varies by current vs original value
* Refunds only 4800 per cleared slot (EIP-3529 reduced from 15000)
### TLOAD/TSTORE (Transient)
Fixed 100 gas each, no gas refunds, no access tracking.
## Common Patterns
### Persistent Storage Patterns
**State management:**
```solidity theme={null}
// Simple counter
uint256 public count;
function increment() external {
count++; // SLOAD, ADD, SSTORE
}
```
**Access list optimization:**
```javascript theme={null}
// Multiple reads from same slot - use local var
function expensive() external {
uint256 value = state[key]; // Cold SLOAD (2100)
for (let i = 0; i < 10; i++) {
// ... use value ...
// Next reads are warm (100) if cached
}
}
```
### Transient Storage Patterns
**Reentrancy guard:**
```solidity theme={null}
contract ReentrancyGuard {
// Check pattern using transient storage
function _nonReentrant() internal {
uint256 locked = 1;
assembly {
// tstore(key, locked)
// Before call: check tload(key) == 0
// After call: tstore(key, 0)
}
}
}
```
**Call context:**
```javascript theme={null}
// Pass data between contract calls without storage
TSTORE(contextKey, contextValue) // Store in caller
CALL(...) // Callee can TLOAD(contextKey)
// Context available only during transaction
```
## See Also
* [SLOAD (0x54)](/evm/instructions/storage/sload) - Persistent storage read
* [SSTORE (0x55)](/evm/instructions/storage/sstore) - Persistent storage write
* [TLOAD (0x5c)](/evm/instructions/storage/tload) - Transient storage read
* [TSTORE (0x5d)](/evm/instructions/storage/tstore) - Transient storage write
* [EIP-2929: Gas-cost increases for state access opcodes](https://eips.ethereum.org/EIPS/eip-2929)
* [EIP-2200: Structured Definitions for Net Gas Metering](https://eips.ethereum.org/EIPS/eip-2200)
* [EIP-3529: Reduction in refunds](https://eips.ethereum.org/EIPS/eip-3529)
* [EIP-1153: Transient storage opcodes](https://eips.ethereum.org/EIPS/eip-1153)
# SLOAD (0x54)
Source: https://voltaire.tevm.sh/evm/instructions/storage/sload
Load word from persistent storage with cold/warm access tracking (EIP-2929)
**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:** `0x54`
**Introduced:** Frontier (EVM genesis)
**Updated:** Berlin (EIP-2929, cold/warm tracking)
SLOAD reads a 256-bit value from an account's persistent storage. The gas cost depends on whether the storage slot was previously accessed in the transaction (warm) or not (cold).
This operation is essential for reading contract state: balances, permissions, prices, and any data that must persist across transactions.
## Specification
**Stack Input:**
```
key (storage slot address)
```
**Stack Output:**
```
value (256-bit value at slot, or 0 if uninitialized)
```
**Gas Cost:**
* **100 gas** - Warm access (already accessed in transaction)
* **2100 gas** - Cold access (first access, EIP-2929)
**Operation:**
```
slot = pop()
value = storage[msg.sender][slot] // 0 if slot never written
push(value)
```
## Behavior
SLOAD retrieves the current value stored at a key in the calling contract's account storage:
1. **Pop key** from stack (256-bit unsigned integer)
2. **Query host** for storage value at contract address + key
3. **Return value** from host (0 if slot never written or cleared)
4. **Push result** to stack
5. **Track access** for cold/warm metering (EIP-2929)
6. **Increment PC**
### Cold vs Warm Access
**First access in transaction (cold):** 2100 gas
```javascript theme={null}
SLOAD(key) // 2100 gas - cold access, not yet seen
```
**Subsequent accesses (warm):** 100 gas
```javascript theme={null}
SLOAD(key) // 2100 gas first time
SLOAD(key) // 100 gas second time (warm)
```
**Access list (EIP-2930):** Can pre-warm slots
```javascript theme={null}
// Access list declaration in transaction
[{ address: contract, storageKeys: [key] }]
// SLOAD uses warm cost even on first access
```
### Uninitialized Slots
Slots never written return 0:
```javascript theme={null}
SLOAD(0xFFFFFFFF) // Returns 0 (never written)
```
## Examples
### Basic Storage Read
```typescript theme={null}
import { sload } from '@voltaire/evm/storage';
import { createFrame } from '@voltaire/evm/Frame';
import { createMemoryHost } from '@voltaire/evm/Host';
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n], // Key to read
gasRemaining: 3000n,
address: contractAddr,
});
// Pre-populate storage
host.setStorage(contractAddr, 0x42n, 0x1337n);
// Execute SLOAD
const error = sload(frame, host);
console.log(frame.stack); // [0x1337n]
console.log(frame.gasRemaining); // 2900n (3000 - 100 warm)
console.log(error); // null
```
### Cold Access Tracking
```typescript theme={null}
const host = createMemoryHost();
host.setStorage(contractAddr, 0x42n, 0x1337n);
host.setStorage(contractAddr, 0x43n, 0x2222n);
// First access to slot 0x42 (cold)
let frame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
console.log(frame.gasRemaining); // 900n (3000 - 2100 cold)
// Second access to slot 0x42 (warm, cached)
frame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
console.log(frame.gasRemaining); // 2900n (3000 - 100 warm)
// First access to slot 0x43 (cold, different slot)
frame = createFrame({
stack: [0x43n],
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
console.log(frame.gasRemaining); // 900n (3000 - 2100 cold)
```
### Mapping Access
```solidity theme={null}
// Smart contract mapping
mapping(address => uint256) public balances;
// Reading mapping[addr]
// Solidity computes: keccak256(abi.encode(addr, 1)) → storage slot
// Then SLOAD retrieves value at that slot
function getBalance(address user) public view returns (uint256) {
return balances[user]; // SLOAD with computed key
}
```
### Nested Structures
```typescript theme={null}
// Reading from dynamic storage arrays
// array[index] → SLOAD with computed offset
// Requires: baseSlot + (32 * index) for 32-byte elements
const baseSlot = 5n; // Array stored at slot 5
const index = 10n;
const storageKey = baseSlot + (32n * index); // Compute slot
frame = createFrame({
stack: [storageKey],
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
```
## Gas Cost
**Cost Matrix:**
| Access Type | Gas | EIP | Notes |
| ----------- | ---- | -------- | --------------------------- |
| Warm | 100 | EIP-2929 | Seen before in transaction |
| Cold | 2100 | EIP-2929 | First access in transaction |
| Pre-warmed | 100 | EIP-2930 | Via access list |
**Optimization:** SLOAD is \~21x more expensive on cold access. Batch accesses or use access lists for known storage reads.
## Edge Cases
### Uninitialized Slot
```typescript theme={null}
const frame = createFrame({
stack: [0xDEADBEEFn],
gasRemaining: 3000n,
address: contractAddr,
});
// Slot never written - returns 0
sload(frame, host);
console.log(frame.stack); // [0n]
```
### Max Uint256 Value
```typescript theme={null}
const MAX = (1n << 256n) - 1n;
host.setStorage(contractAddr, 0x1n, MAX);
const frame = createFrame({
stack: [0x1n],
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
console.log(frame.stack); // [MAX]
```
### Stack Boundaries
```typescript theme={null}
// Reading with key = 0
const frame = createFrame({
stack: [0n], // Slot 0
gasRemaining: 3000n,
address: contractAddr,
});
sload(frame, host);
// Reading with key = max
const maxFrame = createFrame({
stack: [(1n << 256n) - 1n],
gasRemaining: 3000n,
address: contractAddr,
});
sload(maxFrame, host);
```
### Insufficient Gas
```typescript theme={null}
const frame = createFrame({
stack: [0x42n],
gasRemaining: 50n, // < 100 (warm cost)
address: contractAddr,
});
const error = sload(frame, host);
console.log(error); // { type: "OutOfGas" }
console.log(frame.pc); // 0 (unchanged, not executed)
```
## Common Usage
### State Variable Access
```solidity theme={null}
contract Counter {
uint256 public count; // Slot 0
function getCount() public view returns (uint256) {
return count; // SLOAD(0)
}
function increment() public {
count++; // SLOAD(0) + ADD + SSTORE(0)
}
}
```
### Mapping Lookups
```solidity theme={null}
contract Bank {
mapping(address => uint256) public balances;
function getBalance(address user) public view returns (uint256) {
return balances[user]; // SLOAD with keccak computed key
}
function transfer(address to, uint256 amount) public {
uint256 myBalance = balances[msg.sender]; // SLOAD cold (2100)
require(myBalance >= amount, "insufficient balance");
balances[msg.sender] = myBalance - amount; // SLOAD warm (100)
balances[to] += amount;
}
}
```
### Multi-Read Optimization
```solidity theme={null}
// Inefficient: Multiple SLOAD cold accesses
function inefficient(address user) public view returns (uint256, uint256, uint256) {
return (
balances[user], // SLOAD cold (2100)
approved[user], // SLOAD cold (2100)
lastUpdate[user] // SLOAD cold (2100)
);
}
// Efficient: Cache in memory (MSTORE is cheap)
function efficient(address user) public view returns (uint256, uint256, uint256) {
uint256 bal = balances[user]; // SLOAD cold (2100)
uint256 app = approved[user]; // SLOAD cold (2100) - new slot
uint256 last = lastUpdate[user]; // SLOAD cold (2100) - new slot
return (bal, app, last);
}
```
### Access List Warm-up
```typescript theme={null}
// Solidity: Declare access list in transaction
const tx = {
to: contractAddr,
data: encodeFunctionCall("transfer", [to, amount]),
accessList: [
{
address: contractAddr,
storageKeys: [
0x0n, // balances mapping base
0x1n, // approved mapping base
]
}
]
};
// SLOAD now uses 100 gas (warm) even on first access
```
## Implementation
```typescript theme={null}
import * as Frame from "../../Frame/index.js";
import { ColdSload } from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* SLOAD (0x54) - Load word from storage
*
* Stack:
* in: key
* out: value
*
* Gas: 100 (warm) or 2100 (cold) - EIP-2929
*/
export function sload(frame, host) {
// Pop key from stack
const keyResult = Frame.popStack(frame);
if (keyResult.error) return keyResult.error;
const key = keyResult.value;
// Note: EIP-2929 access list tracking for warm/cold slots
// For now, assume cold access (worst case)
const gasCost = ColdSload;
const gasError = Frame.consumeGas(frame, gasCost);
if (gasError) return gasError;
// Load from storage via host
const value = host.getStorage(frame.address, key);
// Push value onto stack
const pushError = Frame.pushStack(frame, value);
if (pushError) return pushError;
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { sload } from './0x54_SLOAD.js';
import { createFrame } from '../../Frame/index.js';
import { createMemoryHost } from '../../Host/createMemoryHost.js';
import { from as addressFrom } from '../../../primitives/Address/index.js';
describe('SLOAD (0x54)', () => {
it('loads value from storage', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
host.setStorage(addr, 0x42n, 0x1337n);
const frame = createFrame({
stack: [0x42n],
gasRemaining: 10000n,
address: addr,
});
expect(sload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0x1337n]);
expect(frame.pc).toBe(1);
});
it('loads zero for uninitialized storage', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0xFFFFFFFFFn],
gasRemaining: 10000n,
address: addr,
});
expect(sload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0n]);
});
it('isolates storage by address', () => {
const host = createMemoryHost();
const addr1 = addressFrom("0x1111111111111111111111111111111111111111");
const addr2 = addressFrom("0x2222222222222222222222222222222222222222");
host.setStorage(addr1, 0x42n, 0xAAAAn);
host.setStorage(addr2, 0x42n, 0xBBBBn);
let frame = createFrame({
stack: [0x42n],
gasRemaining: 10000n,
address: addr1,
});
expect(sload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0xAAAAn]);
frame = createFrame({
stack: [0x42n],
gasRemaining: 10000n,
address: addr2,
});
expect(sload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0xBBBBn]);
});
it('consumes 2100 gas on cold access', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
host.setStorage(addr, 0x42n, 0x1337n);
const frame = createFrame({
stack: [0x42n],
gasRemaining: 5000n,
address: addr,
});
expect(sload(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(2900n); // 5000 - 2100
});
it('returns StackUnderflow on empty stack', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [],
gasRemaining: 10000n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(sload(frame, host)).toEqual({ type: "StackUnderflow" });
});
it('returns OutOfGas when insufficient gas', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n],
gasRemaining: 50n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(sload(frame, host)).toEqual({ type: "OutOfGas" });
});
it('returns StackOverflow when stack full', () => {
const host = createMemoryHost();
const fullStack = new Array(1024).fill(0n);
const frame = createFrame({
stack: fullStack,
gasRemaining: 10000n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(sload(frame, host)).toEqual({ type: "StackOverflow" });
});
});
```
## Security
### State Immutability During Reads
SLOAD is read-only and safe in any context (even static calls). It cannot modify state, only query it:
```solidity theme={null}
function read(address user) public view returns (uint256) {
return balances[user]; // Always safe, read-only
}
```
### Reentrancy Vulnerability (When Used with State Changes)
SLOAD itself is safe, but reading and then writing creates reentrancy windows:
```solidity theme={null}
// VULNERABLE: Read-check-write pattern
function transfer(address to, uint256 amount) public {
uint256 balance = balances[msg.sender]; // SLOAD
require(balance >= amount);
balances[msg.sender] = balance - amount; // SSTORE
(bool ok, ) = to.call(""); // REENTERS HERE
// Attacker re-enters before balance updated
}
// SAFE: Checks-Effects-Interactions pattern
function transfer(address to, uint256 amount) public {
require(balances[msg.sender] >= amount);
balances[msg.sender] -= amount; // SSTORE first
(bool ok, ) = to.call(""); // Reenter safely
require(ok, "transfer failed");
}
```
### Access List Validation
Ensure access lists match actual storage accessed:
```typescript theme={null}
// Declared in access list
accessList: [{ address: token, storageKeys: [slot0, slot1] }]
// But code accesses different slot
host.getStorage(token, 0xFF) // Slot 0xFF not in access list!
// Will cost 2100 gas instead of expected 100
```
### Gas Cost Variation
Cold/warm access affects gas accounting for batch operations:
```solidity theme={null}
function batchTransfer(address[] calldata users, uint256[] calldata amounts) public {
for (uint i = 0; i < users.length; i++) {
uint256 bal = balances[users[i]]; // Variable cost!
// First unique user: 2100 gas (cold)
// Repeated user: 100 gas (warm)
}
}
```
## Benchmarks
**Access cost comparison:**
* Warm SLOAD: 100 gas
* Cold SLOAD: 2100 gas (21x more expensive)
* MLOAD (memory): 3 gas (67x cheaper than warm)
* L1 cache: \~0.5ns vs \~100ns for cold storage
**Practical implications:**
```typescript theme={null}
// Reading 100 values from same slot
SLOAD(key) // 2100 gas first time
// Keep in stack/memory (cheap operations)
// 99 more stack operations at 3 gas each ≈ 297 gas total
// Total: 2100 + 297 = 2397 gas
// vs reading from cold storage 100 times
// 100 × 2100 = 210,000 gas (86x more expensive!)
```
## References
* [EVM Codes - SLOAD (0x54)](https://www.evm.codes/#54)
* [EIP-2929: Gas-cost increases for state access opcodes](https://eips.ethereum.org/EIPS/eip-2929)
* [EIP-2930: Optional access lists](https://eips.ethereum.org/EIPS/eip-2930)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.3 (Account Storage)
* [Solidity Storage Layout](https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html)
# SSTORE (0x55)
Source: https://voltaire.tevm.sh/evm/instructions/storage/sstore
Save word to persistent storage with complex gas pricing and refunds (EIP-2200, EIP-2929, EIP-3529)
**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:** `0x55`
**Introduced:** Frontier (EVM genesis)
**Updated:** Istanbul (EIP-2200), Berlin (EIP-2929), London (EIP-3529)
SSTORE writes a 256-bit value to persistent storage. Unlike SLOAD, SSTORE has complex gas pricing:
* **Sentry check:** Requires >= 2300 gas remaining (EIP-2200)
* **Cost varies:** Depends on current value, original value, and warm/cold access
* **Refunds:** Up to 4800 gas refunded for clearing slots (EIP-3529)
This operation commits data to blockchain state and powers smart contract state management.
## Specification
**Stack Input:**
```
key (storage slot address)
value (256-bit value to store)
```
**Stack Output:**
```
(none - consumes both inputs)
```
**Gas Cost:** Complex (see detailed table below)
* **Base:** 100-5000 gas depending on operation type
* **Cold access:** Additional 2100 gas for first-time write
* **Sentry:** Requires >= 2300 gas remaining
* **Refund:** Up to 4800 gas refunded when clearing
**Operation:**
```
key = pop()
value = pop()
// Check sentry (EIP-2200)
if (gasRemaining < 2300) fail
// Compute gas based on current/original value
if (currentValue == 0 && value != 0) cost = 20000 // Set
else if (currentValue != 0 || value != 0) cost = 5000 // Reset
else cost = 0 // Noop, already zero
// Refund if clearing
if (value == 0 && currentValue != 0) refund = 4800 // EIP-3529
storage[address][key] = value
gasRemaining -= cost
```
## Behavior
SSTORE modifies an account's storage and marks the slot as changed in the transaction:
1. **Pop key and value** from stack
2. **Check sentry** - Requires >= 2300 gas remaining (EIP-2200)
3. **Prevent state modification in static calls** - Return WriteProtection error
4. **Compute gas cost** based on:
* Current value (what's stored now)
* Original value (what was before transaction)
* Whether slot is cold/warm (EIP-2929)
5. **Consume gas** or return OutOfGas error
6. **Apply refunds** for clearing (max 4800)
7. **Write to storage** and increment PC
### EIP-2200 Gas Metering
Modern gas metering (Istanbul+) tracks two values:
| Case | Current | Original | Value | Cost | Refund | Notes |
| ------- | -------- | -------- | --------- | ----- | ------ | ------------------ |
| Set | 0 | 0 | non-zero | 20000 | 0 | New entry |
| Update | non-zero | non-zero | different | 5000 | 0 | Modify existing |
| Clear | non-zero | non-zero | 0 | 5000 | 4800 | Refund on delete |
| Restore | non-zero | non-zero | original | 5000 | 4800 | Return to original |
| Noop | 0 | 0 | 0 | 0 | 0 | Already zero |
### Cold/Warm Access (EIP-2929)
Additional gas added for cold (first-access) writes:
| Access | Cost | Notes |
| ------ | ----------- | ------------------------------- |
| Warm | Base cost | Already accessed in transaction |
| Cold | Base + 2100 | First access in transaction |
### Refund Mechanics (EIP-3529)
Refunds apply when clearing slots:
```
if (newValue == 0 && currentValue != 0) {
addRefund(4800) // Max refund per cleared slot
}
```
**Refund limit:** Maximum refund is 1/5 of total gas consumed in transaction.
## Examples
### Basic Storage Write
```typescript theme={null}
import { sstore } from '@voltaire/evm/storage';
import { createFrame } from '@voltaire/evm/Frame';
import { createMemoryHost } from '@voltaire/evm/Host';
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n], // [key, value]
gasRemaining: 30000n,
address: contractAddr,
isStatic: false,
});
const error = sstore(frame, host);
console.log(error); // null (success)
console.log(frame.gasRemaining); // ~25000 (30000 - 5000 base)
console.log(host.getStorage(contractAddr, 0x42n)); // 0x1337n
```
### Zero to Non-Zero (Set)
```typescript theme={null}
// Writing non-zero to empty slot (Set operation)
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n], // [key, value]
gasRemaining: 30000n,
address: contractAddr,
isStatic: false,
});
// Before: slot 0x42 is empty (0)
// After: slot 0x42 = 0x1337n
const error = sstore(frame, host);
console.log(frame.gasRemaining); // 10000 (30000 - 20000 set cost)
```
### Modify Existing (Update)
```typescript theme={null}
// Slot already has a value, writing different value
const host = createMemoryHost();
host.setStorage(contractAddr, 0x42n, 0x1111n); // Pre-existing
const frame = createFrame({
stack: [0x42n, 0x2222n], // [key, new value]
gasRemaining: 10000n,
address: contractAddr,
isStatic: false,
});
const error = sstore(frame, host);
console.log(frame.gasRemaining); // 5000 (10000 - 5000 reset cost)
console.log(host.getStorage(contractAddr, 0x42n)); // 0x2222n
```
### Clear Storage (With Refund)
```typescript theme={null}
// Clearing a slot (setting to 0) - gets refund
const host = createMemoryHost();
host.setStorage(contractAddr, 0x42n, 0x1337n); // Has value
const frame = createFrame({
stack: [0x42n, 0n], // [key, 0] - clearing
gasRemaining: 10000n,
address: contractAddr,
isStatic: false,
});
const error = sstore(frame, host);
console.log(frame.gasRemaining); // 5000 (10000 - 5000 clear cost)
console.log(frame.refunds); // 4800 (refund for clearing)
console.log(host.getStorage(contractAddr, 0x42n)); // 0n (cleared)
```
### Restore to Original (Refund Path)
```typescript theme={null}
// Modifying and then restoring original value - gets refund
const host = createMemoryHost();
host.setStorage(contractAddr, 0x42n, 0x1337n); // Original value
const original = 0x1337n;
const frame = createFrame({
stack: [0x42n, 0x1337n], // [key, original value]
gasRemaining: 10000n,
address: contractAddr,
isStatic: false,
});
// This might be second write in transaction
// First write: SSTORE(0x42, 0x2222) - modifies
// Second write: SSTORE(0x42, 0x1337) - restores
// Second write costs 5000 and refunds 4800
const error = sstore(frame, host);
console.log(frame.refunds); // 4800 (refund for restoration)
```
### Insufficient Gas (Sentry Check)
```typescript theme={null}
// Fails sentry check - requires >= 2300 gas
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 100n, // < 2300
address: contractAddr,
isStatic: false,
});
const error = sstore(frame, host);
console.log(error); // { type: "OutOfGas" } - sentry failed
console.log(frame.pc); // 0 (not executed)
```
### Static Call Protection
```typescript theme={null}
// Cannot modify storage in static context
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 30000n,
address: contractAddr,
isStatic: true, // Static call context
});
const error = sstore(frame, host);
console.log(error); // { type: "WriteProtection" }
```
## Gas Cost
### Cost Matrix
| Scenario | Current | Original | Value | Gas | Refund | EIP |
| ---------------- | ------- | -------- | ----------- | ----- | ------ | ---- |
| Set (new) | 0 | 0 | ≠0 | 20000 | 0 | - |
| Update | ≠0 | ≠0 | ≠0,≠current | 5000 | 0 | - |
| Clear | ≠0 | ≠0 | 0 | 5000 | 4800 | 3529 |
| Restore original | ≠0 | X | original | 5000 | 4800 | 3529 |
| Noop | 0 | 0 | 0 | 0 | 0 | - |
| Cold set | 0 | 0 | ≠0 | 22100 | 0 | 2929 |
| Cold update | ≠0 | ≠0 | ≠0,≠current | 7100 | 0 | 2929 |
### Gas Evolution (EIP Timeline)
**Pre-Istanbul (Frontier-Petersburg):**
* Zero → non-zero: 20000 gas
* Otherwise: 5000 gas
* Refund: 15000 gas for clearing
**Istanbul (EIP-2200):**
* Added sentry check (>= 2300 gas required)
* Complex metering based on original value
* Reduced refund to 4800 (EIP-3529)
**Berlin (EIP-2929):**
* Added cold/warm access tracking
* First write to slot: +2100 gas
**London (EIP-3529):**
* Reduced refunds from 15000 to 4800
* Max refund limited to 1/5 of total gas
## Edge Cases
### Noop Write (Already Zero)
```typescript theme={null}
// Writing 0 to already-zero slot costs nothing
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0n],
gasRemaining: 1000n,
address: contractAddr,
isStatic: false,
});
// Slot 0x42 is uninitialized (already 0)
const error = sstore(frame, host);
console.log(error); // null
console.log(frame.gasRemaining); // 1000 (unchanged, noop cost = 0)
```
### Max Value Write
```typescript theme={null}
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0x42n, MAX],
gasRemaining: 30000n,
address: contractAddr,
isStatic: false,
});
sstore(frame, host);
console.log(host.getStorage(contractAddr, 0x42n)); // MAX
```
### Refund Limit
```typescript theme={null}
// Refunds capped at 1/5 of total transaction gas
// If transaction uses 100000 gas, max refund = 20000
// Even if multiple clears would give 40000 refund
const refundQuotient = 5n; // 1/5
const maxRefund = totalGasUsed / refundQuotient;
const actualRefund = Math.min(4800 * numClears, maxRefund);
```
## Common Usage
### State Variable Storage
```solidity theme={null}
contract Counter {
uint256 public count; // Slot 0
function increment() public {
count++; // SLOAD + ADD + SSTORE
// First SSTORE to count: 20000 gas (set)
// Subsequent increments: 5000 gas (update)
}
function reset() public {
count = 0; // SSTORE with refund
// Cost: 5000 gas
// Refund: 4800 gas
}
}
```
### Mapping Updates
```solidity theme={null}
contract Bank {
mapping(address => uint256) public balances;
function deposit() public payable {
uint256 bal = balances[msg.sender]; // SLOAD
balances[msg.sender] = bal + msg.value; // SSTORE
// First deposit: 20000 gas (set)
// Subsequent: 5000 gas (update)
}
function withdraw(uint256 amount) public {
uint256 bal = balances[msg.sender];
require(bal >= amount);
balances[msg.sender] = bal - amount; // SSTORE
// If balance becomes 0: 5000 gas + 4800 refund
}
}
```
### Batch Updates
```solidity theme={null}
function batchUpdate(uint256[] calldata newValues) public {
for (uint i = 0; i < newValues.length; i++) {
data[i] = newValues[i]; // Multiple SSTORE
// First write to slot: 20000 gas (cold set)
// Writes to same slot: 5000 gas (warm update)
}
}
```
### Gas-Efficient Clearing
```solidity theme={null}
// Refund-aware clearing pattern
function cleanup() public {
// Clear multiple storage slots in one transaction
slot0 = 0; // 5000 gas, 4800 refund
slot1 = 0; // 5000 gas, 4800 refund
slot2 = 0; // 5000 gas, 4800 refund
// Total cost: 15000 gas
// Total refund: 14400 gas (limited by 1/5 rule)
// Actual cost: 15000 - 14400 = 600 gas
}
```
## Implementation
```typescript theme={null}
import * as Frame from "../../Frame/index.js";
import {
SstoreSentry,
SstoreSet,
SstoreReset,
SstoreRefund,
ColdSload,
} from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* SSTORE (0x55) - Save word to storage
*
* Stack:
* in: key, value
* out: -
*
* Gas: Complex - EIP-2200 (Istanbul+) / EIP-2929 (Berlin+) / EIP-3529 (London+)
*/
export function sstore(frame, host) {
// EIP-214: Cannot modify state in static call
if (frame.isStatic) {
return { type: "WriteProtection" };
}
// Pop key and value from stack
const keyResult = Frame.popStack(frame);
if (keyResult.error) return keyResult.error;
const key = keyResult.value;
const valueResult = Frame.popStack(frame);
if (valueResult.error) return valueResult.error;
const value = valueResult.value;
// Get current value for gas calculation
const currentValue = host.getStorage(frame.address, key);
// Outline: Implement full EIP-2200/2929/3529 logic with:
// - Original value tracking (getOriginal)
// - Access list for cold/warm slots
// - Hardfork-dependent gas costs and refunds
// - Sentry check (requires >= 2300 gas)
// Simplified gas calculation
const gasCost = currentValue === 0n && value !== 0n
? SstoreSet // 20000 - new entry
: SstoreReset; // 5000 - modify/clear
const gasError = Frame.consumeGas(frame, gasCost);
if (gasError) return gasError;
// Then: Apply refund logic
if (value === 0n && currentValue !== 0n) {
frame.refunds += SstoreRefund; // 4800 refund
}
// Store value via host
host.setStorage(frame.address, key, value);
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { sstore } from './0x55_SSTORE.js';
import { createFrame } from '../../Frame/index.js';
import { createMemoryHost } from '../../Host/createMemoryHost.js';
import { from as addressFrom } from '../../../primitives/Address/index.js';
describe('SSTORE (0x55)', () => {
it('stores value to empty slot (set)', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 30000n,
address: addr,
isStatic: false,
});
expect(sstore(frame, host)).toBeNull();
expect(host.getStorage(addr, 0x42n)).toBe(0x1337n);
expect(frame.gasRemaining).toBe(10000n); // 30000 - 20000
});
it('updates existing value (reset)', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
host.setStorage(addr, 0x42n, 0x1111n);
const frame = createFrame({
stack: [0x42n, 0x2222n],
gasRemaining: 10000n,
address: addr,
isStatic: false,
});
expect(sstore(frame, host)).toBeNull();
expect(host.getStorage(addr, 0x42n)).toBe(0x2222n);
expect(frame.gasRemaining).toBe(5000n); // 10000 - 5000
});
it('clears storage with refund', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
host.setStorage(addr, 0x42n, 0x1337n);
const frame = createFrame({
stack: [0x42n, 0n],
gasRemaining: 10000n,
address: addr,
isStatic: false,
refunds: 0n,
});
expect(sstore(frame, host)).toBeNull();
expect(host.getStorage(addr, 0x42n)).toBe(0n);
expect(frame.gasRemaining).toBe(5000n); // 10000 - 5000
expect(frame.refunds).toBe(4800n); // Refund
});
it('rejects write in static call', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 30000n,
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: true,
});
expect(sstore(frame, host)).toEqual({ type: "WriteProtection" });
});
it('fails sentry check with insufficient gas', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 100n, // < 2300
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: false,
});
// Note: Implement sentry check
// expect(sstore(frame, host)).toEqual({ type: "OutOfGas" });
});
it('handles noop write (zero to zero)', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n, 0n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
// Slot uninitialized, writing 0 to 0
expect(sstore(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(1000n); // No cost
});
it('returns StackUnderflow on insufficient stack', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n], // Only key, missing value
gasRemaining: 30000n,
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: false,
});
expect(sstore(frame, host)).toEqual({ type: "StackUnderflow" });
});
it('returns OutOfGas when base cost exceeds remaining', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 100n, // < 20000 for set
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: false,
});
expect(sstore(frame, host)).toEqual({ type: "OutOfGas" });
});
it('isolates storage by address', () => {
const host = createMemoryHost();
const addr1 = addressFrom("0x1111111111111111111111111111111111111111");
const addr2 = addressFrom("0x2222222222222222222222222222222222222222");
const frame1 = createFrame({
stack: [0x42n, 0xAAAAn],
gasRemaining: 30000n,
address: addr1,
isStatic: false,
});
sstore(frame1, host);
const frame2 = createFrame({
stack: [0x42n, 0xBBBBn],
gasRemaining: 30000n,
address: addr2,
isStatic: false,
});
sstore(frame2, host);
expect(host.getStorage(addr1, 0x42n)).toBe(0xAAAAn);
expect(host.getStorage(addr2, 0x42n)).toBe(0xBBBBn);
});
});
```
## Security
### Sentry Check (EIP-2200)
The sentry ensures SSTORE cannot be called with insufficient gas to complete state modifications:
```solidity theme={null}
// VULNERABLE: Old code (pre-Istanbul)
function mayModifyState() public {
if (msg.value < 0.01 ether) return;
storage[msg.sender] = data;
}
// After SSTORE, state is modified but transaction might fail later
// Could create inconsistent blockchain state
```
**Solution:** Sentry check (>= 2300 gas) prevents this:
```
if (gasRemaining < 2300) revert
// SSTORE cannot occur with less than 2300 gas available
```
### Static Call Protection
SSTORE correctly rejects all writes in `STATICCALL` context:
```solidity theme={null}
// SAFE: Read-only function
function getData() public view returns (uint256) {
return data; // Only SLOAD allowed
}
// UNSAFE: Attempting write in view function
function badFunction() public view returns (uint256) {
data = 42; // SSTORE fails with WriteProtection
return data;
}
```
### Reentrancy with Storage
```solidity theme={null}
// VULNERABLE: Read-modify-write pattern with call
function withdraw(uint256 amount) public {
uint256 balance = balances[msg.sender]; // SLOAD
require(balance >= amount);
balances[msg.sender] = balance - amount; // SSTORE
(bool ok, ) = msg.sender.call{value: amount}(""); // REENTRANT
// Attacker can re-enter here and call withdraw again
// Original SSTORE not yet committed to state
}
// SAFE: Effects-Interactions pattern
function withdraw(uint256 amount) public {
require(balances[msg.sender] >= amount);
balances[msg.sender] -= amount; // SSTORE first
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "transfer failed");
}
```
### Refund Manipulation
Attacker might try to maximize refunds:
```solidity theme={null}
// INEFFICIENT: Clearing to get refund
function attackRefunds() public {
// Write then clear intentionally to get refund
data = 42; // 20000 gas (set)
data = 0; // 5000 gas (clear) + 4800 refund
// Total cost: 25000 - 4800 = 20200 gas
// vs: original cost + cleanup elsewhere
}
// Not really an attack, but refunds incentivize cleanup
// This is intentional - EIP-3529 refunds are feature, not bug
```
### Gas Cost Calculation Errors
```solidity theme={null}
// WRONG: Assuming constant SSTORE cost
function batchWrite(uint256[] calldata values) public {
uint256 gasPerWrite = 5000; // WRONG - ignores set cost
require(gasleft() > values.length * gasPerWrite);
for (uint i = 0; i < values.length; i++) {
data[i] = values[i]; // First write: 20000 (set)
// Second write onward: 5000 (update)
// Can run out of gas!
}
}
// RIGHT: Account for variable costs
function batchWrite(uint256[] calldata values) public {
uint256 firstWriteCost = 20000;
uint256 updateCost = 5000;
uint256 requiredGas = firstWriteCost + (values.length - 1) * updateCost;
require(gasleft() > requiredGas, "insufficient gas");
for (uint i = 0; i < values.length; i++) {
data[i] = values[i];
}
}
```
## Benchmarks
**Storage write costs:**
* Set (0 → non-zero): 20000 gas
* Update (non-zero → different): 5000 gas
* Clear (non-zero → 0): 5000 gas + 4800 refund
* Cold access penalty: +2100 gas (EIP-2929)
**Relative performance:**
* MSTORE (memory): 3 gas
* Warm SLOAD: 100 gas
* Cold SLOAD: 2100 gas
* Warm SSTORE update: 5000 gas
* SSTORE set: 20000 gas (4x more expensive than update)
**Optimization tactics:**
```solidity theme={null}
// Batch updates in single transaction (warm access)
// vs multiple transactions (cold access each time)
// Single tx: 20000 + 5000 = 25000 gas
// Multiple tx: 20000 + 2100 + 2100 + ... (much higher)
```
## References
* [EVM Codes - SSTORE (0x55)](https://www.evm.codes/#55)
* [EIP-2200: Structured Definitions for Net Gas Metering](https://eips.ethereum.org/EIPS/eip-2200)
* [EIP-2929: Gas-cost increases for state access opcodes](https://eips.ethereum.org/EIPS/eip-2929)
* [EIP-3529: Reduction in refunds](https://eips.ethereum.org/EIPS/eip-3529)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (Execution)
* [Solidity Storage Layout](https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html)
# TLOAD (0x5c)
Source: https://voltaire.tevm.sh/evm/instructions/storage/tload
Load word from transient storage (EIP-1153, Cancun, fixed 100 gas)
**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:** `0x5c`
**Introduced:** Cancun (EIP-1153)
TLOAD reads from transient storage—a per-transaction key-value store that is automatically cleared when the transaction ends. Unlike persistent storage (SLOAD), transient storage:
* Costs only 100 gas (fixed, no cold/warm metering)
* Is not persisted to blockchain state
* Cannot be accessed by external calls
* Clears automatically at end of transaction
Primary use cases:
* Reentrancy guards (check/set flags with minimal gas)
* Inter-contract communication within same transaction
* Temporary state without expensive storage costs
## Specification
**Stack Input:**
```
key (256-bit storage slot address)
```
**Stack Output:**
```
value (256-bit value, or 0 if uninitialized)
```
**Gas Cost:** 100 (fixed, EIP-1153)
**Hardfork:** Cancun+ (unavailable on earlier hardforks)
**Operation:**
```
key = pop()
value = transientStorage[msg.sender][key] // 0 if never written
push(value)
gasRemaining -= 100
```
## Behavior
TLOAD retrieves the current value from transient storage:
1. **Pop key** from stack (256-bit unsigned integer)
2. **Query host** for transient storage value at contract address + key
3. **Return value** from host (0 if never written or cleared by transaction end)
4. **Push result** to stack
5. **Consume 100 gas** (fixed cost, no gas refunds)
6. **Increment PC**
### Transient Storage Scope
Transient storage is scoped to:
* **Per contract:** Each contract has separate transient storage
* **Per transaction:** Automatically cleared when transaction completes
* **Not persisted:** Does not affect blockchain state
* **Not callable:** Cannot be read via `eth_getStorageAt` or `eth_call`
### Uninitialized Values
Transient storage slots never written return 0:
```javascript theme={null}
TLOAD(key) // Returns 0 if key was never written
```
### Transaction Boundary
Transient storage is cleared at the end of each transaction:
```javascript theme={null}
// Transaction 1
TSTORE(key, 0x1234)
TLOAD(key) // 0x1234
// Transaction 2 (new transaction)
TLOAD(key) // 0 (cleared from TX1)
```
## Examples
### Basic Transient Read
```typescript theme={null}
import { tload } from '@voltaire/evm/storage';
import { createFrame } from '@voltaire/evm/Frame';
import { createMemoryHost } from '@voltaire/evm/Host';
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n], // Key to read
gasRemaining: 3000n,
address: contractAddr,
});
// Pre-populate transient storage (e.g., from TSTORE)
host.setTransientStorage(contractAddr, 0x42n, 0x1337n);
// Execute TLOAD
const error = tload(frame, host);
console.log(frame.stack); // [0x1337n]
console.log(frame.gasRemaining); // 2900n (3000 - 100)
console.log(error); // null
```
### Reentrancy Guard Pattern
```typescript theme={null}
// Reentrancy guard using transient storage
const guardKey = 0x01n;
// Check guard is unlocked
const readFrame = createFrame({
stack: [guardKey],
gasRemaining: 3000n,
address: contractAddr,
});
tload(readFrame, host);
if (readFrame.stack[0] !== 0n) {
return { type: "ReentrancyDetected" };
}
// Lock before call
const lockFrame = createFrame({
stack: [guardKey, 0x1n],
gasRemaining: 3000n,
address: contractAddr,
});
tstore(lockFrame, host);
// ... perform call ...
// Unlock after call
const unlockFrame = createFrame({
stack: [guardKey, 0n],
gasRemaining: 3000n,
address: contractAddr,
});
tstore(unlockFrame, host);
```
### Multiple Values
```typescript theme={null}
// Store multiple values in transient storage
const keys = {
FLAG: 0x01n,
COUNTER: 0x02n,
BALANCE: 0x03n,
};
// Read all values
const values = {};
for (const [name, key] of Object.entries(keys)) {
const frame = createFrame({
stack: [key],
gasRemaining: 1000n,
address: contractAddr,
});
tload(frame, host);
values[name] = frame.stack[0];
}
console.log(values);
// {
// FLAG: 0x0n,
// COUNTER: 0x42n,
// BALANCE: 0xDEADBEEFn
// }
```
### Transaction Boundary
```typescript theme={null}
// Within transaction: Persist across calls
const host = createMemoryHost();
const addr = contractAddr;
// Set value
let frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 3000n,
address: addr,
});
tstore(frame, host);
// Read value (same transaction, same call)
frame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: addr,
});
tload(frame, host);
console.log(frame.stack); // [0x1337n]
// At transaction end: Automatically cleared
// endTransaction(host, addr);
//
// Next transaction:
// frame = createFrame({
// stack: [0x42n],
// gasRemaining: 3000n,
// address: addr,
// });
// tload(frame, host);
// console.log(frame.stack); // [0n] - cleared!
```
### Inter-Call Communication
```solidity theme={null}
// Contract A stores data for contract B to read
contract A {
function callB(address b) public {
// Store context for B
assembly {
tstore(0x01, caller()) // Store caller
tstore(0x02, 42) // Store arbitrary data
}
// Call B (B can read transient storage)
IContractB(b).doSomething();
// Transient storage still available after call
// (until transaction ends)
}
}
contract B {
function doSomething() public {
// Read context from A
address caller;
uint256 data;
assembly {
caller := tload(0x01)
data := tload(0x02)
}
// Use caller and data
require(data == 42);
}
}
```
### Insufficient Gas
```typescript theme={null}
const frame = createFrame({
stack: [0x42n],
gasRemaining: 50n, // < 100
address: contractAddr,
});
const error = tload(frame, host);
console.log(error); // { type: "OutOfGas" }
console.log(frame.pc); // 0 (unchanged, not executed)
```
## Gas Cost
**Fixed Cost:** 100 gas (always)
| Operation | Cost | Notes |
| ---------- | ---- | ------------------------------ |
| TLOAD | 100 | Fixed, no refunds |
| SLOAD warm | 100 | Same cost but persists |
| SLOAD cold | 2100 | 21x more expensive |
| MLOAD | 3 | 33x cheaper but only in memory |
**Comparison:**
```
TLOAD: 100 gas (transient, shared across calls)
MSTORE/MLOAD: 3 gas (local to call, memory-only)
SLOAD warm: 100 gas (persistent, per-transaction)
SLOAD cold: 2100 gas (persistent, expensive)
```
TLOAD bridges the gap—costs same as warm SLOAD but doesn't persist or refund.
## Edge Cases
### Uninitialized Slot
```typescript theme={null}
const frame = createFrame({
stack: [0xDEADBEEFn], // Key never written
gasRemaining: 3000n,
address: contractAddr,
});
tload(frame, host);
console.log(frame.stack); // [0n]
```
### Max Uint256 Key
```typescript theme={null}
const MAX_KEY = (1n << 256n) - 1n;
const frame = createFrame({
stack: [MAX_KEY],
gasRemaining: 3000n,
address: contractAddr,
});
tload(frame, host);
console.log(frame.stack); // [0n] or stored value
```
### Hardfork Unavailable
```typescript theme={null}
// TLOAD not available before Cancun
// If hardfork < CANCUN:
const frame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: contractAddr,
hardfork: "Shanghai", // < Cancun
});
const error = tload(frame, host);
console.log(error); // { type: "InvalidOpcode" }
```
### Stack Boundaries
```typescript theme={null}
// Stack overflow when full
const fullStack = new Array(1024).fill(0n);
const frame = createFrame({
stack: fullStack,
gasRemaining: 3000n,
address: contractAddr,
});
const error = tload(frame, host);
console.log(error); // { type: "StackOverflow" }
```
## Common Usage
### Reentrancy Guard
```solidity theme={null}
// EIP-1153 reentrancy guard (cheaper than storage)
contract Safe {
uint256 private constant LOCKED = 1;
function _nonReentrant() internal {
assembly {
// Check: guard must be unlocked (0)
if tload(0) { revert(0, 0) }
// Lock: set guard to LOCKED
tstore(0, LOCKED)
}
}
function _nonReentrantEnd() internal {
assembly {
// Unlock: clear guard
tstore(0, 0)
}
}
function safeTransfer(address to, uint256 amount) public {
_nonReentrant();
uint256 balance = balances[msg.sender];
require(balance >= amount);
balances[msg.sender] = balance - amount;
// Reentrancy window: attacker re-enters, guard prevents nested call
(bool ok, ) = to.call{value: amount}("");
_nonReentrantEnd();
require(ok);
}
}
```
**Gas savings:** Using transient storage (200 gas total: 100 read + 100 write) vs persistent storage (20000+ gas).
### Callback Data Passing
```solidity theme={null}
// Multicall pattern using transient storage
contract Multicall {
function multicall(
address[] calldata targets,
bytes[] calldata data
) public {
for (uint i = 0; i < targets.length; i++) {
// Store callback context
assembly {
tstore(0x01, i)
tstore(0x02, caller())
}
// Target can read context with TLOAD
(bool ok, ) = targets[i].call(data[i]);
require(ok);
}
// Context cleared at tx end
}
}
contract Target {
function execute(bytes calldata data) external {
// Read callback context
uint256 index;
address caller;
assembly {
index := tload(0x01)
caller := tload(0x02)
}
// Use index and caller for context-aware logic
}
}
```
### Temporary Counters
```solidity theme={null}
contract Counter {
uint256 public globalCount;
function batchIncrement(uint256 count) public {
// Use transient counter for temp state (100 gas per operation)
assembly {
tstore(0x01, 0) // temp counter = 0
}
for (uint i = 0; i < count; i++) {
// Increment temp counter
assembly {
let c := tload(0x01)
tstore(0x01, add(c, 1))
}
}
// Write final count to storage once (20000 or 5000 gas)
assembly {
globalCount := tload(0x01)
}
}
}
```
### Delegation Pattern
```solidity theme={null}
// Store delegation context for called contracts
contract Delegator {
function delegatedCall(
address target,
bytes calldata data,
bytes calldata context
) public {
// Store context for target
assembly {
tstore(0x01, context)
}
// Target executes knowing context
(bool ok, bytes memory result) = target.call(data);
require(ok);
// Context automatically cleared by transaction end
}
}
```
## Implementation
```typescript theme={null}
import * as Frame from "../../Frame/index.js";
import { TLoad } from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* TLOAD (0x5c) - Load word from transient storage
*
* Stack:
* in: key
* out: value
*
* Gas: 100 (fixed)
*
* EIP-1153: Transient storage opcodes (Cancun hardfork)
*/
export function tload(frame, host) {
// Note: Add hardfork validation - TLOAD requires Cancun+
// if (hardfork < CANCUN) return { type: "InvalidOpcode" };
const gasError = Frame.consumeGas(frame, TLoad);
if (gasError) return gasError;
// Pop key from stack
const keyResult = Frame.popStack(frame);
if (keyResult.error) return keyResult.error;
const key = keyResult.value;
// Load from transient storage
const value = host.getTransientStorage(frame.address, key) ?? 0n;
// Push value onto stack
const pushError = Frame.pushStack(frame, value);
if (pushError) return pushError;
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { tload } from './0x5c_TLOAD.js';
import { tstore } from './0x5d_TSTORE.js';
import { createFrame } from '../../Frame/index.js';
import { createMemoryHost } from '../../Host/createMemoryHost.js';
import { from as addressFrom } from '../../../primitives/Address/index.js';
describe('TLOAD (0x5c)', () => {
it('loads value from transient storage', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
// Pre-populate transient storage
host.setTransientStorage(addr, 0x42n, 0x1337n);
const frame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0x1337n]);
expect(frame.pc).toBe(1);
expect(frame.gasRemaining).toBe(900n); // 1000 - 100
});
it('loads zero for uninitialized slot', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0n]);
});
it('isolates transient storage by address', () => {
const host = createMemoryHost();
const addr1 = addressFrom("0x1111111111111111111111111111111111111111");
const addr2 = addressFrom("0x2222222222222222222222222222222222222222");
host.setTransientStorage(addr1, 0x42n, 0xAAAAn);
host.setTransientStorage(addr2, 0x42n, 0xBBBBn);
let frame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr1,
});
expect(tload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0xAAAAn]);
frame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr2,
});
expect(tload(frame, host)).toBeNull();
expect(frame.stack).toEqual([0xBBBBn]);
});
it('consumes fixed 100 gas', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
host.setTransientStorage(addr, 0x42n, 0x1337n);
const frame = createFrame({
stack: [0x42n],
gasRemaining: 5000n,
address: addr,
});
expect(tload(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(4900n); // 5000 - 100 (always)
});
it('returns StackUnderflow on empty stack', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [],
gasRemaining: 1000n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(tload(frame, host)).toEqual({ type: "StackUnderflow" });
});
it('returns OutOfGas when insufficient gas', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n],
gasRemaining: 50n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(tload(frame, host)).toEqual({ type: "OutOfGas" });
});
it('returns StackOverflow when stack full', () => {
const host = createMemoryHost();
const fullStack = new Array(1024).fill(0n);
const frame = createFrame({
stack: fullStack,
gasRemaining: 1000n,
address: addressFrom("0x1111111111111111111111111111111111111111"),
});
expect(tload(frame, host)).toEqual({ type: "StackOverflow" });
});
it('loads max uint256 value', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const MAX = (1n << 256n) - 1n;
host.setTransientStorage(addr, 0x42n, MAX);
const frame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(frame, host)).toBeNull();
expect(frame.stack).toEqual([MAX]);
});
it('persists within transaction, clears on boundary', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
// Write value
const writeFrame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
tstore(writeFrame, host);
// Read value (same transaction)
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0x1337n]);
// After transaction boundary (cleared automatically)
// host.endTransaction();
// const newReadFrame = createFrame({
// stack: [0x42n],
// gasRemaining: 1000n,
// address: addr,
// });
// expect(tload(newReadFrame, host)).toBeNull();
// expect(newReadFrame.stack).toEqual([0n]);
});
});
```
## Security
### Safe in All Contexts
TLOAD is read-only and safe in static calls, constant functions, and any execution context:
```solidity theme={null}
function read(uint256 key) public view returns (uint256) {
uint256 value;
assembly {
value := tload(key) // Always safe, read-only
}
return value;
}
```
### Reentrancy Guard Effectiveness
Transient storage reentrancy guards are effective because:
1. **State is local to transaction:** Attacker cannot bypass guard across transactions
2. **Atomic updates:** Lock + operation + unlock are atomic per call frame
3. **Automatic cleanup:** Guard cleared even if transaction reverts partway
```solidity theme={null}
contract Safe {
function guarded() public {
assembly {
if tload(0) { revert(0, 0) } // Check guard
tstore(0, 1) // Lock
}
// Call external contract
(bool ok, ) = msg.sender.call("");
require(ok);
// Even if call fails here, guard is locked
// Attacker cannot re-enter
assembly {
tstore(0, 0) // Unlock
}
}
}
```
### Isolation Between Contracts
Transient storage is isolated per contract address:
```solidity theme={null}
// Contract A cannot read/write Contract B's transient storage
contract A {
function tryRead() public {
uint256 value;
assembly {
value := tload(0x42) // Reads A's transient storage
}
// Cannot access B's TSTORE values
}
}
```
### No Persistence Risk
Unlike persistent storage, transient storage cannot leave dangling state:
```solidity theme={null}
// No risk of incomplete state
function operation() public {
assembly {
tstore(0x01, 1) // Temporary state
}
// Even if transaction reverts here:
// TLOAD(0x01) returns 0 in next transaction
// No leftover state to clean up
}
```
## Benchmarks
**Cost comparison:**
| Operation | Cost | Use Case |
| ---------- | -------- | ----------------------------- |
| TLOAD | 100 gas | Transaction-scoped reads |
| TSTORE | 100 gas | Transaction-scoped writes |
| SLOAD warm | 100 gas | Persistent reads (persistent) |
| SLOAD cold | 2100 gas | First access (expensive) |
| MLOAD | 3 gas | Memory (local scope) |
| MSTORE | 3 gas | Memory (local scope) |
**Practical gas savings (reentrancy guard):**
```
Storage-based guard:
- Check: SLOAD cold (2100) → warm (100)
- Set: SSTORE (20000 or 5000)
- Clear: SSTORE (5000 + 4800 refund)
- Total: ~22100 gas
Transient-based guard (EIP-1153):
- Check: TLOAD (100)
- Set: TSTORE (100)
- Clear: TSTORE (100)
- Total: 300 gas (73x cheaper!)
```
## References
* [EIP-1153: Transient storage opcodes](https://eips.ethereum.org/EIPS/eip-1153)
* [EVM Codes - TLOAD (0x5c)](https://www.evm.codes/#5c)
* [Cancun Upgrade](https://ethereum.org/en/history/cancun/)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)
# TSTORE (0x5d)
Source: https://voltaire.tevm.sh/evm/instructions/storage/tstore
Save word to transient storage (EIP-1153, Cancun, fixed 100 gas)
**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:** `0x5d`
**Introduced:** Cancun (EIP-1153)
TSTORE writes a 256-bit value to transient storage—a per-transaction key-value store that is automatically cleared when the transaction ends. Unlike persistent storage (SSTORE), transient storage:
* Costs only 100 gas (fixed, no complex gas metering)
* Is not persisted to blockchain state
* Cannot be read by external calls (isolated per transaction)
* Clears automatically at end of transaction
* Cannot be called in static call context (like SSTORE)
Primary use cases:
* Reentrancy guards (set/clear flags with minimal gas)
* Callback context passing within transaction
* Temporary counters and flags
* Efficient multi-call coordination
## Specification
**Stack Input:**
```
key (256-bit storage slot address)
value (256-bit value to store)
```
**Stack Output:**
```
(none - consumes both inputs)
```
**Gas Cost:** 100 (fixed, EIP-1153)
**Hardfork:** Cancun+ (unavailable on earlier hardforks)
**Operation:**
```
key = pop()
value = pop()
// Cannot be called in static context
if (isStatic) revert
transientStorage[msg.sender][key] = value
gasRemaining -= 100
```
## Behavior
TSTORE modifies an account's transient storage and guarantees cleanup:
1. **Check static call context** - Return WriteProtection error if in static context
2. **Pop key and value** from stack
3. **Consume 100 gas** (fixed, no refunds)
4. **Write to transient storage** via host
5. **Auto-clear on transaction end** (no cleanup needed)
6. **Increment PC**
### Transient Storage Scope
Transient storage is scoped to:
* **Per contract:** Each contract has separate transient storage
* **Per transaction:** Automatically cleared when transaction completes
* **Not persisted:** Does not affect blockchain state
* **Not observable:** External calls cannot access (isolated per call frame)
* **Static call protected:** Cannot write in static context
### Write Protection
TSTORE rejects writes in static call context (like SSTORE):
```javascript theme={null}
// In STATICCALL context
TSTORE(key, value) // WriteProtection error
```
## Examples
### Basic Transient Write
```typescript theme={null}
import { tstore } from '@voltaire/evm/storage';
import { createFrame } from '@voltaire/evm/Frame';
import { createMemoryHost } from '@voltaire/evm/Host';
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n], // [key, value]
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // null (success)
console.log(frame.gasRemaining); // 2900n (3000 - 100)
// Verify write
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: contractAddr,
});
tload(readFrame, host);
console.log(readFrame.stack); // [0x1337n]
```
### Reentrancy Guard Lock
```typescript theme={null}
// Set guard lock before external call
const guardKey = 0x01n;
const frame = createFrame({
stack: [guardKey, 0x1n], // [key, locked]
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // null
console.log(frame.gasRemaining); // 2900n
// Now TLOAD(0x01) in reentrant call returns locked
```
### Guard Unlock
```typescript theme={null}
// Clear guard after external call returns
const guardKey = 0x01n;
const frame = createFrame({
stack: [guardKey, 0n], // [key, unlocked]
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // null
console.log(frame.gasRemaining); // 2900n
```
### Multiple Values
```typescript theme={null}
// Store multiple transient values
const writes = [
{ key: 0x01n, value: 0xAAAAAn }, // FLAG
{ key: 0x02n, value: 0xBBBBBn }, // COUNTER
{ key: 0x03n, value: 0xCCCCCn }, // BALANCE
];
let remaining = 5000n;
for (const { key, value } of writes) {
const frame = createFrame({
stack: [key, value],
gasRemaining: remaining,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
if (error) {
console.error(`Failed: ${error.type}`);
break;
}
remaining -= 100n;
}
console.log(`Stored ${writes.length} values, gas remaining: ${remaining}`);
```
### Static Call Protection
```typescript theme={null}
// TSTORE fails in static call context
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 3000n,
address: contractAddr,
isStatic: true, // Static call
});
const error = tstore(frame, host);
console.log(error); // { type: "WriteProtection" }
console.log(frame.pc); // 0 (unchanged, not executed)
```
### Insufficient Gas
```typescript theme={null}
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 50n, // < 100
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // { type: "OutOfGas" }
console.log(frame.pc); // 0 (unchanged, not executed)
```
### Stack Underflow
```typescript theme={null}
const frame = createFrame({
stack: [0x42n], // Missing value
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // { type: "StackUnderflow" }
```
## Gas Cost
**Fixed Cost:** 100 gas (always)
| Operation | Cost | Notes |
| ------------- | ------------- | --------------------------- |
| TSTORE | 100 | Fixed, no refunds |
| SSTORE set | 20000 | New entry, 200x more |
| SSTORE update | 5000 | Existing entry, 50x more |
| SSTORE clear | 5000 + refund | With 4800 refund |
| MSTORE | 3 | 33x cheaper but memory-only |
**Comparison:**
```
TSTORE: 100 gas (transient, auto-cleanup)
SSTORE set: 20000 gas (persistent, complex)
SSTORE update: 5000 gas (persistent, still expensive)
MSTORE: 3 gas (memory, not persistent)
```
TSTORE provides an efficient middle ground for temporary state.
## Edge Cases
### Max Uint256 Value
```typescript theme={null}
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0x42n, MAX],
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(error); // null
// Verify stored
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 3000n,
address: contractAddr,
});
tload(readFrame, host);
console.log(readFrame.stack); // [MAX]
```
### Zero Value Write
```typescript theme={null}
// Writing 0 still costs 100 gas (no noop optimization)
const frame = createFrame({
stack: [0x42n, 0n], // [key, value=0]
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
const error = tstore(frame, host);
console.log(frame.gasRemaining); // 2900n (always 100 cost)
```
### Overwrite
```typescript theme={null}
// Writing again to same key just overwrites (100 gas)
const frame1 = createFrame({
stack: [0x42n, 0x1111n],
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
});
tstore(frame1, host);
const frame2 = createFrame({
stack: [0x42n, 0x2222n], // Overwrite
gasRemaining: 2900n,
address: contractAddr,
isStatic: false,
});
tstore(frame2, host);
// Reads 0x2222n now
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 2800n,
address: contractAddr,
});
tload(readFrame, host);
console.log(readFrame.stack); // [0x2222n]
```
### Hardfork Unavailable
```typescript theme={null}
// TSTORE not available before Cancun
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 3000n,
address: contractAddr,
isStatic: false,
hardfork: "Shanghai", // < Cancun
});
// Would need hardfork check
// const error = tstore(frame, host);
// console.log(error); // { type: "InvalidOpcode" }
```
## Common Usage
### Reentrancy Guard Implementation
```solidity theme={null}
// Complete reentrancy guard using TSTORE
contract ReentrancyGuard {
uint256 constant private LOCKED = 1;
modifier nonReentrant() {
// Check guard is unlocked
assembly {
if tload(0) {
revert(0, 0)
}
// Lock
tstore(0, LOCKED)
}
_;
// Unlock
assembly {
tstore(0, 0)
}
}
function safeSend(address recipient, uint256 amount)
public
nonReentrant
{
uint256 balance = balances[msg.sender];
require(balance >= amount);
balances[msg.sender] = balance - amount;
// Reentrancy window: attacker cannot re-enter due to guard
(bool ok, ) = recipient.call{value: amount}("");
require(ok);
}
}
```
**Gas savings:** 300 gas for guard (3 × TSTORE/TLOAD) vs 20000+ for persistent storage guard.
### Callback Context
```solidity theme={null}
// Pass context to called contracts via transient storage
contract Router {
function route(
address target,
bytes calldata data,
bytes calldata context
) public returns (bytes memory) {
// Store context for target
assembly {
let ctxPtr := mload(0x40)
calldatacopy(ctxPtr, context.offset, context.length)
tstore(0x01, ctxPtr)
}
// Target can read context with TLOAD
(bool ok, bytes memory result) = target.call(data);
require(ok);
// Context auto-cleared at transaction end
return result;
}
}
contract Handler {
function handle(bytes calldata data) external {
// Read context from caller
uint256 ctxPtr;
assembly {
ctxPtr := tload(0x01)
}
// Process data with context
_process(data, ctxPtr);
}
}
```
### Temporary Counter
```solidity theme={null}
// Efficient counter for batch operations
contract Batcher {
function batchProcess(
address[] calldata items,
bytes[] calldata operations
) public {
// Initialize counter in transient storage (100 gas)
assembly {
tstore(0x01, 0)
}
for (uint i = 0; i < items.length; i++) {
// Increment counter
assembly {
let count := tload(0x01)
tstore(0x01, add(count, 1))
}
// Process item
_process(items[i], operations[i]);
}
// Read final count
uint256 processed;
assembly {
processed := tload(0x01)
}
emit BatchCompleted(processed);
// Counter auto-cleared at transaction end
}
}
```
### State Accumulation
```solidity theme={null}
// Accumulate results across multiple calls
contract Accumulator {
function aggregate(
address[] calldata targets,
bytes[] calldata calls
) public returns (uint256 total) {
// Initialize accumulator
assembly {
tstore(0x01, 0)
}
for (uint i = 0; i < targets.length; i++) {
// Call target
(bool ok, bytes memory result) = targets[i].call(calls[i]);
require(ok);
// Accumulate result
uint256 value = abi.decode(result, (uint256));
assembly {
let acc := tload(0x01)
tstore(0x01, add(acc, value))
}
}
// Read final accumulated value
assembly {
total := tload(0x01)
}
}
}
```
## Implementation
```typescript theme={null}
import * as Frame from "../../Frame/index.js";
import { TStore } from "../../../primitives/GasConstants/BrandedGasConstants/constants.js";
/**
* TSTORE (0x5d) - Save word to transient storage
*
* Stack:
* in: key, value
* out: -
*
* Gas: 100 (fixed)
*
* EIP-1153: Transient storage opcodes (Cancun hardfork)
*/
export function tstore(frame, host) {
// Note: Add hardfork validation - TSTORE requires Cancun+
// if (hardfork < CANCUN) return { type: "InvalidOpcode" };
// EIP-1153: Cannot modify transient storage in static call
if (frame.isStatic) {
return { type: "WriteProtection" };
}
const gasError = Frame.consumeGas(frame, TStore);
if (gasError) return gasError;
// Pop key and value from stack
const keyResult = Frame.popStack(frame);
if (keyResult.error) return keyResult.error;
const key = keyResult.value;
const valueResult = Frame.popStack(frame);
if (valueResult.error) return valueResult.error;
const value = valueResult.value;
// Pending host integration: store to transient storage
// Real implementation: host.setTransientStorage(frame.address, key, value)
host.setTransientStorage(frame.address, key, value);
frame.pc += 1;
return null;
}
```
## Testing
### Test Coverage
```typescript theme={null}
import { describe, it, expect } from 'vitest';
import { tstore } from './0x5d_TSTORE.js';
import { tload } from './0x5c_TLOAD.js';
import { createFrame } from '../../Frame/index.js';
import { createMemoryHost } from '../../Host/createMemoryHost.js';
import { from as addressFrom } from '../../../primitives/Address/index.js';
describe('TSTORE (0x5d)', () => {
it('stores value to transient storage', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(900n); // 1000 - 100
expect(frame.pc).toBe(1);
// Verify stored
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0x1337n]);
});
it('overwrites existing transient value', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
// First write
let frame = createFrame({
stack: [0x42n, 0x1111n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Overwrite
frame = createFrame({
stack: [0x42n, 0x2222n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Verify overwritten
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0x2222n]);
});
it('consumes fixed 100 gas', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 5000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(4900n); // 5000 - 100 (always)
});
it('rejects write in static call', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 1000n,
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: true,
});
expect(tstore(frame, host)).toEqual({ type: "WriteProtection" });
expect(frame.pc).toBe(0); // Not executed
});
it('returns StackUnderflow on insufficient stack', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n], // Missing value
gasRemaining: 1000n,
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: false,
});
expect(tstore(frame, host)).toEqual({ type: "StackUnderflow" });
});
it('returns OutOfGas when insufficient gas', () => {
const host = createMemoryHost();
const frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 50n,
address: addressFrom("0x1234567890123456789012345678901234567890"),
isStatic: false,
});
expect(tstore(frame, host)).toEqual({ type: "OutOfGas" });
});
it('isolates transient storage by address', () => {
const host = createMemoryHost();
const addr1 = addressFrom("0x1111111111111111111111111111111111111111");
const addr2 = addressFrom("0x2222222222222222222222222222222222222222");
// Write to addr1
let frame = createFrame({
stack: [0x42n, 0xAAAAn],
gasRemaining: 1000n,
address: addr1,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Write to addr2 (same key)
frame = createFrame({
stack: [0x42n, 0xBBBBn],
gasRemaining: 1000n,
address: addr2,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Verify isolation
let readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr1,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0xAAAAn]);
readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr2,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0xBBBBn]);
});
it('stores max uint256 value', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
stack: [0x42n, MAX],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Verify
const readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([MAX]);
});
it('stores zero value', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
const frame = createFrame({
stack: [0x42n, 0n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
expect(frame.gasRemaining).toBe(900n); // Still costs 100
});
it('clears at transaction boundary', () => {
const host = createMemoryHost();
const addr = addressFrom("0x1234567890123456789012345678901234567890");
// Write value
let frame = createFrame({
stack: [0x42n, 0x1337n],
gasRemaining: 1000n,
address: addr,
isStatic: false,
});
expect(tstore(frame, host)).toBeNull();
// Read value (same transaction)
let readFrame = createFrame({
stack: [0x42n],
gasRemaining: 1000n,
address: addr,
});
expect(tload(readFrame, host)).toBeNull();
expect(readFrame.stack).toEqual([0x1337n]);
// After transaction boundary (auto-clear)
// host.endTransaction();
// readFrame = createFrame({
// stack: [0x42n],
// gasRemaining: 1000n,
// address: addr,
// });
// expect(tload(readFrame, host)).toBeNull();
// expect(readFrame.stack).toEqual([0n]);
});
});
```
## Security
### Write Protection in Static Calls
TSTORE correctly prevents all writes in `STATICCALL` context:
```solidity theme={null}
// SAFE: Read-only function
function getData() public view returns (uint256) {
uint256 value;
assembly {
value := tload(0x01) // Read-only, safe
}
return value;
}
// UNSAFE: Attempting write in view function
function badFunction() public view returns (uint256) {
assembly {
tstore(0x01, 42) // WriteProtection error
}
return 42;
}
```
### Reentrancy Guard Guarantees
Transient storage guards cannot be bypassed:
```solidity theme={null}
contract Guard {
function protected() public {
assembly {
// Guard must be clear
if tload(0) {
revert(0, 0)
}
// Lock guard
tstore(0, 1)
}
// Call external function
(bool ok, ) = msg.sender.call("");
// Even if call reverts, guard is locked
assembly {
// Unlock
tstore(0, 0)
}
}
}
// Attacker cannot bypass:
// - Cannot call protected() again (guard locked)
// - Cannot access transient storage from another contract
// - Guard auto-clears at transaction end (no lingering state)
```
### No State Leakage
Unlike persistent storage, transient storage doesn't leak state:
```solidity theme={null}
contract NoLeakage {
function operation() public {
assembly {
tstore(0x01, 42) // Temporary value
}
// Even if transaction reverts here:
revert("something");
// In next transaction: TLOAD(0x01) = 0
// No dangling state to clean up or cause issues
}
}
```
### Isolation Guarantees
Transient storage is strictly isolated:
```solidity theme={null}
// Contract A cannot read Contract B's transient storage
contract A {
function tryRead() public {
uint256 value;
assembly {
value := tload(0x01) // Reads A's transient storage only
}
// Cannot access B's TSTORE values via staticcall or delegatecall
}
}
```
## Benchmarks
**Storage write costs:**
* TSTORE: 100 gas (fixed)
* SSTORE set: 20000 gas (200x more)
* SSTORE update: 5000 gas (50x more)
* MSTORE: 3 gas (33x cheaper but memory-only)
**Reentrancy guard comparison:**
| Approach | Cost | Cleanup | Notes |
| ------------ | --------- | ------- | ------------------------ |
| TSTORE guard | 300 gas | Auto | Recommended (EIP-1153) |
| SSTORE guard | 20000+ | Manual | Expensive, complex |
| OpenZeppelin | 3500+ gas | Manual | Library overhead |
| No guard | 0 gas | N/A | Vulnerable to reentrancy |
## References
* [EIP-1153: Transient storage opcodes](https://eips.ethereum.org/EIPS/eip-1153)
* [EVM Codes - TSTORE (0x5d)](https://www.evm.codes/#5d)
* [Cancun Upgrade](https://ethereum.org/en/history/cancun/)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)
# CALL (0xf1)
Source: https://voltaire.tevm.sh/evm/instructions/system/call
External message call with value transfer and full state modification access
**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:** `0xf1`
**Introduced:** Frontier (EVM genesis)
CALL executes code from another account with specified gas, value, and calldata. The callee runs in its own context with `msg.sender` set to the caller and `msg.value` to the transferred amount. This is the primary mechanism for inter-contract communication.
## Specification
**Stack Input:**
```
gas (max gas to forward)
address (target account to call)
value (wei to send)
inOffset (calldata memory offset)
inLength (calldata size)
outOffset (returndata memory offset)
outLength (returndata size)
```
**Stack Output:**
```
success (1 if call succeeded, 0 if failed)
```
**Gas Cost:** 700 + value\_transfer + new\_account + cold\_access + memory\_expansion
**Operation:**
```
calldata = memory[inOffset:inOffset+inLength]
success = external_call(address, value, calldata, gas * 63/64)
memory[outOffset:outOffset+outLength] = returndata[0:min(outLength, returndata.length)]
push(success)
```
## Behavior
CALL performs a nested execution in the target account's context:
1. **Pop 7 stack arguments** in order: gas, address, value, inOffset, inLength, outOffset, outLength
2. **Validate static context:** Cannot transfer value in static call (EIP-214)
3. **Calculate gas cost:**
* Base: 700 gas (Tangerine Whistle+)
* Value transfer: +9,000 gas if value > 0
* New account: +25,000 gas if recipient doesn't exist and value > 0
* Cold access: +2,600 gas for first access (Berlin+)
* Memory expansion for both input and output regions
4. **Read calldata** from memory at inOffset:inLength
5. **Forward gas:** Up to 63/64 of remaining gas after charging (EIP-150)
6. **Execute in callee context:**
* msg.sender = caller address
* msg.value = transferred value
* Storage = callee's storage
* Code = callee's code
7. **Transfer value:** Move ETH from caller to callee (if value > 0)
8. **Copy returndata** to memory at outOffset (up to min(outLength, returndata.length))
9. **Set return\_data** buffer to full returndata
10. **Push success flag** (1 if succeeded, 0 if reverted/failed)
11. **Refund unused gas** from child execution
**Key rules:**
* Callee stipend: +2,300 gas (free) if value > 0 for receive/fallback execution
* Cannot be called with value in static context (EIP-214)
* Success flag pushed even if call reverts (caller continues execution)
* Returndata accessible via RETURNDATASIZE/RETURNDATACOPY
* Call depth limited to 1,024 (pre-Tangerine Whistle enforcement)
## Examples
### Basic External Call
```typescript theme={null}
import { CALL } from '@tevm/voltaire/evm/system';
import { createFrame } from '@tevm/voltaire/evm/Frame';
import { Address } from '@tevm/voltaire/primitives';
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
});
// Calldata: function selector for "transfer(address,uint256)"
const calldata = new Uint8Array([
0xa9, 0x05, 0x9c, 0xbb, // keccak256("transfer(address,uint256)")[:4]
// ... ABI-encoded parameters
]);
// Write calldata to memory
for (let i = 0; i < calldata.length; i++) {
frame.memory.set(i, calldata[i]);
}
// Stack: [gas=100000, address, value=0, inOffset=0, inLength=68, outOffset=0, outLength=32]
frame.stack.push(32n); // outLength
frame.stack.push(0n); // outOffset
frame.stack.push(68n); // inLength
frame.stack.push(0n); // inOffset
frame.stack.push(0n); // value
frame.stack.push(BigInt("0x742d35Cc...")); // address
frame.stack.push(100000n); // gas
const err = CALL(frame);
console.log(err); // null (success)
console.log(frame.stack[0]); // 1n (call succeeded) or 0n (call failed)
console.log(frame.return_data); // Returndata from callee
```
### Value Transfer Call
```typescript theme={null}
import { Address } from '@tevm/voltaire/primitives';
// Send 1 ETH to address with empty calldata
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
});
// Stack: [gas=50000, address, value=1 ETH, inOffset=0, inLength=0, outOffset=0, outLength=0]
frame.stack.push(0n); // outLength
frame.stack.push(0n); // outOffset
frame.stack.push(0n); // inLength
frame.stack.push(0n); // inOffset
frame.stack.push(1_000_000_000_000_000_000n); // value (1 ETH)
frame.stack.push(BigInt("0x742d35Cc...")); // recipient
frame.stack.push(50000n); // gas
const err = CALL(frame);
// Check success
if (frame.stack[0] === 1n) {
console.log("Transfer succeeded");
} else {
console.log("Transfer failed:", frame.return_data);
}
```
### Safe External Call Pattern
```solidity theme={null}
contract Caller {
event CallResult(bool success, bytes returnData);
// Safe external call with error handling
function safeCall(
address target,
uint256 value,
bytes memory data
) external returns (bool success, bytes memory returnData) {
// Limit gas to prevent griefing (retain 1/64 for post-call logic)
uint256 gasToForward = gasleft() * 63 / 64;
assembly {
// CALL(gas, address, value, inOffset, inLength, outOffset, outLength)
success := call(
gasToForward,
target,
value,
add(data, 0x20), // Skip length prefix
mload(data), // Data length
0, // Don't copy to memory yet
0
)
// Copy returndata
let size := returndatasize()
returnData := mload(0x40) // Free memory pointer
mstore(returnData, size) // Store length
returndatacopy(add(returnData, 0x20), 0, size)
mstore(0x40, add(add(returnData, 0x20), size)) // Update free pointer
}
emit CallResult(success, returnData);
return (success, returnData);
}
// Revert if call fails
function strictCall(address target, bytes memory data) external payable {
(bool success, bytes memory returnData) = target.call{value: msg.value}(data);
if (!success) {
// Bubble up revert reason
assembly {
revert(add(returnData, 32), mload(returnData))
}
}
}
}
```
### Token Transfer Example
```solidity theme={null}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract TokenCaller {
// Call ERC20.transfer using CALL opcode
function transferTokens(
address token,
address recipient,
uint256 amount
) external returns (bool) {
// ABI encode: transfer(address,uint256)
bytes memory callData = abi.encodeWithSelector(
IERC20.transfer.selector,
recipient,
amount
);
bool success;
bytes memory returnData;
assembly {
// CALL with no value transfer
success := call(
gas(), // Forward all gas
token, // Target contract
0, // No ETH sent
add(callData, 0x20), // Calldata location
mload(callData), // Calldata length
0, // Return data location
0 // Return data length
)
// Copy return data
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
returndatacopy(add(returnData, 0x20), 0, size)
mstore(0x40, add(add(returnData, 0x20), size))
}
// Decode return value (bool)
require(success && returnData.length >= 32, "Transfer failed");
return abi.decode(returnData, (bool));
}
}
```
## Gas Cost
**Total cost:** 700 + value\_transfer + new\_account + cold\_access + memory\_expansion + forwarded\_gas
### Base Cost: 700 gas (Tangerine Whistle+)
**Pre-Tangerine Whistle:** 40 gas
### Value Transfer: +9,000 gas
Charged when `value > 0`:
```
if (value > 0) {
cost += 9000 // CallValueTransferGas
}
```
**Stipend:** Callee receives additional +2,300 gas (free to caller) for receive/fallback execution.
### New Account: +25,000 gas
Charged when sending value to non-existent account:
```
if (value > 0 && !accountExists(address)) {
cost += 25000 // CallNewAccountGas
}
```
**Account exists if:** balance > 0 OR code.length > 0 OR nonce > 0
### Cold Access: +2,600 gas (Berlin+)
**EIP-2929 (Berlin+):** First access to address in transaction:
```
if (firstAccess(address)) {
cost += 2600 // ColdAccountAccess
} else {
cost += 100 // WarmStorageRead
}
```
**Pre-Berlin:** No access list costs.
### Memory Expansion
Dynamic cost for both input and output regions:
```typescript theme={null}
const inEnd = inOffset + inLength;
const outEnd = outOffset + outLength;
const maxEnd = Math.max(inEnd, outEnd);
const words = Math.ceil(maxEnd / 32);
const expansionCost = words ** 2 / 512 + 3 * words;
```
### Gas Forwarding (EIP-150)
**Tangerine Whistle+:** Caller retains 1/64th, forwards up to 63/64:
```
remaining_after_charge = gas_remaining - base_cost
max_forwarded = remaining_after_charge - (remaining_after_charge / 64)
actual_forwarded = min(gas_parameter, max_forwarded)
```
**Pre-Tangerine Whistle:** Forward all remaining gas.
### Example Calculation
```typescript theme={null}
// Call external contract with value, cold access, memory expansion
const gasRemaining = 100000n;
const value = 1_000_000_000_000_000_000n; // 1 ETH
const inLength = 68; // Function call with parameters
const outLength = 32; // Return value
// Base cost
let cost = 700n; // Tangerine Whistle+
// Value transfer
cost += 9000n; // CallValueTransferGas
// New account (assume account doesn't exist)
cost += 25000n; // CallNewAccountGas
// Cold access (Berlin+, first access)
cost += 2600n; // ColdAccountAccess
// Memory expansion (assume clean memory)
const maxEnd = Math.max(68, 32); // 68 bytes
const words = Math.ceil(68 / 32); // 3 words
const memCost = Math.floor(words ** 2 / 512) + 3 * words; // 9 gas
cost += BigInt(memCost);
// Total charged: 37,309 gas
// Gas forwarding (63/64 rule)
const afterCharge = gasRemaining - cost; // 62,691 gas
const maxForward = afterCharge - afterCharge / 64n; // 61,711 gas
// Forward min(gas_param, max_forward)
// Total consumed: 37,309 + gas_actually_used_by_callee
```
## Common Usage
### Reentrancy Guard
```solidity theme={null}
contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() {
require(locked == 1, "Reentrancy");
locked = 2;
_;
locked = 1;
}
// Safe withdrawal with reentrancy protection
function withdraw(uint256 amount) external nonReentrant {
require(balances[msg.sender] >= amount);
// Update state BEFORE external call
balances[msg.sender] -= amount;
// External call (potential reentrancy point)
(bool success, ) = msg.sender.call{value: amount}("");
require(success, "Transfer failed");
}
}
```
### Multicall Pattern
```solidity theme={null}
contract Multicall {
struct Call {
address target;
bytes callData;
}
struct Result {
bool success;
bytes returnData;
}
// Execute multiple calls in single transaction
function aggregate(Call[] memory calls) external returns (Result[] memory results) {
results = new Result[](calls.length);
for (uint256 i = 0; i < calls.length; i++) {
(bool success, bytes memory returnData) = calls[i].target.call(calls[i].callData);
results[i] = Result(success, returnData);
}
}
// Execute multiple calls, revert if any fails
function tryAggregate(Call[] memory calls) external returns (bytes[] memory returnData) {
returnData = new bytes[](calls.length);
for (uint256 i = 0; i < calls.length; i++) {
(bool success, bytes memory data) = calls[i].target.call(calls[i].callData);
require(success, "Call failed");
returnData[i] = data;
}
}
}
```
### Router Pattern
```solidity theme={null}
contract Router {
// Route call to appropriate handler based on selector
function route(address target, bytes memory data) external payable returns (bytes memory) {
require(data.length >= 4, "Invalid calldata");
// Extract function selector
bytes4 selector;
assembly {
selector := mload(add(data, 32))
}
// Validate selector against whitelist
require(isAllowed(selector), "Selector not allowed");
// Forward call
(bool success, bytes memory returnData) = target.call{value: msg.value}(data);
if (!success) {
assembly {
revert(add(returnData, 32), mload(returnData))
}
}
return returnData;
}
function isAllowed(bytes4 selector) internal pure returns (bool) {
// Whitelist logic
return true;
}
}
```
## Security
### Reentrancy Attacks
CALL's primary security risk - external code can re-enter caller:
```solidity theme={null}
// VULNERABLE: DAO hack pattern
contract Vulnerable {
mapping(address => uint256) public balances;
function withdraw() external {
uint256 amount = balances[msg.sender];
require(amount > 0);
// VULNERABILITY: External call before state update
(bool success, ) = msg.sender.call{value: amount}("");
require(success);
balances[msg.sender] = 0; // Too late! Already re-entered
}
}
contract Attacker {
Vulnerable victim;
uint256 public attackCount;
receive() external payable {
// Re-enter during CALL
if (attackCount < 10) {
attackCount++;
victim.withdraw(); // Drain funds
}
}
}
```
**Mitigation: Checks-Effects-Interactions pattern:**
```solidity theme={null}
// SAFE: State updates before external calls
function withdraw() external {
uint256 amount = balances[msg.sender];
require(amount > 0);
// Update state FIRST
balances[msg.sender] = 0;
// External call LAST
(bool success, ) = msg.sender.call{value: amount}("");
require(success);
}
```
### Return Value Check
Must check success flag - call can fail silently:
```solidity theme={null}
// VULNERABLE: Ignoring return value
function unsafeTransfer(address to, uint256 amount) external {
// Assumes success, but call might fail!
to.call{value: amount}("");
}
// SAFE: Check return value
function safeTransfer(address to, uint256 amount) external {
(bool success, ) = to.call{value: amount}("");
require(success, "Transfer failed");
}
```
### Gas Griefing
Callee controls gas consumption:
```solidity theme={null}
// VULNERABLE: Unbounded gas consumption
function dangerousCall(address target, bytes memory data) external {
// Forwards 63/64 of all remaining gas!
target.call(data); // Callee can consume all gas
}
// BETTER: Limit forwarded gas
function limitedCall(address target, bytes memory data) external {
// Limit gas to specific amount
target.call{gas: 100000}(data);
}
```
### Returndata Bomb
Large returndata can cause OOG when copying:
```solidity theme={null}
// VULNERABLE: Unbounded returndata copy
function unsafeCopy(address target) external returns (bytes memory) {
(bool success, bytes memory data) = target.call("");
return data; // Might copy gigabytes!
}
// SAFE: Limit returndata size
function safeCopy(address target) external returns (bytes memory) {
(bool success, ) = target.call("");
require(success);
// Manual copy with size limit
uint256 size = min(returndatasize(), 1024);
bytes memory data = new bytes(size);
assembly {
returndatacopy(add(data, 32), 0, size)
}
return data;
}
```
### Value Transfer Validation
Ensure sufficient balance before value transfer:
```solidity theme={null}
// VULNERABLE: No balance check
function unsafeSend(address to, uint256 amount) external {
to.call{value: amount}(""); // Reverts if insufficient balance
}
// SAFE: Explicit balance validation
function safeSend(address to, uint256 amount) external {
require(address(this).balance >= amount, "Insufficient balance");
(bool success, ) = to.call{value: amount}("");
require(success, "Transfer failed");
}
```
## Implementation
```typescript theme={null}
/**
* CALL opcode (0xf1) - Message call into an account
*/
export function call(frame: FrameType): EvmError | null {
// Pop 7 arguments
const gas = popStack(frame);
const address = popStack(frame);
const value = popStack(frame);
const inOffset = popStack(frame);
const inLength = popStack(frame);
const outOffset = popStack(frame);
const outLength = popStack(frame);
// EIP-214: Cannot transfer value in static context
if (frame.isStatic && value > 0n) {
return { type: "WriteProtection" };
}
// Calculate gas cost
let gasCost = 700n; // Base (Tangerine Whistle+)
// Value transfer
if (value > 0n) {
gasCost += 9000n; // CallValueTransferGas
// Check if account exists
const exists = accountExists(address);
if (!exists) {
gasCost += 25000n; // CallNewAccountGas
}
}
// Cold access cost (Berlin+)
const accessCost = getAccessCost(address);
gasCost += accessCost;
// Memory expansion
const inEnd = inLength > 0 ? inOffset + inLength : 0;
const outEnd = outLength > 0 ? outOffset + outLength : 0;
const maxEnd = Math.max(inEnd, outEnd);
if (maxEnd > 0) {
gasCost += memoryExpansionCost(frame, maxEnd);
updateMemorySize(frame, maxEnd);
}
// Calculate forwarded gas (63/64 rule)
const afterCharge = frame.gasRemaining - gasCost;
const maxForward = afterCharge - afterCharge / 64n;
const forwardedGas = min(gas, maxForward);
// Charge total cost
consumeGas(frame, gasCost + forwardedGas);
// Read calldata
const calldata = readMemory(frame, inOffset, inLength);
// Execute call
const result = executeCall({
target: address,
value: value,
data: calldata,
gas: forwardedGas
});
// Refund unused gas
frame.gasRemaining += result.gasLeft;
// Copy returndata to memory
const copySize = min(outLength, result.returnData.length);
writeMemory(frame, outOffset, result.returnData.slice(0, copySize));
// Set return_data buffer
frame.returnData = result.returnData;
// Push success flag
pushStack(frame, result.success ? 1n : 0n);
frame.pc += 1;
return null;
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.4.4 (Message Call)
* **[EIP-150](https://eips.ethereum.org/EIPS/eip-150)** - Gas cost changes (63/64 rule)
* **[EIP-214](https://eips.ethereum.org/EIPS/eip-214)** - STATICCALL and static context
* **[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)** - Access list gas costs
* **[evm.codes - CALL](https://www.evm.codes/#f1)** - Interactive reference
* **[Consensys Best Practices](https://consensys.github.io/smart-contract-best-practices/)** - Reentrancy patterns
# CALLCODE (0xf2)
Source: https://voltaire.tevm.sh/evm/instructions/system/callcode
Execute code in current context - DEPRECATED, use DELEGATECALL instead
**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:** `0xf2`
**Introduced:** Frontier (EVM genesis)
**Status:** DEPRECATED - Use DELEGATECALL (0xf4) instead
CALLCODE executes code from another account in the caller's storage context. Unlike CALL, storage modifications affect the caller. This opcode has confusing semantics and was superseded by DELEGATECALL in Homestead.
**WARNING:** CALLCODE is deprecated and should not be used in new contracts. Use DELEGATECALL for library calls and code reuse patterns.
## Specification
**Stack Input:**
```
gas (max gas to forward)
address (target account code to execute)
value (wei to send to caller's own address)
inOffset (calldata memory offset)
inLength (calldata size)
outOffset (returndata memory offset)
outLength (returndata size)
```
**Stack Output:**
```
success (1 if call succeeded, 0 if failed)
```
**Gas Cost:** 700 + value\_transfer + cold\_access + memory\_expansion
**Operation:**
```
calldata = memory[inOffset:inOffset+inLength]
success = execute_code_in_caller_context(address.code, value, calldata, gas * 63/64)
memory[outOffset:outOffset+outLength] = returndata[0:min(outLength, returndata.length)]
push(success)
```
## Behavior
CALLCODE executes foreign code with confusing context semantics:
1. **Pop 7 stack arguments** (same as CALL)
2. **Calculate gas cost:**
* Base: 700 gas (Tangerine Whistle+)
* Value transfer: +9,000 gas if value > 0
* Cold access: +2,600 gas for first access (Berlin+)
* Memory expansion for input and output regions
3. **Read calldata** from memory
4. **Forward gas:** Up to 63/64 of remaining gas (EIP-150)
5. **Execute target's code in caller's context:**
* msg.sender = caller (NOT preserved from parent!)
* msg.value = specified value
* Storage = caller's storage (modifications affect caller!)
* Code = target's code
* address(this) = caller's address
6. **Value handling:** ETH sent to caller's own address (weird!)
7. **Copy returndata** to memory
8. **Push success flag**
**Key differences from CALL:**
* Storage operations affect caller, not target
* msg.sender is caller (not preserved from parent)
* Value sent to caller's own address
**Key differences from DELEGATECALL:**
* msg.sender is caller (DELEGATECALL preserves original sender)
* msg.value is specified value (DELEGATECALL preserves original value)
* Value handling is confusing
## Examples
### Basic CALLCODE (Don't Do This!)
```typescript theme={null}
import { CALLCODE } from '@tevm/voltaire/evm/system';
// DON'T USE - deprecated opcode
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
});
// Stack: [gas=100000, address, value=0, inOffset=0, inLength=0, outOffset=0, outLength=0]
frame.stack.push(0n); // outLength
frame.stack.push(0n); // outOffset
frame.stack.push(0n); // inLength
frame.stack.push(0n); // inOffset
frame.stack.push(0n); // value
frame.stack.push(BigInt("0x742d35Cc...")); // address (code source)
frame.stack.push(100000n); // gas
// USE DELEGATECALL INSTEAD!
```
### Why CALLCODE is Confusing
```solidity theme={null}
contract Library {
uint256 public value;
function setValue(uint256 _value) external {
value = _value; // Modifies storage at slot 0
}
}
contract Caller {
uint256 public myValue; // Storage slot 0
function useCallCode(address library) external {
// CALLCODE execution context:
// - msg.sender = address(this) (NOT tx.origin!)
// - msg.value = sent value
// - storage = Caller's storage
// - code = Library's code
assembly {
let success := callcode(
gas(),
library,
0, // Value sent to self (weird!)
0, // calldata
0,
0, // returndata
0
)
}
// Library's setValue modified Caller.myValue!
// But msg.sender in Library was Caller, not original caller
}
}
```
### Correct Pattern: Use DELEGATECALL
```solidity theme={null}
contract Library {
uint256 public value;
function setValue(uint256 _value) external {
value = _value;
}
}
contract Caller {
uint256 public myValue;
// ✅ CORRECT: Use DELEGATECALL
function useDelegateCall(address library) external {
// DELEGATECALL execution context:
// - msg.sender = original caller (preserved!)
// - msg.value = original value (preserved!)
// - storage = Caller's storage
// - code = Library's code
(bool success, ) = library.delegatecall(
abi.encodeWithSignature("setValue(uint256)", 42)
);
require(success);
// Clear semantics: Library code runs as if part of Caller
}
}
```
### Migration Example
```solidity theme={null}
// ❌ OLD: Using CALLCODE (deprecated)
contract OldPattern {
function callLibrary(address lib, bytes memory data) external {
assembly {
let success := callcode(
gas(),
lib,
0,
add(data, 0x20),
mload(data),
0,
0
)
if iszero(success) { revert(0, 0) }
}
}
}
// ✅ NEW: Using DELEGATECALL
contract NewPattern {
function callLibrary(address lib, bytes memory data) external {
(bool success, ) = lib.delegatecall(data);
require(success, "Delegatecall failed");
}
}
```
## Gas Cost
**Total cost:** 700 + value\_transfer + cold\_access + memory\_expansion + forwarded\_gas
### Base Cost: 700 gas (Tangerine Whistle+)
**Pre-Tangerine Whistle:** 40 gas
### Value Transfer: +9,000 gas
Charged when `value > 0` (even though value sent to self):
```
if (value > 0) {
cost += 9000 // CallValueTransferGas
}
```
**Note:** No new account cost - value sent to caller's own address.
### Cold Access: +2,600 gas (Berlin+)
**EIP-2929 (Berlin+):** First access to target address:
```
if (firstAccess(address)) {
cost += 2600 // ColdAccountAccess
} else {
cost += 100 // WarmStorageRead
}
```
### Memory Expansion
Same as CALL - charges for both input and output regions.
### Gas Forwarding
Same as CALL - 63/64 rule applies (EIP-150).
## Common Usage
**None - this opcode is deprecated.**
Historical uses included:
* Library pattern (replaced by DELEGATECALL)
* Code reuse (replaced by DELEGATECALL)
* Upgradeable contracts (replaced by DELEGATECALL + proxy patterns)
## Security
### Deprecated - Do Not Use
The primary security issue with CALLCODE is that it should not be used at all. Use DELEGATECALL instead.
### Confusing msg.sender Semantics
CALLCODE sets `msg.sender` to the caller, not the original transaction sender:
```solidity theme={null}
// VULNERABLE: Unexpected msg.sender
contract VulnerableAuth {
address public owner;
constructor() {
owner = msg.sender;
}
function updateOwner(address newOwner) external {
// Assumes msg.sender is the transaction sender
require(msg.sender == owner);
owner = newOwner;
}
}
contract Attacker {
function exploit(address vulnerable, address lib) external {
// Call library code via CALLCODE
assembly {
// In library code, msg.sender will be Attacker contract
// NOT the original transaction sender!
callcode(gas(), lib, 0, 0, 0, 0, 0)
}
}
}
```
### Storage Collision
Same storage collision risks as DELEGATECALL:
```solidity theme={null}
contract Library {
address public implementation; // Slot 0
function upgrade(address newImpl) external {
implementation = newImpl;
}
}
contract Caller {
address public owner; // Slot 0 - COLLISION!
function callLibrary(address lib) external {
assembly {
callcode(gas(), lib, 0, 0, 0, 0, 0)
}
// Library modified Caller.owner instead of implementation!
}
}
```
### Value Transfer Confusion
Value sent to caller's own address creates confusing semantics:
```solidity theme={null}
contract ConfusingValue {
function sendToSelf() external payable {
assembly {
// This sends msg.value to self - pointless!
callcode(gas(), target, callvalue(), 0, 0, 0, 0)
}
}
}
```
## Why DELEGATECALL is Better
| Aspect | CALLCODE | DELEGATECALL |
| -------------- | ------------------ | ---------------------- |
| msg.sender | Caller (confusing) | Preserved (clear) |
| msg.value | Specified value | Preserved (clear) |
| Value transfer | To self (weird) | No value transfer |
| Use case | NONE (deprecated) | Library calls, proxies |
| Introduced | Frontier | Homestead (EIP-7) |
| Status | Deprecated | Standard |
**DELEGATECALL advantages:**
* Preserves full execution context (msg.sender, msg.value)
* Clear semantics for library pattern
* No confusing value-to-self transfers
* Industry standard for proxies and libraries
## Implementation
```typescript theme={null}
/**
* CALLCODE opcode (0xf2) - DEPRECATED
* Execute code in current context
*/
export function callcode(frame: FrameType): EvmError | null {
// Pop 7 arguments (same as CALL)
const gas = popStack(frame);
const address = popStack(frame);
const value = popStack(frame);
const inOffset = popStack(frame);
const inLength = popStack(frame);
const outOffset = popStack(frame);
const outLength = popStack(frame);
// Calculate gas cost
let gasCost = 700n; // Base (Tangerine Whistle+)
// Value transfer (even though to self)
if (value > 0n) {
gasCost += 9000n;
// No new account cost - value sent to self
}
// Cold access cost (Berlin+)
const accessCost = getAccessCost(address);
gasCost += accessCost;
// Memory expansion
const inEnd = inLength > 0 ? inOffset + inLength : 0;
const outEnd = outLength > 0 ? outOffset + outLength : 0;
const maxEnd = Math.max(inEnd, outEnd);
if (maxEnd > 0) {
gasCost += memoryExpansionCost(frame, maxEnd);
updateMemorySize(frame, maxEnd);
}
// Calculate forwarded gas (63/64 rule)
const afterCharge = frame.gasRemaining - gasCost;
const maxForward = afterCharge - afterCharge / 64n;
const forwardedGas = min(gas, maxForward);
// Charge total cost
consumeGas(frame, gasCost + forwardedGas);
// Read calldata
const calldata = readMemory(frame, inOffset, inLength);
// Execute in caller context with target's code
const result = executeCallCode({
codeAddress: address, // Code to execute
storageAddress: frame.address, // Storage to modify
sender: frame.address, // msg.sender = caller
value: value, // msg.value = specified
data: calldata,
gas: forwardedGas
});
// Refund unused gas
frame.gasRemaining += result.gasLeft;
// Copy returndata
const copySize = min(outLength, result.returnData.length);
writeMemory(frame, outOffset, result.returnData.slice(0, copySize));
// Set return_data buffer
frame.returnData = result.returnData;
// Push success flag
pushStack(frame, result.success ? 1n : 0n);
frame.pc += 1;
return null;
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.4.4 (CALLCODE)
* **[EIP-7](https://eips.ethereum.org/EIPS/eip-7)** - DELEGATECALL (replacement)
* **[evm.codes - CALLCODE](https://www.evm.codes/#f2)** - Interactive reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - Deprecation notice
# CREATE (0xf0)
Source: https://voltaire.tevm.sh/evm/instructions/system/create
Create new contract with computed address based on sender and nonce
**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:** `0xf0`
**Introduced:** Frontier (EVM genesis)
CREATE deploys a new contract by executing initialization code and storing the resulting runtime bytecode. The new contract's address is deterministically computed from the creator's address and nonce.
## Specification
**Stack Input:**
```
value (wei to send)
offset (memory offset of init code)
length (size of init code)
```
**Stack Output:**
```
address (deployed contract address, or 0 if failed)
```
**Gas Cost:** 32,000 + init\_code\_cost + memory\_expansion + deployment\_cost
**Operation:**
```
address = keccak256(rlp([sender_address, sender_nonce]))[12:]
success = deploy(address, init_code, value, gas * 63/64)
push(success ? address : 0)
```
## Behavior
CREATE executes a multi-step deployment process:
1. **Pop stack arguments:** value, memory offset, length
2. **Charge gas:** Base 32,000 + init code cost + memory expansion
3. **Read init code** from memory at offset:length
4. **Compute address:** `keccak256(rlp([sender, nonce]))[12:]`
5. **Forward gas:** Up to 63/64 of remaining gas (EIP-150)
6. **Execute init code** in new context with forwarded gas
7. **Store runtime code** returned by init code (charged 200 gas/byte)
8. **Push address** to stack (0 if deployment failed)
9. **Refund unused gas** from child execution
10. **Clear return\_data** on success, set to child output on failure
**Key rules:**
* Cannot be called in static context (EIP-214)
* Init code executes with empty storage/code
* Nonce incremented before address computation
* Init code size limited to 49,152 bytes (EIP-3860)
* Runtime code size limited to 24,576 bytes (EIP-170)
## Examples
### Basic Contract Creation
```typescript theme={null}
import { CREATE } from '@tevm/voltaire/evm/system';
import { createFrame } from '@tevm/voltaire/evm/Frame';
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
nonce: 5n
});
// Init code: PUSH1 0x42 PUSH1 0x00 MSTORE PUSH1 0x01 PUSH1 0x1f RETURN
// Returns single byte: 0x42
const initCode = Bytecode([
0x60, 0x42, // PUSH1 0x42
0x60, 0x00, // PUSH1 0x00
0x52, // MSTORE
0x60, 0x01, // PUSH1 0x01 (length)
0x60, 0x1f, // PUSH1 0x1f (offset)
0xf3 // RETURN
]);
// Write init code to memory
for (let i = 0; i < initCode.length; i++) {
frame.memory.set(i, initCode[i]);
}
// Stack: [value=0, offset=0, length=9]
frame.stack.push(9n); // length
frame.stack.push(0n); // offset
frame.stack.push(0n); // value
const err = CREATE(frame);
console.log(err); // null (success)
console.log(frame.stack[0]); // address (non-zero if successful)
console.log(frame.return_data); // empty on success
```
### Address Prediction
```typescript theme={null}
import { Address } from '@tevm/voltaire/primitives';
import { keccak256 } from '@tevm/voltaire/crypto';
import { RLP } from '@tevm/voltaire/primitives';
function predictAddress(creator: Address, nonce: bigint): Address {
// CREATE address = keccak256(rlp([sender, nonce]))[12:]
const encoded = RLP.encode([
creator,
nonce
]);
const hash = keccak256(encoded);
return Address(hash.slice(12));
}
const creator = Address("0x742d35Cc6634C0532925a3b844Bc454e4438f44e");
const nonce = 5n;
const predictedAddr = predictAddress(creator, nonce);
console.log(predictedAddr); // Address where contract will be deployed
```
### Factory Contract
```solidity theme={null}
contract Factory {
event Deployed(address indexed contractAddress, address indexed creator);
// Deploy new contract and return address
function deployContract(bytes memory initCode) external returns (address) {
address contractAddr;
assembly {
// CREATE(value, offset, length)
contractAddr := create(
0, // No ETH sent
add(initCode, 0x20), // Skip length prefix
mload(initCode) // Init code length
)
// Revert if deployment failed
if iszero(contractAddr) {
revert(0, 0)
}
}
emit Deployed(contractAddr, msg.sender);
return contractAddr;
}
// Predict next deployment address
function predictNextAddress() external view returns (address) {
// Address of this contract
address factory = address(this);
// Next nonce will be current nonce + 1
uint256 nonce = vm.getNonce(factory) + 1;
// Compute CREATE address
return address(uint160(uint256(keccak256(abi.encodePacked(
bytes1(0xd6), // RLP prefix for [address, nonce] with nonce < 128
bytes1(0x94), // RLP prefix for 20-byte address
factory,
bytes1(uint8(nonce))
)))));
}
}
```
### Constructor with Arguments
```solidity theme={null}
contract Example {
uint256 public value;
address public owner;
constructor(uint256 _value) {
value = _value;
owner = msg.sender;
}
}
contract Deployer {
function deploy(uint256 constructorArg) external returns (address) {
// Get creation bytecode with encoded constructor args
bytes memory bytecode = abi.encodePacked(
type(Example).creationCode,
abi.encode(constructorArg)
);
address deployed;
assembly {
deployed := create(0, add(bytecode, 32), mload(bytecode))
}
return deployed;
}
}
```
## Gas Cost
**Total cost:** 32,000 + init\_code\_cost + memory\_expansion + deployment\_cost
### Base Cost: 32,000 gas
Fixed cost for CREATE operation.
### Init Code Cost (EIP-3860)
**Shanghai+:** 2 gas per word (32 bytes)
```
init_code_cost = 2 * ceil(init_code_length / 32)
```
**Pre-Shanghai:** No init code cost.
### Memory Expansion
Dynamic cost for reading init code from memory:
```
words_needed = ceil((offset + length) / 32)
expansion_cost = (words_needed)² / 512 + 3 * (words_needed - current_words)
```
### Deployment Cost
**Runtime code storage:** 200 gas per byte of returned code
```
deployment_cost = 200 * runtime_code_length
```
### Gas Forwarding (EIP-150)
**Tangerine Whistle+:** Forward up to 63/64 of remaining gas:
```
gas_after_charge = remaining_gas - total_cost
max_forwarded = gas_after_charge - (gas_after_charge / 64)
```
**Pre-Tangerine Whistle:** Forward all remaining gas after charging.
### Example Calculation
```typescript theme={null}
// Deploy contract with 100-byte init code, returns 50-byte runtime code
const initCodeLength = 100;
const runtimeCodeLength = 50;
// Base cost
const baseCost = 32000;
// Init code cost (Shanghai+): 2 gas/word
const initCodeWords = Math.ceil(initCodeLength / 32); // 4 words
const initCodeCost = 2 * initCodeWords; // 8 gas
// Memory expansion (assume clean memory)
const memWords = Math.ceil(initCodeLength / 32); // 4 words
const memCost = Math.floor(memWords ** 2 / 512) + 3 * memWords; // 12 gas
// Deployment cost: 200 gas/byte
const deploymentCost = 200 * runtimeCodeLength; // 10,000 gas
// Total charged to caller
const totalCost = baseCost + initCodeCost + memCost; // 32,020 gas
// Gas forwarded to init code (assume 100,000 remaining after charge)
const remainingAfterCharge = 100000 - totalCost; // 67,980 gas
const forwardedGas = remainingAfterCharge - Math.floor(remainingAfterCharge / 64); // 66,918 gas
// Total gas consumed (if init code uses all forwarded gas)
const totalConsumed = totalCost + forwardedGas + deploymentCost; // 108,938 gas
```
## Common Usage
### Contract Factory
```solidity theme={null}
contract TokenFactory {
Token[] public deployedTokens;
function createToken(
string memory name,
string memory symbol,
uint256 initialSupply
) external returns (address) {
Token token = new Token(name, symbol, initialSupply, msg.sender);
deployedTokens.push(token);
return address(token);
}
function getDeployedTokens() external view returns (Token[] memory) {
return deployedTokens;
}
}
contract Token {
string public name;
string public symbol;
uint256 public totalSupply;
address public creator;
constructor(
string memory _name,
string memory _symbol,
uint256 _initialSupply,
address _creator
) {
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
creator = _creator;
}
}
```
### Clone Pattern (Minimal Proxy)
```solidity theme={null}
contract Cloner {
// Minimal proxy bytecode (EIP-1167)
function clone(address implementation) external returns (address instance) {
bytes20 targetBytes = bytes20(implementation);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), targetBytes)
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "Clone failed");
}
}
```
### Upgradeable Contract
```solidity theme={null}
contract UpgradeableContract {
address public implementation;
function upgrade(bytes memory newCode) external {
// Deploy new implementation
address newImpl;
assembly {
newImpl := create(0, add(newCode, 32), mload(newCode))
}
require(newImpl != address(0), "Deployment failed");
implementation = newImpl;
}
}
```
## Security
### Nonce Prediction
CREATE addresses are predictable - can pre-compute future deployment addresses:
```solidity theme={null}
// VULNERABLE: Relying on address unpredictability
function deploy() external returns (address) {
Contract c = new Contract();
// Assuming address(c) is unpredictable - WRONG!
return address(c);
}
```
**Risk:** Attacker can pre-compute addresses and exploit race conditions.
**Mitigation:** Use CREATE2 if address unpredictability is required.
### Deployment Failure
CREATE returns 0 on failure - must check result:
```solidity theme={null}
// VULNERABLE: Not checking deployment result
function deployUnchecked() external {
address deployed;
assembly {
deployed := create(0, 0, 0)
}
// deployed might be 0!
Contract(deployed).initialize(); // Will revert with confusing error
}
// SAFE: Check deployment result
function deploySafe() external {
address deployed;
assembly {
deployed := create(0, add(bytecode, 32), mload(bytecode))
}
require(deployed != address(0), "Deployment failed");
Contract(deployed).initialize();
}
```
### Constructor Reentrancy
Init code can make external calls - reentrancy risk during construction:
```solidity theme={null}
contract Victim {
mapping(address => bool) public initialized;
function register() external {
// Deploy new contract
address deployed = address(new Malicious());
// VULNERABLE: Malicious constructor could re-enter here
initialized[deployed] = true;
}
}
contract Malicious {
constructor() {
// Re-enter during construction!
Victim(msg.sender).register(); // Reentrancy attack
}
}
```
**Mitigation:** Use reentrancy guards, check-effects-interactions.
### Gas Griefing
Init code controls gas consumption - griefing risk:
```solidity theme={null}
// VULNERABLE: Unbounded gas consumption
function deployUserContract(bytes memory code) external {
address deployed;
assembly {
deployed := create(0, add(code, 32), mload(code))
}
// User can provide gas-heavy init code
}
// BETTER: Limit gas forwarded
function deployUserContractSafe(bytes memory code) external {
address deployed;
assembly {
// Forward limited gas
deployed := create(0, add(code, 32), mload(code))
}
// Gas limit naturally bounds init code execution
}
```
### Code Size Limits
**Init code:** Max 49,152 bytes (EIP-3860, Shanghai+)
**Runtime code:** Max 24,576 bytes (EIP-170, Spurious Dragon+)
```solidity theme={null}
// Pre-deploy check
require(initCode.length <= 49152, "Init code too large");
// Runtime code check happens during deployment
// Will fail if init code returns >24,576 bytes
```
## Implementation
**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:** `0xf5`
**Introduced:** Constantinople (EIP-1014)
CREATE2 deploys a new contract with a deterministic address computed from creator, salt, and init code hash. Unlike CREATE (which uses nonce), the address is predictable before deployment, enabling counterfactual instantiation and state channels.
## Specification
**Stack Input:**
```
value (wei to send)
offset (memory offset of init code)
length (size of init code)
salt (32-byte salt for address computation)
```
**Stack Output:**
```
address (deployed contract address, or 0 if failed)
```
**Gas Cost:** 32,000 + init\_code\_cost + keccak256\_cost + memory\_expansion + deployment\_cost
**Operation:**
```
initCodeHash = keccak256(memory[offset:offset+length])
address = keccak256(0xff ++ sender ++ salt ++ initCodeHash)[12:]
success = deploy(address, init_code, value, gas * 63/64)
push(success ? address : 0)
```
## Behavior
CREATE2 performs deterministic contract deployment:
1. **Pop 4 stack arguments:** value, offset, length, salt
2. **Validate static context:** Cannot be called in static mode (EIP-214)
3. **Charge gas:**
* Base: 32,000 gas
* Init code: 2 gas/word (EIP-3860)
* Keccak256: 6 gas/word (for init code hash)
* Memory expansion
4. **Read init code** from memory
5. **Compute deterministic address:**
```
initCodeHash = keccak256(initCode)
preimage = 0xff ++ sender (20 bytes) ++ salt (32 bytes) ++ initCodeHash (32 bytes)
address = keccak256(preimage)[12:] // Last 20 bytes
```
6. **Check collision:** Fail if account exists at computed address
7. **Forward gas:** Up to 63/64 of remaining gas (EIP-150)
8. **Execute init code** in new context
9. **Store runtime code** if successful (charged 200 gas/byte)
10. **Push address** to stack (0 if failed)
**Key differences from CREATE:**
* Address depends on salt and code hash, not nonce
* Additional 6 gas/word for keccak256 hashing
* Address predictable before deployment
* Enables counterfactual patterns
## Examples
### Basic CREATE2 Deployment
```typescript theme={null}
import { CREATE2 } from '@tevm/voltaire/evm/system';
import { keccak256 } from '@tevm/voltaire/crypto';
import { Address } from '@tevm/voltaire/primitives';
// Init code: returns single byte 0x42
const initCode = Bytecode([
0x60, 0x42, // PUSH1 0x42
0x60, 0x00, // PUSH1 0x00
0x52, // MSTORE
0x60, 0x01, // PUSH1 0x01 (length)
0x60, 0x1f, // PUSH1 0x1f (offset)
0xf3 // RETURN
]);
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
});
// Write init code to memory
for (let i = 0; i < initCode.length; i++) {
frame.memory.set(i, initCode[i]);
}
// Compute address before deployment
const salt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn;
const predictedAddress = predictCreate2Address(
frame.address,
salt,
initCode
);
console.log("Will deploy to:", predictedAddress);
// Stack: [value=0, offset=0, length=9, salt]
frame.stack.push(salt); // salt
frame.stack.push(9n); // length
frame.stack.push(0n); // offset
frame.stack.push(0n); // value
const err = CREATE2(frame);
console.log(frame.stack[0]); // Deployed address (matches prediction!)
```
### Address Prediction
```typescript theme={null}
import { Address, Hash } from '@tevm/voltaire/primitives';
import { keccak256 } from '@tevm/voltaire/crypto';
function predictCreate2Address(
creator: Address,
salt: bigint,
initCode: Uint8Array
): Address {
// 1. Hash init code
const initCodeHash = keccak256(initCode);
// 2. Build preimage: 0xff ++ creator ++ salt ++ initCodeHash
const preimage = new Uint8Array(1 + 20 + 32 + 32);
preimage[0] = 0xff;
preimage.set(creator, 1);
// Convert salt to bytes (big-endian)
for (let i = 0; i < 32; i++) {
preimage[21 + i] = Number((salt >> BigInt(8 * (31 - i))) & 0xffn);
}
preimage.set(initCodeHash, 53);
// 3. Hash and extract address
const hash = keccak256(preimage);
return Address(hash.slice(12));
}
// Example usage
const creator = Address("0x742d35Cc6634C0532925a3b844Bc454e4438f44e");
const salt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn;
const initCode = Bytecode();
const predicted = predictCreate2Address(creator, salt, initCode);
console.log("Contract will deploy to:", Address.toHex(predicted));
```
### Factory Pattern with CREATE2
```solidity theme={null}
contract Create2Factory {
event Deployed(address indexed addr, bytes32 indexed salt);
// Deploy contract with deterministic address
function deploy(bytes memory bytecode, bytes32 salt) external returns (address) {
address addr;
assembly {
// CREATE2(value, offset, length, salt)
addr := create2(
0, // No ETH sent
add(bytecode, 0x20), // Skip length prefix
mload(bytecode), // Init code length
salt // Salt
)
if iszero(addr) {
revert(0, 0)
}
}
emit Deployed(addr, salt);
return addr;
}
// Predict deployment address
function computeAddress(
bytes memory bytecode,
bytes32 salt
) public view returns (address) {
bytes32 bytecodeHash = keccak256(bytecode);
bytes32 hash = keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
bytecodeHash
)
);
return address(uint160(uint256(hash)));
}
// Check if contract deployed at address
function isDeployed(address addr) public view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
}
```
### Minimal Proxy Factory (EIP-1167)
```solidity theme={null}
contract CloneFactory {
// Minimal proxy bytecode with CREATE2
function cloneDeterministic(
address implementation,
bytes32 salt
) external returns (address instance) {
bytes20 targetBytes = bytes20(implementation);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), targetBytes)
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, salt)
}
require(instance != address(0), "Clone failed");
}
// Predict clone address
function predictCloneAddress(
address implementation,
bytes32 salt
) external view returns (address) {
bytes20 targetBytes = bytes20(implementation);
bytes memory bytecode = abi.encodePacked(
hex"3d602d80600a3d3981f3363d3d373d3d3d363d73",
targetBytes,
hex"5af43d82803e903d91602b57fd5bf3"
);
bytes32 hash = keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
keccak256(bytecode)
)
);
return address(uint160(uint256(hash)));
}
}
```
### Counterfactual Instantiation
```solidity theme={null}
// State channel pattern
contract StateChannel {
mapping(bytes32 => bool) public deployed;
// Deploy channel only when needed (counterfactual)
function finalizeChannel(
bytes memory channelCode,
bytes32 salt,
bytes memory finalState
) external {
bytes32 channelId = keccak256(abi.encodePacked(channelCode, salt));
require(!deployed[channelId], "Already deployed");
// Predict address
address predictedAddr = computeAddress(channelCode, salt);
// Verify off-chain state was for this address
require(verifyState(predictedAddr, finalState), "Invalid state");
// Deploy actual contract
address addr;
assembly {
addr := create2(0, add(channelCode, 0x20), mload(channelCode), salt)
}
require(addr == predictedAddr, "Address mismatch");
deployed[channelId] = true;
}
// Channel can operate off-chain at predicted address
// Only deploys on-chain when dispute or finalization needed
}
```
## Gas Cost
**Total cost:** 32,000 + init\_code\_cost + keccak256\_cost + memory\_expansion + deployment\_cost
### Base Cost: 32,000 gas
Fixed cost for CREATE2 operation (same as CREATE).
### Init Code Cost (EIP-3860)
**Shanghai+:** 2 gas per word for init code:
```
init_code_cost = 2 * ceil(init_code_length / 32)
```
**Pre-Shanghai:** No init code cost.
### Keccak256 Cost
**CREATE2-specific:** 6 gas per word for hashing init code:
```
keccak256_cost = 6 * ceil(init_code_length / 32)
```
This is the primary cost difference vs CREATE.
### Memory Expansion
Dynamic cost for reading init code from memory:
```
words_needed = ceil((offset + length) / 32)
expansion_cost = (words_needed)² / 512 + 3 * (words_needed - current_words)
```
### Deployment Cost
**Runtime code storage:** 200 gas per byte of deployed code:
```
deployment_cost = 200 * runtime_code_length
```
### Gas Forwarding (EIP-150)
Same as CREATE - 63/64 rule applies.
### Example Calculation
```typescript theme={null}
// Deploy with 100-byte init code, returns 50-byte runtime code
const initCodeLength = 100;
const runtimeCodeLength = 50;
// Base cost
const baseCost = 32000;
// Init code cost (Shanghai+): 2 gas/word
const initCodeWords = Math.ceil(initCodeLength / 32); // 4 words
const initCodeCost = 2 * initCodeWords; // 8 gas
// Keccak256 cost (CREATE2-specific): 6 gas/word
const keccak256Cost = 6 * initCodeWords; // 24 gas
// Memory expansion (assume clean memory)
const memWords = Math.ceil(initCodeLength / 32); // 4 words
const memCost = Math.floor(memWords ** 2 / 512) + 3 * memWords; // 12 gas
// Deployment cost: 200 gas/byte
const deploymentCost = 200 * runtimeCodeLength; // 10,000 gas
// Total charged to caller
const totalCost = baseCost + initCodeCost + keccak256Cost + memCost; // 32,044 gas
// Gas forwarded to init code (assume 100,000 remaining)
const remainingAfterCharge = 100000 - totalCost; // 67,956 gas
const forwardedGas = remainingAfterCharge - Math.floor(remainingAfterCharge / 64); // 66,895 gas
// Total consumed
const totalConsumed = totalCost + forwardedGas + deploymentCost; // 108,939 gas
```
## Common Usage
### Upgradeable Factory
```solidity theme={null}
contract UpgradeableFactory {
address public implementation;
function deployProxy(bytes32 salt) external returns (address) {
bytes memory bytecode = getProxyBytecode(implementation);
address proxy;
assembly {
proxy := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
require(proxy != address(0), "Deploy failed");
return proxy;
}
function upgrade(address newImpl) external {
implementation = newImpl;
// Future deployments use new implementation
}
}
```
### Registry Pattern
```solidity theme={null}
contract Registry {
mapping(address => bool) public registered;
function register(bytes memory code, bytes32 salt) external {
// Predict address
address predicted = computeAddress(code, salt);
require(!registered[predicted], "Already registered");
// Deploy
address deployed;
assembly {
deployed := create2(0, add(code, 32), mload(code), salt)
}
require(deployed == predicted, "Mismatch");
registered[deployed] = true;
}
}
```
### Multi-signature Wallet Factory
```solidity theme={null}
contract WalletFactory {
function createWallet(
address[] memory owners,
uint256 threshold,
bytes32 salt
) external returns (address wallet) {
// Deterministic address based on configuration
bytes memory bytecode = abi.encodePacked(
type(MultiSigWallet).creationCode,
abi.encode(owners, threshold)
);
assembly {
wallet := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
require(wallet != address(0), "Deploy failed");
}
function computeWalletAddress(
address[] memory owners,
uint256 threshold,
bytes32 salt
) external view returns (address) {
bytes memory bytecode = abi.encodePacked(
type(MultiSigWallet).creationCode,
abi.encode(owners, threshold)
);
bytes32 hash = keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
keccak256(bytecode)
)
);
return address(uint160(uint256(hash)));
}
}
```
## Security
### Address Collision Attacks
CREATE2 enables deliberate address collisions through init code manipulation:
```solidity theme={null}
// VULNERABLE: Pre-Cancun collision attack
contract VulnerableFactory {
function deploy(bytes memory code, bytes32 salt) external {
address addr;
assembly {
addr := create2(0, add(code, 32), mload(code), salt)
}
// Deployed contract A
}
}
// Attack (pre-EIP-6780):
// 1. Deploy Contract A with init_code_1, salt
// 2. Selfdestruct Contract A
// 3. Deploy Contract B with init_code_2, SAME salt
// Result: Different code at same address!
// Post-Cancun (EIP-6780): SELFDESTRUCT doesn't delete in same tx
// Attack mitigated: Cannot redeploy at same address
```
**Mitigation (EIP-6780):** SELFDESTRUCT only deletes if created in same transaction.
### Init Code Hash Importance
Address depends on init code hash - different code = different address:
```solidity theme={null}
// These deploy to DIFFERENT addresses even with same salt
bytes memory code1 = type(Contract).creationCode;
bytes memory code2 = abi.encodePacked(
type(Contract).creationCode,
abi.encode(123) // Constructor argument
);
// Different init code hash = different address
address addr1 = create2(0, add(code1, 32), mload(code1), salt);
address addr2 = create2(0, add(code2, 32), mload(code2), salt);
// addr1 != addr2
```
### Salt Reuse
Same salt with same code fails:
```solidity theme={null}
// VULNERABLE: Deployment fails if salt reused
function deploy(bytes memory code, bytes32 salt) external {
address addr;
assembly {
addr := create2(0, add(code, 32), mload(code), salt)
}
// Reverts if contract already exists at computed address
}
// SAFE: Include unique data in salt
function deployUnique(bytes memory code, uint256 nonce) external {
bytes32 salt = keccak256(abi.encodePacked(msg.sender, nonce));
// Address unique per user + nonce
}
```
### Metamorphic Contracts
Contracts that change code after deployment:
```solidity theme={null}
// DANGEROUS: Metamorphic pattern (pre-Cancun)
contract Metamorphic {
function morph() external {
// Change implementation
selfdestruct(payable(address(this)));
// Then redeploy different code at same address via CREATE2
}
}
// Post-Cancun: EIP-6780 prevents this
// SELFDESTRUCT doesn't delete code unless created in same tx
```
### Frontrunning
Deterministic addresses enable frontrunning:
```solidity theme={null}
// VULNERABLE: Public salt + code = frontrunnabale
function deploy(bytes memory code, bytes32 salt) external {
// Attacker sees tx in mempool
// Frontruns with higher gas price
// Deploys at target address first!
address addr;
assembly {
addr := create2(0, add(code, 32), mload(code), salt)
}
}
// MITIGATION: Include msg.sender in salt
bytes32 salt = keccak256(abi.encodePacked(msg.sender, userProvidedSalt));
// Address unique per deployer
```
### Constructor Reentrancy
Same reentrancy risks as CREATE:
```solidity theme={null}
contract Vulnerable {
mapping(address => bool) public trusted;
function deployAndTrust(bytes memory code, bytes32 salt) external {
address deployed;
assembly {
deployed := create2(0, add(code, 32), mload(code), salt)
}
// VULNERABLE: Constructor could re-enter here
trusted[deployed] = true;
}
}
```
## Implementation
```typescript theme={null}
/**
* CREATE2 opcode (0xf5)
* Create contract at deterministic address
*/
export function create2(frame: FrameType): EvmError | null {
// EIP-214: Cannot be called in static context
if (frame.isStatic) {
return { type: "WriteProtection" };
}
// Pop 4 arguments
const value = popStack(frame);
const offset = popStack(frame);
const length = popStack(frame);
const salt = popStack(frame);
// Calculate gas cost
const words = Math.ceil(Number(length) / 32);
let gasCost = 32000n; // Base
gasCost += BigInt(words * 2); // Init code (EIP-3860)
gasCost += BigInt(words * 6); // Keccak256 for address
// Memory expansion
if (length > 0) {
const end = Number(offset) + Number(length);
gasCost += memoryExpansionCost(frame, end);
updateMemorySize(frame, end);
}
// Charge gas
consumeGas(frame, gasCost);
// Read init code
const initCode = readMemory(frame, offset, length);
// Compute deterministic address
const initCodeHash = keccak256(initCode);
const preimage = new Uint8Array(1 + 20 + 32 + 32);
preimage[0] = 0xff;
preimage.set(frame.address, 1);
preimage.set(saltToBytes(salt), 21);
preimage.set(initCodeHash, 53);
const addressHash = keccak256(preimage);
const address = addressHash.slice(12);
// Check collision
if (accountExists(address)) {
pushStack(frame, 0n); // Failure
frame.returnData = new Uint8Array(0);
return null;
}
// Calculate forwarded gas (63/64 rule)
const afterCharge = frame.gasRemaining;
const maxForward = afterCharge - afterCharge / 64n;
// Execute deployment
const result = executeCreate({
address: address,
initCode: initCode,
value: value,
gas: maxForward
});
// Refund unused gas
frame.gasRemaining += result.gasLeft;
// Set return_data
frame.returnData = result.success ? new Uint8Array(0) : result.output;
// Push address (0 if failed)
pushStack(frame, result.success ? addressToBigInt(address) : 0n);
frame.pc += 1;
return null;
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 7 (Contract Creation)
* **[EIP-1014](https://eips.ethereum.org/EIPS/eip-1014)** - CREATE2 opcode
* **[EIP-150](https://eips.ethereum.org/EIPS/eip-150)** - Gas cost changes (63/64 rule)
* **[EIP-170](https://eips.ethereum.org/EIPS/eip-170)** - Contract code size limit
* **[EIP-1167](https://eips.ethereum.org/EIPS/eip-1167)** - Minimal proxy contract
* **[EIP-3860](https://eips.ethereum.org/EIPS/eip-3860)** - Init code size limit
* **[EIP-6780](https://eips.ethereum.org/EIPS/eip-6780)** - SELFDESTRUCT behavior (collision mitigation)
* **[evm.codes - CREATE2](https://www.evm.codes/#f5)** - Interactive reference
# DELEGATECALL (0xf4)
Source: https://voltaire.tevm.sh/evm/instructions/system/delegatecall
Execute code preserving msg.sender and msg.value - foundation for libraries and proxies
**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:** `0xf4`
**Introduced:** Homestead (EIP-7)
DELEGATECALL executes code from another account while preserving the complete execution context (msg.sender, msg.value, storage). This enables library patterns and upgradeable proxy contracts by allowing code reuse without changing the caller's state context.
## Specification
**Stack Input:**
```
gas (max gas to forward)
address (target account code to execute)
inOffset (calldata memory offset)
inLength (calldata size)
outOffset (returndata memory offset)
outLength (returndata size)
```
**Stack Output:**
```
success (1 if call succeeded, 0 if failed)
```
**Gas Cost:** 700 + cold\_access + memory\_expansion
**Operation:**
```
calldata = memory[inOffset:inOffset+inLength]
success = execute_preserving_context(address.code, calldata, gas * 63/64)
memory[outOffset:outOffset+outLength] = returndata[0:min(outLength, returndata.length)]
push(success)
```
## Behavior
DELEGATECALL executes foreign code as if it were part of the caller:
1. **Pop 6 stack arguments** (no value parameter)
2. **Calculate gas cost:**
* Base: 700 gas (Tangerine Whistle+)
* Cold access: +2,600 gas for first access (Berlin+)
* Memory expansion for input and output regions
3. **Read calldata** from memory
4. **Forward gas:** Up to 63/64 of remaining gas (EIP-150)
5. **Execute target's code preserving context:**
* msg.sender = preserved from caller (NOT changed!)
* msg.value = preserved from caller (NOT changed!)
* Storage = caller's storage (modifications affect caller!)
* Code = target's code
* address(this) = caller's address
6. **Copy returndata** to memory
7. **Set return\_data** buffer to full returndata
8. **Push success flag**
9. **Refund unused gas** from child execution
**Key characteristics:**
* Complete context preservation (msg.sender, msg.value unchanged)
* Storage operations affect caller
* No value transfer (preserves existing msg.value)
* Foundation for library and proxy patterns
## Examples
### Library Pattern
```typescript theme={null}
import { DELEGATECALL } from '@tevm/voltaire/evm/system';
import { Address } from '@tevm/voltaire/primitives';
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
caller: Address("0x5678..."),
value: 1_000_000_000_000_000_000n // 1 ETH from original call
});
// Call library function
const libraryAddress = Address("0xLibrary...");
const calldata = new Uint8Array([/* function selector + params */]);
// Write calldata to memory
for (let i = 0; i < calldata.length; i++) {
frame.memory.set(i, calldata[i]);
}
// Stack: [gas=100000, address, inOffset=0, inLength, outOffset=0, outLength=32]
frame.stack.push(32n); // outLength
frame.stack.push(0n); // outOffset
frame.stack.push(BigInt(calldata.length)); // inLength
frame.stack.push(0n); // inOffset
frame.stack.push(BigInt(libraryAddress)); // library address
frame.stack.push(100000n); // gas
const err = DELEGATECALL(frame);
// In library code:
// - msg.sender = 0x5678... (preserved!)
// - msg.value = 1 ETH (preserved!)
// - storage modifications affect 0x1234...
// - address(this) = 0x1234...
console.log(frame.stack[0]); // 1n if success
```
### Proxy Pattern
```solidity theme={null}
contract Proxy {
address public implementation;
constructor(address _implementation) {
implementation = _implementation;
}
// Fallback forwards all calls to implementation
fallback() external payable {
address impl = implementation;
assembly {
// Copy calldata
calldatacopy(0, 0, calldatasize())
// DELEGATECALL to implementation
let result := delegatecall(
gas(),
impl,
0,
calldatasize(),
0,
0
)
// Copy returndata
returndatacopy(0, 0, returndatasize())
// Return or revert based on result
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
// Upgrade implementation (admin only)
function upgrade(address newImpl) external {
require(msg.sender == admin, "Not admin");
implementation = newImpl;
}
}
contract Implementation {
// Storage layout MUST match Proxy!
address public implementation; // Slot 0
address public admin; // Slot 1
uint256 public value; // Slot 2
function setValue(uint256 _value) external {
// Executes in Proxy's context
// msg.sender = original caller (preserved!)
// storage modifications affect Proxy storage
value = _value;
}
function getValue() external view returns (uint256) {
// Reads from Proxy's storage
return value;
}
}
```
### Library Contract
```solidity theme={null}
// Library with reusable logic
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "Overflow");
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "Overflow");
return c;
}
}
// Using library via DELEGATECALL
contract Calculator {
using SafeMath for uint256;
function calculate(uint256 a, uint256 b) external pure returns (uint256) {
// Compiler generates DELEGATECALL to SafeMath
return a.add(b).mul(2);
}
}
```
### Upgradeable Storage Pattern
```solidity theme={null}
// Eternal storage pattern
contract EternalStorage {
mapping(bytes32 => uint256) uintStorage;
mapping(bytes32 => address) addressStorage;
function getUint(bytes32 key) external view returns (uint256) {
return uintStorage[key];
}
function setUint(bytes32 key, uint256 value) external {
uintStorage[key] = value;
}
}
contract LogicV1 {
EternalStorage public store;
function setValue(uint256 value) external {
// Store via delegatecall-safe pattern
store.setUint(keccak256("myValue"), value);
}
function getValue() external view returns (uint256) {
return store.getUint(keccak256("myValue"));
}
}
contract LogicV2 {
EternalStorage public store;
// Upgraded logic with new features
function setValue(uint256 value) external {
require(value > 0, "Must be positive");
store.setUint(keccak256("myValue"), value * 2);
}
function getValue() external view returns (uint256) {
return store.getUint(keccak256("myValue"));
}
}
```
## Gas Cost
**Total cost:** 700 + cold\_access + memory\_expansion + forwarded\_gas
### Base Cost: 700 gas (Tangerine Whistle+)
**Pre-Tangerine Whistle:** 40 gas
### No Value Transfer Cost
DELEGATECALL never transfers value - preserves msg.value:
```
// No CallValueTransferGas
// No CallNewAccountGas
```
### Cold Access: +2,600 gas (Berlin+)
**EIP-2929 (Berlin+):** First access to target address:
```
if (firstAccess(address)) {
cost += 2600 // ColdAccountAccess
} else {
cost += 100 // WarmStorageRead
}
```
### Memory Expansion
Same as CALL - charges for both input and output regions:
```typescript theme={null}
const inEnd = inOffset + inLength;
const outEnd = outOffset + outLength;
const maxEnd = Math.max(inEnd, outEnd);
const words = Math.ceil(maxEnd / 32);
const expansionCost = words ** 2 / 512 + 3 * words;
```
### Gas Forwarding (EIP-150)
**Tangerine Whistle+:** 63/64 rule:
```
remaining_after_charge = gas_remaining - base_cost
max_forwarded = remaining_after_charge - (remaining_after_charge / 64)
actual_forwarded = min(gas_parameter, max_forwarded)
```
### Example Calculation
```typescript theme={null}
// DELEGATECALL to library with cold access
const gasRemaining = 100000n;
const inLength = 68; // Function call
const outLength = 32; // Return value
// Base cost
let cost = 700n; // Tangerine Whistle+
// No value transfer cost
// Cold access (Berlin+, first access)
cost += 2600n; // ColdAccountAccess
// Memory expansion (clean memory)
const maxEnd = Math.max(68, 32); // 68 bytes
const words = Math.ceil(68 / 32); // 3 words
const memCost = Math.floor(words ** 2 / 512) + 3 * words; // 9 gas
cost += BigInt(memCost);
// Total charged: 3,309 gas
// Gas forwarding
const afterCharge = gasRemaining - cost; // 96,691 gas
const maxForward = afterCharge - afterCharge / 64n; // 95,181 gas
// Total consumed: 3,309 + gas_used_by_library
```
## Common Usage
### Minimal Proxy (EIP-1167)
```solidity theme={null}
// Clone factory using minimal proxy pattern
contract CloneFactory {
// Minimal proxy bytecode (55 bytes)
function clone(address implementation) external returns (address instance) {
bytes20 targetBytes = bytes20(implementation);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), targetBytes)
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "Clone failed");
}
}
// The minimal proxy forwards all calls via DELEGATECALL:
// PUSH1 0x00 CALLDATASIZE PUSH1 0x00 CALLDATACOPY
// PUSH1 0x00 CALLDATASIZE PUSH1 0x00 PUSH20 GAS DELEGATECALL
// RETURNDATASIZE PUSH1 0x00 PUSH1 0x00 RETURNDATACOPY
// RETURNDATASIZE PUSH1 0x00 RETURN/REVERT
```
### Diamond Pattern (EIP-2535)
```solidity theme={null}
contract Diamond {
mapping(bytes4 => address) public facets;
fallback() external payable {
address facet = facets[msg.sig];
require(facet != address(0), "Function does not exist");
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function addFacet(bytes4 selector, address facet) external {
facets[selector] = facet;
}
}
```
### Library Call Helper
```solidity theme={null}
contract LibraryUser {
// Safe library call with error handling
function callLibrary(
address library,
bytes memory data
) internal returns (bool success, bytes memory returnData) {
assembly {
success := delegatecall(
gas(),
library,
add(data, 0x20),
mload(data),
0,
0
)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
returndatacopy(add(returnData, 0x20), 0, size)
mstore(0x40, add(add(returnData, 0x20), size))
}
}
}
```
## Security
### Storage Collision
Storage layout MUST match between caller and callee:
```solidity theme={null}
// VULNERABLE: Storage layout mismatch
contract Proxy {
address public implementation; // Slot 0
address public admin; // Slot 1
}
contract MaliciousImpl {
address public owner; // Slot 0 - COLLIDES with implementation!
uint256 public value; // Slot 1 - COLLIDES with admin!
function exploit() external {
// Overwrites Proxy.implementation!
owner = msg.sender;
}
}
```
**Mitigation: Use consistent storage layout:**
```solidity theme={null}
// SAFE: Matching storage layout
contract Proxy {
address public implementation; // Slot 0
address public admin; // Slot 1
}
contract Implementation {
address public implementation; // Slot 0 - MATCHES
address public admin; // Slot 1 - MATCHES
uint256 public value; // Slot 2 - New state
}
```
### Uninitialized Proxy
Proxy storage must be initialized before use:
```solidity theme={null}
// VULNERABLE: Uninitialized proxy
contract Proxy {
address public implementation;
fallback() external payable {
// implementation is address(0)!
address impl = implementation;
assembly {
delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
}
}
}
// SAFE: Initialize in constructor
contract SafeProxy {
address public implementation;
constructor(address _impl) {
require(_impl != address(0), "Invalid implementation");
implementation = _impl;
}
}
```
### Selfdestruct in Implementation
SELFDESTRUCT in library can destroy proxy:
```solidity theme={null}
// VULNERABLE: Library can selfdestruct
contract MaliciousLibrary {
function destroy() external {
selfdestruct(payable(msg.sender));
// Destroys PROXY, not library!
}
}
// MITIGATION: Never SELFDESTRUCT in delegatecalled code
// Or use EIP-6780 (Cancun+) which limits SELFDESTRUCT
```
### Function Selector Collision
Different functions with same selector can cause unexpected behavior:
```solidity theme={null}
// VULNERABLE: Selector collision
contract Implementation {
// collides_uint256(uint256) and burn(uint256) have same selector!
function collides_uint256(uint256) external { }
function burn(uint256) external { }
}
// MITIGATION: Check for collisions, use namespaced selectors
```
### Delegate to Untrusted Contract
Only DELEGATECALL to trusted, audited code:
```solidity theme={null}
// VULNERABLE: User-controlled delegatecall
contract Vulnerable {
function proxyCall(address target, bytes memory data) external {
// User controls target - CAN EXECUTE ARBITRARY CODE!
target.delegatecall(data);
}
}
// SAFE: Whitelist allowed targets
contract Safe {
mapping(address => bool) public allowed;
function proxyCall(address target, bytes memory data) external {
require(allowed[target], "Target not allowed");
target.delegatecall(data);
}
}
```
## Implementation
```typescript theme={null}
/**
* DELEGATECALL opcode (0xf4)
* Execute code preserving msg.sender and msg.value
*/
export function delegatecall(frame: FrameType): EvmError | null {
// Pop 6 arguments (no value)
const gas = popStack(frame);
const address = popStack(frame);
const inOffset = popStack(frame);
const inLength = popStack(frame);
const outOffset = popStack(frame);
const outLength = popStack(frame);
// Calculate gas cost
let gasCost = 700n; // Base (Tangerine Whistle+)
// No value transfer cost
// Cold access cost (Berlin+)
const accessCost = getAccessCost(address);
gasCost += accessCost;
// Memory expansion
const inEnd = inLength > 0 ? inOffset + inLength : 0;
const outEnd = outLength > 0 ? outOffset + outLength : 0;
const maxEnd = Math.max(inEnd, outEnd);
if (maxEnd > 0) {
gasCost += memoryExpansionCost(frame, maxEnd);
updateMemorySize(frame, maxEnd);
}
// Calculate forwarded gas (63/64 rule)
const afterCharge = frame.gasRemaining - gasCost;
const maxForward = afterCharge - afterCharge / 64n;
const forwardedGas = min(gas, maxForward);
// Charge total cost
consumeGas(frame, gasCost + forwardedGas);
// Read calldata
const calldata = readMemory(frame, inOffset, inLength);
// Execute delegatecall (preserve context!)
const result = executeDelegateCall({
codeAddress: address, // Code to execute
storageAddress: frame.address, // Storage to modify
sender: frame.caller, // msg.sender PRESERVED
value: frame.value, // msg.value PRESERVED
data: calldata,
gas: forwardedGas
});
// Refund unused gas
frame.gasRemaining += result.gasLeft;
// Copy returndata
const copySize = min(outLength, result.returnData.length);
writeMemory(frame, outOffset, result.returnData.slice(0, copySize));
// Set return_data buffer
frame.returnData = result.returnData;
// Push success flag
pushStack(frame, result.success ? 1n : 0n);
frame.pc += 1;
return null;
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.4.4 (DELEGATECALL)
* **[EIP-7](https://eips.ethereum.org/EIPS/eip-7)** - DELEGATECALL opcode
* **[EIP-150](https://eips.ethereum.org/EIPS/eip-150)** - Gas cost changes (63/64 rule)
* **[EIP-1167](https://eips.ethereum.org/EIPS/eip-1167)** - Minimal proxy contract
* **[EIP-2535](https://eips.ethereum.org/EIPS/eip-2535)** - Diamond standard
* **[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)** - Access list gas costs
* **[evm.codes - DELEGATECALL](https://www.evm.codes/#f4)** - Interactive reference
* **[OpenZeppelin Proxy Docs](https://docs.openzeppelin.com/contracts/4.x/api/proxy)** - Proxy patterns
# System Instructions
Source: https://voltaire.tevm.sh/evm/instructions/system/index
EVM opcodes for contract creation, message calls, and account management
**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
System instructions enable contracts to interact with external accounts, create new contracts, and manage account lifecycle. These are the most complex EVM opcodes, handling gas forwarding, context preservation, and state modifications.
## Instructions
### Contract Creation
* **[CREATE (0xf0)](/evm/instructions/system/create)** - Create contract at computed address
* **[CREATE2 (0xf5)](/evm/instructions/system/create2)** - Create contract at deterministic address (Constantinople+)
### Message Calls
* **[CALL (0xf1)](/evm/instructions/system/call)** - External call with value transfer
* **[CALLCODE (0xf2)](/evm/instructions/system/callcode)** - Execute code in current context (deprecated)
* **[DELEGATECALL (0xf4)](/evm/instructions/system/delegatecall)** - Execute code preserving msg.sender/value (Homestead+)
* **[STATICCALL (0xfa)](/evm/instructions/system/staticcall)** - Read-only call (Byzantium+)
### Account Management
* **[SELFDESTRUCT (0xff)](/evm/instructions/system/selfdestruct)** - Transfer balance and mark for deletion
## Key Concepts
### Gas Forwarding (EIP-150)
**63/64 Rule (Tangerine Whistle+):** Caller retains 1/64th of remaining gas, forwards up to 63/64:
```
max_forwarded = remaining_gas - (remaining_gas / 64)
```
**Pre-Tangerine Whistle:** Forward all remaining gas.
### Call Variants
| Opcode | msg.sender | msg.value | Storage | State Changes | Introduced |
| ------------ | ---------- | --------- | ------- | ------------- | ---------- |
| CALL | caller | specified | callee | allowed | Frontier |
| CALLCODE | caller | specified | caller | allowed | Frontier |
| DELEGATECALL | preserved | preserved | caller | allowed | Homestead |
| STATICCALL | caller | 0 | callee | forbidden | Byzantium |
### Value Transfer Gas Costs
**With non-zero value:**
* Base call cost: 700 gas (Tangerine Whistle+)
* Value transfer: +9,000 gas
* Stipend to callee: +2,300 gas (free)
* New account: +25,000 gas (if recipient doesn't exist)
**Without value:**
* Base call cost: 700 gas (Tangerine Whistle+)
* Access cost: 100 (warm) or 2,600 (cold) gas (Berlin+)
### Address Computation
**CREATE:**
```
address = keccak256(rlp([sender, nonce]))[12:]
```
**CREATE2:**
```
address = keccak256(0xff ++ sender ++ salt ++ keccak256(init_code))[12:]
```
## Security Considerations
### Reentrancy
External calls enable reentrancy attacks:
```solidity theme={null}
// VULNERABLE: State change after external call
function withdraw(uint256 amount) external {
require(balances[msg.sender] >= amount);
// External call before state update
(bool success, ) = msg.sender.call{value: amount}("");
require(success);
balances[msg.sender] -= amount; // Too late!
}
```
**Mitigation: Checks-Effects-Interactions pattern:**
```solidity theme={null}
function withdraw(uint256 amount) external {
require(balances[msg.sender] >= amount);
// Update state BEFORE external call
balances[msg.sender] -= amount;
(bool success, ) = msg.sender.call{value: amount}("");
require(success);
}
```
### CREATE2 Address Collision
CREATE2 enables deterministic addresses but introduces collision risks:
```solidity theme={null}
// Attack: Deploy different code at same address
// 1. Deploy contract A with init_code_1
// 2. SELFDESTRUCT contract A (pre-Cancun)
// 3. Deploy contract B with init_code_2 using same salt
// Result: Different code at same address!
```
**EIP-6780 (Cancun) mitigation:** SELFDESTRUCT only deletes if created in same transaction.
### CALLCODE Deprecation
CALLCODE is deprecated - use DELEGATECALL instead:
```solidity theme={null}
// ❌ CALLCODE: msg.value preserved but semantics confusing
assembly {
callcode(gas(), target, value, in, insize, out, outsize)
}
// ✅ DELEGATECALL: Clear semantics, preserves full context
assembly {
delegatecall(gas(), target, in, insize, out, outsize)
}
```
### SELFDESTRUCT Changes (EIP-6780)
**Pre-Cancun:** SELFDESTRUCT deletes code, storage, nonce.
**Cancun+:** SELFDESTRUCT only transfers balance (unless created same tx).
```solidity theme={null}
// Pre-Cancun: Code/storage deleted at end of tx
selfdestruct(beneficiary);
// Contract unusable after tx
// Cancun+: Code/storage persist
selfdestruct(beneficiary);
// Contract still functional after tx!
```
## Gas Cost Summary
### Call Instructions
| Operation | Base | Value Transfer | New Account | Cold Access | Memory |
| ------------ | ---- | -------------- | ----------- | ----------- | ------- |
| CALL | 700 | +9,000 | +25,000 | +2,600 | dynamic |
| CALLCODE | 700 | +9,000 | - | +2,600 | dynamic |
| DELEGATECALL | 700 | - | - | +2,600 | dynamic |
| STATICCALL | 700 | - | - | +2,600 | dynamic |
### Creation Instructions
| Operation | Base | Init Code | Memory | Notes |
| --------- | ------ | -------------------------- | ------- | ------------------ |
| CREATE | 32,000 | +6/byte (EIP-3860) | dynamic | +200/byte codesize |
| CREATE2 | 32,000 | +6/byte + 6/byte (hashing) | dynamic | +200/byte codesize |
### SELFDESTRUCT
* Base: 5,000 gas
* Cold beneficiary: +2,600 gas (Berlin+)
* New account: +25,000 gas (if beneficiary doesn't exist)
* Refund: 24,000 gas (removed in London)
## Common Patterns
### Safe External Call
```solidity theme={null}
function safeCall(address target, bytes memory data) internal returns (bool) {
// 1. Update state first (reentrancy protection)
// 2. Limit gas forwarded
// 3. Handle return data safely
(bool success, bytes memory returnData) = target.call{
gas: 100000 // Limit forwarded gas
}(data);
if (!success) {
// Handle error (revert or return false)
if (returnData.length > 0) {
assembly {
revert(add(returnData, 32), mload(returnData))
}
}
return false;
}
return true;
}
```
### Factory Pattern (CREATE2)
```solidity theme={null}
contract Factory {
function deploy(bytes32 salt) external returns (address) {
bytes memory bytecode = type(Contract).creationCode;
address addr;
assembly {
addr := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
require(addr != address(0), "Deploy failed");
return addr;
}
function predictAddress(bytes32 salt) external view returns (address) {
bytes32 hash = keccak256(abi.encodePacked(
bytes1(0xff),
address(this),
salt,
keccak256(type(Contract).creationCode)
));
return address(uint160(uint256(hash)));
}
}
```
### Proxy Pattern (DELEGATECALL)
```solidity theme={null}
contract Proxy {
address public implementation;
fallback() external payable {
address impl = implementation;
assembly {
// Copy calldata
calldatacopy(0, 0, calldatasize())
// Delegatecall to implementation
let result := delegatecall(
gas(),
impl,
0,
calldatasize(),
0,
0
)
// Copy return data
returndatacopy(0, 0, returndatasize())
// Return or revert
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.4.4 (System Operations)
* **[EIP-150](https://eips.ethereum.org/EIPS/eip-150)** - Gas cost changes (63/64 rule)
* **[EIP-214](https://eips.ethereum.org/EIPS/eip-214)** - STATICCALL opcode
* **[EIP-1014](https://eips.ethereum.org/EIPS/eip-1014)** - CREATE2 opcode
* **[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)** - Access list gas costs
* **[EIP-3860](https://eips.ethereum.org/EIPS/eip-3860)** - Init code size limit
* **[EIP-6780](https://eips.ethereum.org/EIPS/eip-6780)** - SELFDESTRUCT behavior change
* **[evm.codes](https://www.evm.codes/)** - Interactive opcode reference
# SELFDESTRUCT (0xff)
Source: https://voltaire.tevm.sh/evm/instructions/system/selfdestruct
Transfer remaining balance and mark contract for deletion (being deprecated)
**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:** 0xff
**Gas:** 5,000 (warm) / 30,000 (cold)
**Hardfork:** Frontier
**Stack Input:** address (recipient of remaining balance)
**Stack Output:** (none)
**Status:** Being deprecated (EIP-6049)
SELFDESTRUCT transfers all remaining Ether to a target address and marks the contract for deletion at the end of the transaction.
## Specification
```
Stack: [address] → []
Gas: 5,000 + Ccold (if cold access) + Cnew (if creating account)
```
### Operation
1. Pop recipient address from stack
2. Transfer contract's entire balance to recipient
3. Mark contract for deletion
4. Halt execution (like STOP)
5. Contract code removed at end of transaction (post-EIP-6780: only in same transaction as creation)
## Deprecation Status (EIP-6049)
**SELFDESTRUCT is being deprecated** due to security and complexity issues:
### EIP-6780 (Cancun) - Behavior Change
Post-Cancun, SELFDESTRUCT only deletes code if called in same transaction as CREATE/CREATE2:
```solidity theme={null}
// Same transaction - code deleted
contract Factory {
function createAndDestroy() external {
Victim v = new Victim();
v.destroy(); // Code deleted
}
}
// Different transaction - code NOT deleted, only sends balance
contract Existing {
function destroy() external {
selfdestruct(payable(msg.sender)); // Balance sent, code remains!
}
}
```
### Future (EIP-4758) - Full Removal
Planned removal in future hardfork. Use alternatives:
* Send balance with CALL
* Disable contract with storage flags
* Upgrade via proxy pattern
## Gas Cost
```typescript theme={null}
const baseCost = 5000n;
// Cold access (Berlin+)
const coldCost = isColdAccess(recipient) ? 25000n : 0n;
// New account (if recipient doesn't exist and balance > 0)
const newAccountCost = (balance > 0 && !accountExists(recipient)) ? 25000n : 0n;
const totalCost = baseCost + coldCost + newAccountCost;
```
### Range: 5,000 - 55,000 gas
## Examples
### Basic Self-Destruct
```solidity theme={null}
contract Mortal {
address public owner;
constructor() {
owner = msg.sender;
}
function destroy() external {
require(msg.sender == owner, "Not owner");
selfdestruct(payable(owner)); // Send balance to owner
}
}
```
### Assembly
```solidity theme={null}
assembly {
// SELFDESTRUCT(address)
selfdestruct(recipient)
}
```
### Factory Pattern (Works in Cancun)
```solidity theme={null}
contract Factory {
function createEphemeral() external returns (bytes32 hash) {
// Create contract
Ephemeral e = new Ephemeral();
// Use it
e.doSomething();
// Destroy in same transaction - code deleted
e.destroy();
return keccak256(address(e).code); // Returns 0 after destruction
}
}
contract Ephemeral {
function doSomething() external {
// Temporary logic
}
function destroy() external {
selfdestruct(payable(msg.sender));
}
}
```
## Behavior Changes Across Hardforks
| Hardfork | Change |
| --------------------------- | ----------------------------------------------------- |
| Frontier | Introduced - deletes code, refunds 24,000 gas |
| Tangerine Whistle (EIP-150) | Gas cost: 0 → 5,000 |
| Spurious Dragon (EIP-161) | Don't create empty accounts |
| Berlin (EIP-2929) | +25,000 gas for cold access |
| London (EIP-3529) | Removed 24,000 gas refund |
| Cancun (EIP-6780) | **Only deletes code in same transaction as creation** |
| Future (EIP-4758) | Full removal planned |
## Edge Cases
### Balance Transfer
```solidity theme={null}
// Sends all remaining Ether
contract HasBalance {
receive() external payable {}
function destroy() external {
// All ETH (including in same transaction) sent to recipient
selfdestruct(payable(msg.sender));
}
}
```
### Multiple Calls in Same Transaction (Pre-Cancun)
```solidity theme={null}
// Pre-Cancun: First SELFDESTRUCT marks for deletion, subsequent calls still work
contract MultiDestruct {
function destroyTwice() external {
address recipient = msg.sender;
selfdestruct(payable(recipient)); // Marks for deletion
// Code continues executing!
selfdestruct(payable(recipient)); // Works again (balance already 0)
}
}
```
### Receiving Contract Rejection
If recipient is contract with failing receive/fallback:
```solidity theme={null}
contract RejectingRecipient {
receive() external payable {
revert("I don't want ETH");
}
}
// SELFDESTRUCT ignores recipient's rejection - forcibly sends ETH
```
## Security
### Funds Recovery
**Problem:** Users send ETH to contract after destruction
**Pre-Cancun:**
```solidity theme={null}
// Contract destroyed
victim.destroy();
// ETH sent here is LOST FOREVER (no code to retrieve)
payable(address(victim)).transfer(1 ether);
```
**Post-Cancun (EIP-6780):** Code remains if destroyed in different transaction, funds not lost.
### Metamorphic Contracts (Pre-Cancun)
**Attack:** Deploy malicious contract, destroy, redeploy different code at same address
```solidity theme={null}
// 1. Deploy benign contract at address A
CREATE2(salt, bytecode1) → address A
// 2. Get users to trust address A
// 3. Destroy contract
selfdestruct(owner)
// 4. Deploy malicious contract at SAME address A
CREATE2(salt, bytecode2) → address A (same!)
// 5. Malicious code now at trusted address
```
**Mitigation:** EIP-6780 prevents code deletion after creation transaction, making this impossible.
### Reentrancy via Forced ETH Send
```solidity theme={null}
contract Vulnerable {
mapping(address => uint256) public balances;
function withdraw() external {
uint256 amount = balances[msg.sender];
// Attacker selfdestructs, forcibly sending ETH here
// This triggers receive(), which can reenter before state update
balances[msg.sender] = 0; // Too late!
}
receive() external payable {
// Attacker reenters withdraw() with balance still set
}
}
```
**Mitigation:** Checks-effects-interactions pattern.
## Alternatives (Recommended)
### 1. Transfer Balance via CALL
```solidity theme={null}
contract Modern {
function close() external {
require(msg.sender == owner);
// Send balance
(bool success, ) = owner.call{value: address(this).balance}("");
require(success);
// Mark disabled in storage
disabled = true;
}
modifier notDisabled() {
require(!disabled, "Contract disabled");
_;
}
}
```
### 2. Proxy Pattern
```solidity theme={null}
// Upgradeable proxy - "destroy" by upgrading to empty implementation
contract Proxy {
address public implementation;
function upgrade(address newImpl) external {
implementation = newImpl; // Set to 0x0 to "destroy"
}
fallback() external payable {
address impl = implementation;
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
}
```
### 3. Circuit Breaker
```solidity theme={null}
contract Pausable {
bool public paused;
modifier whenNotPaused() {
require(!paused, "Paused");
_;
}
function pause() external onlyOwner {
paused = true;
}
}
```
## Implementation
```typescript theme={null}
/**
* SELFDESTRUCT opcode (0xff)
*/
export function selfdestruct(frame: FrameType): EvmError | null {
// Pop recipient address
if (frame.stack.length < 1) return { type: "StackUnderflow" };
const recipient = frame.stack.pop()!;
// Calculate gas cost
const baseCost = 5000n;
const isCold = !frame.accessedAddresses.has(recipient);
const coldCost = isCold ? 25000n : 0n;
const balance = frame.balance;
const recipientExists = frame.host.accountExists(recipient);
const newAccountCost = (balance > 0n && !recipientExists) ? 25000n : 0n;
const totalCost = baseCost + coldCost + newAccountCost;
// Consume gas
frame.gasRemaining -= totalCost;
if (frame.gasRemaining < 0n) {
frame.gasRemaining = 0n;
return { type: "OutOfGas" };
}
// Transfer balance
frame.host.transfer(frame.address, recipient, balance);
// Post-Cancun (EIP-6780): Only delete if created in same transaction
if (frame.hardfork >= Hardfork.CANCUN) {
if (frame.createdInTransaction) {
frame.host.markForDeletion(frame.address);
}
} else {
// Pre-Cancun: Always mark for deletion
frame.host.markForDeletion(frame.address);
}
// Halt execution
frame.stopped = true;
return null;
}
```
## Testing
```typescript theme={null}
describe('SELFDESTRUCT opcode', () => {
it('should transfer balance and mark for deletion (pre-Cancun)', () => {
const frame = createFrame({
stack: [recipientAddress],
balance: 1000n,
hardfork: Hardfork.LONDON
});
selfdestruct(frame);
expect(frame.stopped).toBe(true);
expect(host.getBalance(recipientAddress)).toBe(1000n);
expect(host.isMarkedForDeletion(frame.address)).toBe(true);
});
it('should NOT delete code if created in different transaction (Cancun)', () => {
const frame = createFrame({
stack: [recipientAddress],
hardfork: Hardfork.CANCUN,
createdInTransaction: false
});
selfdestruct(frame);
expect(frame.stopped).toBe(true);
expect(host.isMarkedForDeletion(frame.address)).toBe(false); // Not deleted!
});
it('should charge cold access cost', () => {
const frame = createFrame({
stack: [coldAddress],
accessedAddresses: new Set()
});
const gasBefore = frame.gasRemaining;
selfdestruct(frame);
const gasUsed = gasBefore - frame.gasRemaining;
expect(gasUsed).toBe(30000n); // 5000 + 25000 cold
});
});
```
## Benchmarks
| Scenario | Gas Cost |
| --------------------------- | -------- |
| Warm recipient, exists | 5,000 |
| Cold recipient, exists | 30,000 |
| Cold recipient, new account | 55,000 |
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.4
* [evm.codes - SELFDESTRUCT](https://www.evm.codes/#ff)
* [EIP-6049](https://eips.ethereum.org/EIPS/eip-6049) - Deprecation notice
* [EIP-6780](https://eips.ethereum.org/EIPS/eip-6780) - SELFDESTRUCT behavior change (Cancun)
* [EIP-4758](https://eips.ethereum.org/EIPS/eip-4758) - Proposed removal
* [EIP-3529](https://eips.ethereum.org/EIPS/eip-3529) - Reduced refunds (London)
## Related Documentation
* [CREATE](/evm/instructions/system/create) - Contract creation
* [CREATE2](/evm/instructions/system/create2) - Deterministic creation
* [CALL](/evm/instructions/system/call) - External calls (alternative for balance transfer)
# STATICCALL (0xfa)
Source: https://voltaire.tevm.sh/evm/instructions/system/staticcall
Read-only message call with state modification protection - foundation for view/pure functions
**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:** `0xfa`
**Introduced:** Byzantium (EIP-214)
STATICCALL executes code from another account with state modification restrictions enforced. Any attempt to modify state (SSTORE, CREATE, CALL with value, SELFDESTRUCT, LOG, etc.) reverts the entire call. This enables secure read-only operations and implements Solidity's view and pure function semantics.
## Specification
**Stack Input:**
```
gas (max gas to forward)
address (target account to call)
inOffset (calldata memory offset)
inLength (calldata size)
outOffset (returndata memory offset)
outLength (returndata size)
```
**Stack Output:**
```
success (1 if call succeeded, 0 if failed/reverted)
```
**Gas Cost:** 700 + cold\_access + memory\_expansion
**Operation:**
```
calldata = memory[inOffset:inOffset+inLength]
success = static_call(address, calldata, gas * 63/64) // Sets is_static flag
memory[outOffset:outOffset+outLength] = returndata[0:min(outLength, returndata.length)]
push(success)
```
## Behavior
STATICCALL performs a read-only external call with state protection:
1. **Pop 6 stack arguments** (no value parameter)
2. **Calculate gas cost:**
* Base: 700 gas (Tangerine Whistle+)
* Cold access: +2,600 gas for first access (Berlin+)
* Memory expansion for input and output regions
3. **Read calldata** from memory
4. **Forward gas:** Up to 63/64 of remaining gas (EIP-150)
5. **Execute in callee context with static flag:**
* msg.sender = caller address
* msg.value = 0 (always zero!)
* Storage = callee's storage (READ-ONLY)
* Code = callee's code
* is\_static = true (inherited by child calls)
6. **Enforce read-only restrictions:**
* SSTORE reverts (storage modification)
* CREATE/CREATE2 revert (contract creation)
* CALL with value > 0 reverts (ETH transfer)
* SELFDESTRUCT reverts (account deletion)
* LOG0-LOG4 revert (event emission)
7. **Copy returndata** to memory
8. **Set return\_data** buffer
9. **Push success flag**
10. **Refund unused gas**
**Key characteristics:**
* No value transfer (msg.value always 0)
* State modifications forbidden (enforced recursively)
* Safe for untrusted code execution
* Foundation for view/pure functions
## Examples
### Basic Static Call
```typescript theme={null}
import { STATICCALL } from '@tevm/voltaire/evm/system';
import { Address } from '@tevm/voltaire/primitives';
const frame = createFrame({
gasRemaining: 1000000n,
address: Address("0x1234..."),
});
// Call view function: balanceOf(address)
const calldata = new Uint8Array([
0x70, 0xa0, 0x82, 0x31, // balanceOf(address) selector
// ... ABI-encoded address parameter
]);
// Write calldata to memory
for (let i = 0; i < calldata.length; i++) {
frame.memory.set(i, calldata[i]);
}
// Stack: [gas=100000, address, inOffset=0, inLength=36, outOffset=0, outLength=32]
frame.stack.push(32n); // outLength
frame.stack.push(0n); // outOffset
frame.stack.push(36n); // inLength
frame.stack.push(0n); // inOffset
frame.stack.push(BigInt("0x742d35Cc...")); // target address
frame.stack.push(100000n); // gas
const err = STATICCALL(frame);
console.log(frame.stack[0]); // 1n if success, 0n if failed
console.log(frame.return_data); // Balance (uint256)
// In callee:
// - msg.value = 0 (always)
// - Any SSTORE, CREATE, LOG, etc. will revert
// - is_static flag set (inherited by nested calls)
```
### View Function Call
```solidity theme={null}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
contract Reader {
// Safe read-only call to ERC20
function getBalance(
address token,
address account
) external view returns (uint256) {
// Solidity automatically uses STATICCALL for view functions
return IERC20(token).balanceOf(account);
}
// Manual static call with assembly
function getBalanceAssembly(
address token,
address account
) external view returns (uint256) {
bytes memory callData = abi.encodeWithSelector(
IERC20.balanceOf.selector,
account
);
uint256 balance;
bool success;
assembly {
// STATICCALL(gas, address, inOffset, inLength, outOffset, outLength)
success := staticcall(
gas(),
token,
add(callData, 0x20),
mload(callData),
0,
32
)
if success {
balance := mload(0)
}
}
require(success, "Static call failed");
return balance;
}
}
```
### Multi-token Reader
```solidity theme={null}
contract TokenReader {
struct TokenInfo {
uint256 totalSupply;
uint256 userBalance;
string name;
string symbol;
uint8 decimals;
}
// Read multiple token properties in one call
function getTokenInfo(
address token,
address user
) external view returns (TokenInfo memory info) {
// All calls are STATICCALL (view context)
info.totalSupply = IERC20(token).totalSupply();
info.userBalance = IERC20(token).balanceOf(user);
info.name = IERC20Metadata(token).name();
info.symbol = IERC20Metadata(token).symbol();
info.decimals = IERC20Metadata(token).decimals();
}
// Batch read multiple tokens
function batchGetBalances(
address[] calldata tokens,
address user
) external view returns (uint256[] memory balances) {
balances = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++) {
balances[i] = IERC20(tokens[i]).balanceOf(user);
}
}
}
```
### Safe Untrusted Call
```solidity theme={null}
contract SafeReader {
// Call untrusted contract safely (no state changes possible)
function safeQuery(
address untrusted,
bytes memory data
) external view returns (bool success, bytes memory result) {
assembly {
// Allocate memory for return data
let ptr := mload(0x40)
// STATICCALL to untrusted contract
success := staticcall(
gas(),
untrusted,
add(data, 0x20),
mload(data),
0,
0
)
// Copy return data
let size := returndatasize()
result := ptr
mstore(result, size)
returndatacopy(add(result, 0x20), 0, size)
mstore(0x40, add(add(result, 0x20), size))
}
// Even if untrusted contract is malicious:
// - Cannot modify state
// - Cannot transfer ETH
// - Cannot emit events
// Worst case: returns wrong data or reverts
}
}
```
### Price Oracle Reader
```solidity theme={null}
interface IPriceOracle {
function getPrice(address token) external view returns (uint256);
}
contract PriceAggregator {
address[] public oracles;
// Get median price from multiple oracles (all static calls)
function getMedianPrice(address token) external view returns (uint256) {
require(oracles.length > 0, "No oracles");
uint256[] memory prices = new uint256[](oracles.length);
uint256 validPrices = 0;
for (uint256 i = 0; i < oracles.length; i++) {
try IPriceOracle(oracles[i]).getPrice(token) returns (uint256 price) {
prices[validPrices] = price;
validPrices++;
} catch {
// Oracle failed, skip
}
}
require(validPrices > 0, "No valid prices");
// Sort and return median
return _median(prices, validPrices);
}
function _median(uint256[] memory prices, uint256 length) internal pure returns (uint256) {
// Sort and return median
// Implementation omitted for brevity
}
}
```
## Gas Cost
**Total cost:** 700 + cold\_access + memory\_expansion + forwarded\_gas
### Base Cost: 700 gas (Tangerine Whistle+)
**Pre-Tangerine Whistle:** STATICCALL didn't exist (introduced Byzantium).
### No Value Transfer Cost
STATICCALL never transfers value:
```
// No CallValueTransferGas (msg.value always 0)
// No CallNewAccountGas
```
### Cold Access: +2,600 gas (Berlin+)
**EIP-2929 (Berlin+):** First access to target address:
```
if (firstAccess(address)) {
cost += 2600 // ColdAccountAccess
} else {
cost += 100 // WarmStorageRead
}
```
**Pre-Berlin:** No access list costs.
### Memory Expansion
Same as CALL - charges for both input and output regions:
```typescript theme={null}
const inEnd = inOffset + inLength;
const outEnd = outOffset + outLength;
const maxEnd = Math.max(inEnd, outEnd);
const words = Math.ceil(maxEnd / 32);
const expansionCost = words ** 2 / 512 + 3 * words;
```
### Gas Forwarding (EIP-150)
**63/64 rule applies:**
```
remaining_after_charge = gas_remaining - base_cost
max_forwarded = remaining_after_charge - (remaining_after_charge / 64)
actual_forwarded = min(gas_parameter, max_forwarded)
```
### Example Calculation
```typescript theme={null}
// STATICCALL to read function, cold access
const gasRemaining = 100000n;
const inLength = 36; // balanceOf(address)
const outLength = 32; // uint256 return
// Base cost
let cost = 700n; // Byzantium+
// No value transfer cost
// Cold access (Berlin+, first access)
cost += 2600n; // ColdAccountAccess
// Memory expansion (clean memory)
const maxEnd = Math.max(36, 32); // 36 bytes
const words = Math.ceil(36 / 32); // 2 words
const memCost = Math.floor(words ** 2 / 512) + 3 * words; // 6 gas
cost += BigInt(memCost);
// Total charged: 3,306 gas
// Gas forwarding
const afterCharge = gasRemaining - cost; // 96,694 gas
const maxForward = afterCharge - afterCharge / 64n; // 95,184 gas
// Total consumed: 3,306 + gas_used_by_callee
```
## Common Usage
### Safe Contract Query
```solidity theme={null}
contract QueryHelper {
// Query arbitrary contract safely
function query(
address target,
bytes memory data
) external view returns (bytes memory) {
(bool success, bytes memory result) = target.staticcall(data);
require(success, "Query failed");
return result;
}
// Query with try/catch
function tryQuery(
address target,
bytes memory data
) external view returns (bool success, bytes memory result) {
(success, result) = target.staticcall(data);
}
}
```
### View Function Multicall
```solidity theme={null}
contract Multicall {
struct Call {
address target;
bytes callData;
}
// Execute multiple view calls in one transaction
function aggregate(
Call[] memory calls
) external view returns (bytes[] memory results) {
results = new bytes[](calls.length);
for (uint256 i = 0; i < calls.length; i++) {
(bool success, bytes memory result) = calls[i].target.staticcall(
calls[i].callData
);
require(success, "Call failed");
results[i] = result;
}
}
// Aggregate with failure tolerance
function tryAggregate(
Call[] memory calls
) external view returns (bool[] memory successes, bytes[] memory results) {
successes = new bool[](calls.length);
results = new bytes[](calls.length);
for (uint256 i = 0; i < calls.length; i++) {
(successes[i], results[i]) = calls[i].target.staticcall(
calls[i].callData
);
}
}
}
```
### Contract Existence Check
```solidity theme={null}
contract ExistenceChecker {
// Check if contract exists and has code
function exists(address target) external view returns (bool) {
uint256 size;
assembly {
size := extcodesize(target)
}
return size > 0;
}
// Check if contract implements interface (ERC165)
function supportsInterface(
address target,
bytes4 interfaceId
) external view returns (bool) {
bytes memory data = abi.encodeWithSelector(
IERC165.supportsInterface.selector,
interfaceId
);
(bool success, bytes memory result) = target.staticcall(data);
return success && result.length == 32 && abi.decode(result, (bool));
}
}
```
## Security
### State Modification Prevention
STATICCALL enforces read-only semantics:
```solidity theme={null}
contract Malicious {
uint256 public value;
function maliciousView() external view returns (uint256) {
// This compiles but REVERTS at runtime when called via STATICCALL
value = 42; // SSTORE in static context!
return value;
}
}
contract Caller {
function callView(address target) external view returns (uint256) {
// Calls Malicious.maliciousView() via STATICCALL
// Reverts because maliciousView() attempts SSTORE
return Malicious(target).maliciousView();
}
}
```
**Protected operations (revert in static context):**
* SSTORE (storage write)
* CREATE/CREATE2 (contract creation)
* CALL with value > 0 (ETH transfer)
* SELFDESTRUCT (account deletion)
* LOG0-LOG4 (event emission)
### Read-Only Guarantee
STATICCALL guarantees no state changes:
```solidity theme={null}
// SAFE: State cannot be modified via static call
contract SafeReader {
function readUntrusted(address target) external view returns (bytes memory) {
(bool success, bytes memory data) = target.staticcall("");
// Even if target is malicious:
// - Cannot modify storage
// - Cannot create contracts
// - Cannot transfer ETH
// - Cannot emit events
// Worst case: returns bad data or reverts
require(success, "Call failed");
return data;
}
}
```
### Gas Limit Attacks
Callee still controls gas consumption:
```solidity theme={null}
// VULNERABLE: Unbounded gas consumption
function dangerousQuery(address target, bytes memory data) external view returns (bytes memory) {
// Forwards 63/64 of all remaining gas
(bool success, bytes memory result) = target.staticcall(data);
require(success);
return result; // Callee could consume all gas
}
// BETTER: Limit forwarded gas
function limitedQuery(address target, bytes memory data) external view returns (bytes memory) {
(bool success, bytes memory result) = target.staticcall{gas: 100000}(data);
require(success);
return result;
}
```
### Returndata Bomb
Large returndata can cause OOG when copying:
```solidity theme={null}
// VULNERABLE: Unbounded returndata
function unsafeQuery(address target) external view returns (bytes memory) {
(, bytes memory data) = target.staticcall("");
return data; // Might copy gigabytes!
}
// SAFE: Limit returndata size
function safeQuery(address target) external view returns (bytes memory) {
(bool success, ) = target.staticcall("");
require(success);
// Manual copy with size limit
uint256 size = min(returndatasize(), 1024);
bytes memory data = new bytes(size);
assembly {
returndatacopy(add(data, 32), 0, size)
}
return data;
}
```
### Reentrancy (Still Possible!)
Read-only reentrancy is possible:
```solidity theme={null}
// VULNERABLE: Read-only reentrancy
contract Vault {
mapping(address => uint256) public balances;
function withdraw() external {
uint256 amount = balances[msg.sender];
// VULNERABILITY: External call before state update
(bool success, ) = msg.sender.call{value: amount}("");
require(success);
balances[msg.sender] = 0; // Too late!
}
function getBalance(address user) external view returns (uint256) {
return balances[user]; // Can be called during reentrancy!
}
}
contract Attacker {
Vault vault;
Oracle oracle;
receive() external payable {
// During withdraw, balance not yet updated
uint256 balance = vault.getBalance(address(this)); // STATICCALL
// Oracle sees inflated balance!
oracle.updatePrice(balance);
}
}
```
**Mitigation: Checks-Effects-Interactions pattern.**
## Implementation
```typescript theme={null}
/**
* STATICCALL opcode (0xfa)
* Read-only message call with state protection
*/
export function staticcall(frame: FrameType): EvmError | null {
// Pop 6 arguments (no value)
const gas = popStack(frame);
const address = popStack(frame);
const inOffset = popStack(frame);
const inLength = popStack(frame);
const outOffset = popStack(frame);
const outLength = popStack(frame);
// Calculate gas cost
let gasCost = 700n; // Base
// No value transfer cost
// Cold access cost (Berlin+)
const accessCost = getAccessCost(address);
gasCost += accessCost;
// Memory expansion
const inEnd = inLength > 0 ? inOffset + inLength : 0;
const outEnd = outLength > 0 ? outOffset + outLength : 0;
const maxEnd = Math.max(inEnd, outEnd);
if (maxEnd > 0) {
gasCost += memoryExpansionCost(frame, maxEnd);
updateMemorySize(frame, maxEnd);
}
// Calculate forwarded gas (63/64 rule)
const afterCharge = frame.gasRemaining - gasCost;
const maxForward = afterCharge - afterCharge / 64n;
const forwardedGas = min(gas, maxForward);
// Charge total cost
consumeGas(frame, gasCost + forwardedGas);
// Read calldata
const calldata = readMemory(frame, inOffset, inLength);
// Execute static call (set is_static flag!)
const result = executeStaticCall({
target: address,
data: calldata,
gas: forwardedGas,
isStatic: true // Enforces read-only
});
// Refund unused gas
frame.gasRemaining += result.gasLeft;
// Copy returndata
const copySize = min(outLength, result.returnData.length);
writeMemory(frame, outOffset, result.returnData.slice(0, copySize));
// Set return_data buffer
frame.returnData = result.returnData;
// Push success flag
pushStack(frame, result.success ? 1n : 0n);
frame.pc += 1;
return null;
}
```
## References
* **[Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)** - Section 9.4.4 (STATICCALL)
* **[EIP-214](https://eips.ethereum.org/EIPS/eip-214)** - STATICCALL opcode and static mode
* **[EIP-150](https://eips.ethereum.org/EIPS/eip-150)** - Gas cost changes (63/64 rule)
* **[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)** - Access list gas costs
* **[evm.codes - STATICCALL](https://www.evm.codes/#fa)** - Interactive reference
* **[Solidity Docs](https://docs.soliditylang.org/)** - View and pure functions
# 0x09 Blake2f
Source: https://voltaire.tevm.sh/evm/precompiles/blake2f
Blake2b compression function for efficient hashing
**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
**Address:** `0x0000000000000000000000000000000000000009`
**Introduced:** Istanbul (EIP-152)
**EIP:** [EIP-152](https://eips.ethereum.org/EIPS/eip-152)
The Blake2f precompile implements the Blake2b compression function F, the core building block of the Blake2b cryptographic hash function. Unlike other hash precompiles that compute complete hashes, Blake2f exposes the low-level compression step, giving smart contracts fine-grained control over Blake2b hashing. This enables efficient verification of Zcash Equihash proofs and cross-chain bridges to Blake2-based blockchains.
Blake2 is a modern cryptographic hash function that's faster than MD5, SHA-1, SHA-2, and SHA-3 while maintaining strong security guarantees. It's widely used in Zcash, Monero, IPFS, and Wireguard. The "b" variant (Blake2b) operates on 64-bit words and produces up to 512-bit (64-byte) hashes.
By exposing the compression function directly, this precompile allows contracts to implement custom Blake2b variants (different initialization vectors, personalization strings, or tree hashing) without requiring new precompiles for each variant.
## Gas Cost
**Formula:** `rounds` (1 gas per round)
The number of rounds is specified in the input (first 4 bytes). Common values:
* Blake2b standard: 12 rounds
* Reduced round versions: 1-12 rounds
* Maximum: 2^32 - 1 rounds (4,294,967,295 gas)
**Examples:**
* 0 rounds: 0 gas
* 12 rounds: 12 gas
* 1000 rounds: 1000 gas
## Input Format
**Exactly 213 bytes required:**
```
Offset | Length | Description
-------|--------|-------------
0 | 4 | rounds (big-endian u32)
4 | 64 | h (state vector, 8x u64 little-endian)
68 | 128 | m (message block, 16x u64 little-endian)
196 | 16 | t (offset counters, 2x u64 little-endian)
212 | 1 | f (final block flag, 0x00 or 0x01)
```
Total input length: **Exactly 213 bytes** (no padding, no truncation)
All multi-byte integers except rounds are little-endian.
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | h (new state vector, 8x u64 little-endian)
```
Total output length: 64 bytes
Output is the updated Blake2b state after applying the compression function.
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import * as Hex from '@tevm/voltaire/Hex';
// Blake2b compression with 12 rounds (standard)
const input = new Uint8Array(213);
// Set rounds (big-endian)
const view = new DataView(input.buffer);
view.setUint32(0, 12, false); // 12 rounds, big-endian
// Set state vector h - Blake2b-512 IV (8 x u64, little-endian)
const iv = [
0x6a09e667f3bcc908n, 0xbb67ae8584caa73bn, 0x3c6ef372fe94f82bn, 0xa54ff53a5f1d36f1n,
0x510e527fade682d1n, 0x9b05688c2b3e6c1fn, 0x1f83d9abfb41bd6bn, 0x5be0cd19137e2179n
];
iv.forEach((val, i) => view.setBigUint64(4 + i * 8, val, true));
// Set message block m (128 bytes, example data)
const message = Hex('0x48656c6c6f20426c616b6532622100' + '00'.repeat(115));
input.set(message, 68);
// Set offset counters t (little-endian u64s)
view.setBigUint64(196, 128n, true); // t0 = 128 (processed bytes)
view.setBigUint64(204, 0n, true); // t1 = 0
// Set final flag f
input[212] = 0x00; // Not final block
const result = execute(
PrecompileAddress.BLAKE2F,
input,
20n, // Need at least 12 gas for 12 rounds
Hardfork.CANCUN
);
if (result.success) {
console.log('New state:', result.output);
console.log('Gas used:', result.gasUsed); // 12
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Input length ≠ 213 bytes (exact length required)
* Out of gas (gasLimit \< rounds)
* Invalid final flag (not 0x00 or 0x01)
## Use Cases
**Production Applications:**
* **Zcash Bridge:** Verify Zcash Equihash proofs on Ethereum to enable trustless ZEC/ETH swaps. Equihash is a memory-hard proof-of-work algorithm based on Blake2b. The bridge contract uses Blake2f to verify Zcash block headers.
* **Cross-chain Bridges:** Validate headers from blockchains using Blake2b:
* **Filecoin:** Uses Blake2b for hashing (bridge to Ethereum)
* **Sia/Siacoin:** Blake2b-based storage network
* **Decred:** Uses Blake256 (related to Blake2)
* **Efficient Hashing in Contracts:** Blake2b is \~10x cheaper than SHA256 per byte:
* Large data structure hashing (Merkle trees)
* Content-addressed storage systems
* Efficient MACs and authenticated encryption
* **Custom Blake2 Variants:**
* **Personalized hashing:** Domain separation for different protocols
* **Tree hashing:** BLAKE2bp parallel variant
* **Keyed hashing:** HMAC-like authentication
**Real-World Example:** A Zcash-Ethereum bridge uses Blake2f to verify \~100 Zcash blocks (\~10,000 Blake2f calls) for \~120,000 gas total, versus millions of gas if implemented in pure Solidity.
## Implementation Details
* **Zig:** Uses Blake2 crypto module implementing RFC 7693
* **TypeScript:** Wrapper around Blake2 compression function
* **Integration:** Standalone Blake2b F function
* **Algorithm:** Blake2b compression as specified in RFC 7693
* **Rounds:** Configurable (standard Blake2b uses 12)
## Blake2b Algorithm Overview
**What is Blake2b?**
Blake2b is a cryptographic hash function designed to be faster than MD5, SHA-1, SHA-2, and SHA-3 while maintaining strong security. It's the 64-bit variant of Blake2 (Blake2s is the 32-bit variant).
**Key Features:**
* **Performance:** Up to 2x faster than SHA-3, comparable to MD5
* **Security:** No known cryptographic weaknesses (finalist in SHA-3 competition)
* **Flexibility:** Configurable output length, keyed hashing, salting, personalization
* **Simplicity:** Simpler than SHA-3, easier to implement and audit
**Standard Blake2b Parameters:**
* **Rounds:** 12 rounds per 128-byte block (can be reduced for performance/security tradeoff)
* **Output:** Up to 512 bits (64 bytes), configurable
* **Block size:** 128 bytes (1024 bits)
* **Word size:** 64-bit (unlike Blake2s which uses 32-bit)
* **State:** 8 x 64-bit words (512 bits total)
**Compression Function F:**
The compression function F is the core of Blake2b. It takes:
* Current state `h` (8 x 64-bit words)
* Message block `m` (16 x 64-bit words = 128 bytes)
* Offset counters `t` (2 x 64-bit words, tracks bytes processed)
* Final block flag `f` (1 byte, marks last block)
And produces a new state `h'` by mixing the message into the state over multiple rounds.
## Complete Blake2b Hashing
To hash a message completely using Blake2f:
1. Initialize state h with Blake2b IV
2. Process each 128-byte block:
* Call Blake2f with current state
* Update offset counter t
3. Final block: set f=0x01
4. State h is the hash output
```typescript theme={null}
// Simplified Blake2b using Blake2f precompile
function blake2b(message: Uint8Array): Uint8Array {
let h = blake2bIV(); // Initial state
let t = 0n;
const blocks = Math.ceil(message.length / 128);
for (let i = 0; i < blocks; i++) {
const block = message.slice(i * 128, (i + 1) * 128);
const input = encodeBlake2fInput({
rounds: 12,
h: h,
m: padTo128(block),
t: [t + BigInt(block.length), 0n],
f: i === blocks - 1 ? 1 : 0
});
const result = executeBlake2f(input);
h = result.output;
t += BigInt(block.length);
}
return h; // 64-byte hash
}
```
## Gas Cost Efficiency
Blake2f is extremely gas-efficient:
* 12 rounds = 12 gas
* Processes 128 bytes per compression
* \~0.09 gas/byte (cheaper than all other hash functions)
Comparison (per 128 bytes):
* Blake2f: \~12 gas
* SHA256: \~108 gas (60 + 12\*4)
* Keccak256: \~66 gas (30 + 6\*4)
## Test Vectors
From RFC 7693 and EIP-152 official test suite:
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import * as Hex from '@tevm/voltaire/Hex';
// Vector 1: Empty message hash
// Hash of empty string with Blake2b should produce specific known output
const input1 = Hex(
'0x0000000c' + // rounds = 12
'6a09e667f2bcc948bb67ae8584caa73b3c6ef372fe94f82ba54ff53a5f1d36f1' + // h (IV XOR params)
'510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b5be0cd19137e2179' +
'00'.repeat(128) + // m (empty message)
'0000000000000000' + '0000000000000000' + // t = [0, 0]
'01' // f = final
);
const result1 = execute(PrecompileAddress.BLAKE2F, input1, 20n, Hardfork.CANCUN);
// result1.gasUsed === 12
// result1.output should match known Blake2b("") hash
// Vector 2: "abc" message hash
// Standard test vector - hash of "abc"
const input2 = Hex(
'0x0000000c' + // rounds = 12
'6a09e667f2bcc948bb67ae8584caa73b3c6ef372fe94f82ba54ff53a5f1d36f1' + // h (IV XOR params)
'510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b5be0cd19137e2179' +
'616263' + '00'.repeat(125) + // m = "abc" padded to 128 bytes
'0300000000000000' + '0000000000000000' + // t = [3, 0]
'01' // f = final
);
const result2 = execute(PrecompileAddress.BLAKE2F, input2, 20n, Hardfork.CANCUN);
// result2.gasUsed === 12
// Expected output (Blake2b("abc")):
// 0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d1
// 7d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923
// Vector 3: Variable rounds (1 round only)
// Tests gas calculation - should cost 1 gas
const input3 = Hex(
'0x00000001' + // rounds = 1
'6a09e667f2bcc948bb67ae8584caa73b3c6ef372fe94f82ba54ff53a5f1d36f1' + // h
'510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b5be0cd19137e2179' +
'00'.repeat(128) + // m
'0000000000000000' + '0000000000000000' + // t
'01' // f
);
const result3 = execute(PrecompileAddress.BLAKE2F, input3, 10n, Hardfork.CANCUN);
// result3.gasUsed === 1
// Vector 4: Maximum rounds
// Tests high round counts (Zcash uses higher round counts)
const input4 = Hex(
'0x00002710' + // rounds = 10000
'6a09e667f2bcc948bb67ae8584caa73b3c6ef372fe94f82ba54ff53a5f1d36f1' + // h
'510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b5be0cd19137e2179' +
'00'.repeat(128) + // m
'0000000000000000' + '0000000000000000' + // t
'01' // f
);
const result4 = execute(PrecompileAddress.BLAKE2F, input4, 15000n, Hardfork.CANCUN);
// result4.gasUsed === 10000
```
## Byte Order Warning
Blake2f uses **little-endian** for h, m, t (unlike most Ethereum precompiles).
Only rounds is big-endian. This matches Blake2b specification but differs from Ethereum convention.
## Related
* [Crypto: Blake2](/crypto/blake2)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E
* [EIP-152: Add BLAKE2 compression function F precompile](https://eips.ethereum.org/EIPS/eip-152)
* [RFC 7693: The BLAKE2 Cryptographic Hash and MAC](https://tools.ietf.org/html/rfc7693)
* [Zcash Protocol Specification](https://zips.z.cash/protocol/protocol.pdf)
# BLS12-381 Precompiles (EIP-2537)
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-381/index
Nine precompiles for BLS12-381 curve operations enabling efficient signature aggregation
**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
**Addresses:** `0x0B` - `0x13`
**Introduced:** Prague (planned)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
BLS12-381 is a pairing-friendly elliptic curve enabling efficient signature aggregation for Ethereum 2.0 consensus. These 9 precompiles provide gas-efficient operations on the BLS12-381 curve, supporting:
* BLS signature aggregation for Ethereum 2.0 validators
* Threshold signatures (t-of-n signing schemes)
* Blind signatures and anonymous credentials
* Verifiable random functions (VRFs)
* Advanced cryptographic protocols requiring pairings
## Curve Overview
**BLS12-381** is a pairing-friendly elliptic curve with:
* **Field modulus (p):** 381-bit prime
* **Curve order (r):** 255-bit prime subgroup
* **Embedding degree:** 12 (enables efficient pairings)
* **Security level:** 128-bit (comparable to AES-128)
The curve has two groups:
* **G1:** Points over the base field Fp (128 bytes uncompressed)
* **G2:** Points over the extension field Fp2 (256 bytes uncompressed)
**Pairing:** A bilinear map `e: G1 × G2 → GT` that enables verification of complex cryptographic relationships.
## Precompile Summary
| Address | Name | Gas | Input Size | Output Size | Description |
| ------- | ---------------- | -------------- | ---------- | ----------- | --------------------------------- |
| 0x0B | G1\_ADD | 500 | 256 | 128 | Add two G1 points |
| 0x0C | G1\_MUL | 12000 | 160 | 128 | Multiply G1 point by scalar |
| 0x0D | G1\_MSM | variable | 160k | 128 | Multi-scalar multiplication on G1 |
| 0x0E | G2\_ADD | 800 | 512 | 256 | Add two G2 points |
| 0x0F | G2\_MUL | 45000 | 288 | 256 | Multiply G2 point by scalar |
| 0x10 | G2\_MSM | variable | 288k | 256 | Multi-scalar multiplication on G2 |
| 0x11 | PAIRING | 65000 + 43000k | 384k | 32 | Pairing check (k pairs) |
| 0x12 | MAP\_FP\_TO\_G1 | 5500 | 64 | 128 | Hash to G1 (map field element) |
| 0x13 | MAP\_FP2\_TO\_G2 | 75000 | 128 | 256 | Hash to G2 (map Fp2 element) |
## Detailed Specifications
### 0x0B: G1\_ADD
Add two points on the G1 curve.
**Gas Cost:** 500
**Input:** 256 bytes
* Bytes 0-127: First G1 point (x₁, y₁)
* Bytes 0-63: x-coordinate (big-endian, 48-byte field element padded to 64)
* Bytes 64-127: y-coordinate (big-endian, 48-byte field element padded to 64)
* Bytes 128-255: Second G1 point (x₂, y₂)
**Output:** 128 bytes
* G1 point representing P₁ + P₂
**Operation:** Elliptic curve point addition on G1. Point at infinity encoded as (0, 0).
**Errors:**
* Invalid input length (not 256 bytes)
* Points not on curve
* Out of gas
***
### 0x0C: G1\_MUL
Multiply a G1 point by a scalar.
**Gas Cost:** 12000
**Input:** 160 bytes
* Bytes 0-127: G1 point (x, y)
* Bytes 0-63: x-coordinate
* Bytes 64-127: y-coordinate
* Bytes 128-159: Scalar (32 bytes, big-endian)
**Output:** 128 bytes
* G1 point representing scalar × P
**Operation:** Scalar multiplication on G1. Scalar is reduced modulo curve order.
**Errors:**
* Invalid input length (not 160 bytes)
* Point not on curve
* Out of gas
***
### 0x0D: G1\_MSM (Multi-Scalar Multiplication)
Compute a linear combination of G1 points: s₁P₁ + s₂P₂ + ... + sₖPₖ
**Gas Cost:** Variable with discount
```
gas = (12000 × k × discount) / 1000
```
where `k` = number of point-scalar pairs, and discount per tier:
| Pairs (k) | Discount | Gas per pair | | Pairs (k) | Discount | Gas per pair |
| --------- | -------- | ------------ | - | --------- | -------- | ------------ |
| 1 | 1000 | 12000 | | 16 | 320 | 3840 |
| 2 | 820 | 4920 | | 32 | 250 | 3000 |
| 4 | 580 | 3480 | | 64 | 200 | 2400 |
| 8 | 430 | 2580 | | 128+ | 174 | 2088 |
**Input:** 160k bytes (k point-scalar pairs)
* Each pair: 160 bytes
* Bytes 0-127: G1 point
* Bytes 128-159: Scalar (32 bytes)
**Output:** 128 bytes
* G1 point representing the sum
**Operation:** Optimized batch scalar multiplication with Pippenger's algorithm. Discount reflects batch efficiency.
**Errors:**
* Invalid input length (not multiple of 160)
* Empty input
* Point not on curve
* Out of gas
***
### 0x0E: G2\_ADD
Add two points on the G2 curve.
**Gas Cost:** 800
**Input:** 512 bytes
* Bytes 0-255: First G2 point (x₁, y₁)
* Bytes 0-127: x-coordinate (Fp2 element: c0 || c1, each 64 bytes)
* Bytes 128-255: y-coordinate (Fp2 element: c0 || c1, each 64 bytes)
* Bytes 256-511: Second G2 point (x₂, y₂)
**Output:** 256 bytes
* G2 point representing P₁ + P₂
**Operation:** Elliptic curve point addition on G2. Point at infinity encoded as all zeros.
**Errors:**
* Invalid input length (not 512 bytes)
* Points not on curve
* Out of gas
***
### 0x0F: G2\_MUL
Multiply a G2 point by a scalar.
**Gas Cost:** 45000
**Input:** 288 bytes
* Bytes 0-255: G2 point (x, y)
* Bytes 0-127: x-coordinate (Fp2)
* Bytes 128-255: y-coordinate (Fp2)
* Bytes 256-287: Scalar (32 bytes, big-endian)
**Output:** 256 bytes
* G2 point representing scalar × P
**Operation:** Scalar multiplication on G2. More expensive than G1 due to Fp2 arithmetic.
**Errors:**
* Invalid input length (not 288 bytes)
* Point not on curve
* Out of gas
***
### 0x10: G2\_MSM (Multi-Scalar Multiplication)
Compute a linear combination of G2 points: s₁P₁ + s₂P₂ + ... + sₖPₖ
**Gas Cost:** Variable with discount
```
gas = (45000 × k × discount) / 1000
```
Uses same discount table as G1\_MSM. Base cost is 45000 (G2\_MUL cost).
**Input:** 288k bytes (k point-scalar pairs)
* Each pair: 288 bytes
* Bytes 0-255: G2 point
* Bytes 256-287: Scalar (32 bytes)
**Output:** 256 bytes
* G2 point representing the sum
**Operation:** Optimized batch scalar multiplication on G2.
**Errors:**
* Invalid input length (not multiple of 288)
* Empty input
* Point not on curve
* Out of gas
***
### 0x11: BLS12\_PAIRING
Verify a pairing equation: e(P₁, Q₁) × e(P₂, Q₂) × ... × e(Pₖ, Qₖ) = 1
**Gas Cost:** 65000 + 43000k
* Base: 65000
* Per pair: 43000
**Input:** 384k bytes (k pairs, k ≥ 0)
* Each pair: 384 bytes
* Bytes 0-127: G1 point (128 bytes)
* Bytes 128-383: G2 point (256 bytes)
* Empty input (k=0) is valid and returns success
**Output:** 32 bytes
* Byte 31: 1 if pairing check succeeds, 0 otherwise
* Bytes 0-30: Zero padding
**Operation:** Compute optimal Ate pairing for each (G1, G2) pair, multiply results, check if product equals 1.
**Use Case:** BLS signature verification
* Verify: e(pubkey, H(msg)) = e(G1\_generator, signature)
* Input: \[G1\_generator, signature, -pubkey, H(msg)]
* Rearranged: e(G1, sig) × e(-pub, H) = 1
**Errors:**
* Invalid input length (not multiple of 384)
* Points not on curve
* Out of gas
***
### 0x12: BLS12\_MAP\_FP\_TO\_G1
Map a field element to a G1 point (hash-to-curve).
**Gas Cost:** 5500
**Input:** 64 bytes
* Field element in Fp (48-byte big-endian, padded to 64 bytes)
**Output:** 128 bytes
* G1 point
**Operation:** Deterministic hash-to-curve mapping using simplified SWU (Shallue-van de Woestijne-Ulas) method. Maps arbitrary field elements to valid curve points.
**Use Case:** Hash-to-curve for BLS signatures
* H(message) → G1 point for signing
**Errors:**
* Invalid input length (not 64 bytes)
* Field element ≥ field modulus
* Out of gas
***
### 0x13: BLS12\_MAP\_FP2\_TO\_G2
Map an Fp2 element to a G2 point (hash-to-curve).
**Gas Cost:** 75000
**Input:** 128 bytes
* Fp2 element (c0 || c1, each 64 bytes)
* Bytes 0-63: c0 component (48-byte field element padded to 64)
* Bytes 64-127: c1 component (48-byte field element padded to 64)
**Output:** 256 bytes
* G2 point
**Operation:** Deterministic hash-to-curve mapping for G2 using simplified SWU over Fp2.
**Use Case:** Hash messages to G2 for signature schemes where public keys are in G1.
**Errors:**
* Invalid input length (not 128 bytes)
* Field elements ≥ field modulus
* Out of gas
## Point Encoding
### G1 Point (128 bytes)
```
[x-coordinate (64 bytes)][y-coordinate (64 bytes)]
```
* Each coordinate: 48-byte big-endian field element, left-padded with 16 zero bytes
* Point at infinity: all zeros
### G2 Point (256 bytes)
```
[x.c0 (64)][x.c1 (64)][y.c0 (64)][y.c1 (64)]
```
* Each Fp2 element: two 48-byte field elements (c0, c1), each padded to 64 bytes
* Point at infinity: all zeros
### Field Element (Fp)
* 48-byte big-endian integer \< field modulus p
* Padded to 64 bytes with leading zeros
* p = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
## Complete BLS Signature Workflow
This example shows how multiple BLS12-381 precompiles work together for a complete signature verification:
```typescript theme={null}
import { execute, PrecompileAddress, Hardfork } from '@tevm/voltaire/precompiles';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
/**
* Complete BLS signature verification workflow
* Uses 5 precompiles: MAP_FP2_TO_G2, G1_MUL, G2_MUL, G1_ADD (optional), PAIRING
*/
// Step 1: Hash message to G2 point using MAP_FP2_TO_G2
function hashMessageToG2(message: Uint8Array): Uint8Array {
// Hash message to field elements (simplified - real impl uses hash_to_field)
const hash1 = Keccak256.hash(message);
const hash2 = Keccak256.hash(hash1);
// Create two Fp2 elements
const u0 = new Uint8Array(128);
u0.set(hash1, 96); // Place hash in lower 32 bytes of c0
const u1 = new Uint8Array(128);
u1.set(hash2, 96);
// Map both to G2 points
const q0 = execute(PrecompileAddress.BLS12_MAP_FP2_TO_G2, u0, 75000n, Hardfork.PRAGUE);
const q1 = execute(PrecompileAddress.BLS12_MAP_FP2_TO_G2, u1, 75000n, Hardfork.PRAGUE);
if (!q0.success || !q1.success) throw new Error('Hash-to-curve failed');
// Add points: H(m) = Q0 + Q1
const addInput = new Uint8Array(512);
addInput.set(q0.output, 0);
addInput.set(q1.output, 256);
const result = execute(PrecompileAddress.BLS12_G2_ADD, addInput, 800n, Hardfork.PRAGUE);
if (!result.success) throw new Error('G2 addition failed');
return result.output; // 256-byte G2 point: H(m)
}
// Step 2: Generate BLS signature: sig = sk * H(m)
function signMessage(secretKey: bigint, messageHash: Uint8Array): Uint8Array {
// messageHash is G2 point from hashMessageToG2
const input = new Uint8Array(288);
input.set(messageHash, 0); // G2 point (256 bytes)
// Encode scalar at offset 256
const scalarBytes = Bytes32();
for (let i = 0; i < 32; i++) {
scalarBytes[31 - i] = Number((secretKey >> BigInt(i * 8)) & 0xFFn);
}
input.set(scalarBytes, 256);
const result = execute(PrecompileAddress.BLS12_G2_MUL, input, 45000n, Hardfork.PRAGUE);
if (!result.success) throw new Error('Signing failed');
return result.output; // 256-byte signature in G2
}
// Step 3: Derive public key: PK = sk * G1
function derivePublicKey(secretKey: bigint): Uint8Array {
// G1 generator point (these are the actual BLS12-381 generator coordinates)
const g1Generator = new Uint8Array(128);
// x-coordinate (48 bytes, left-padded to 64)
g1Generator.set([
0x17, 0xf1, 0xd3, 0xa7, 0x31, 0x97, 0xd7, 0x94,
0x26, 0x95, 0x63, 0x8c, 0x4f, 0xa9, 0xac, 0x0f,
0xc3, 0x68, 0x8c, 0x4f, 0x97, 0x74, 0xb9, 0x05,
0xa1, 0x4e, 0x3a, 0x3f, 0x17, 0x1b, 0xac, 0x58,
0x6c, 0x55, 0xe8, 0x3f, 0xf9, 0x7a, 0x1a, 0xef,
0xfb, 0x3a, 0xf0, 0x0a, 0xdb, 0x22, 0xc6, 0xbb,
], 16);
// y-coordinate (48 bytes, left-padded to 64)
g1Generator.set([
0x08, 0xb3, 0xf4, 0x81, 0xe3, 0xaa, 0xa0, 0xf1,
0xa0, 0x9e, 0x30, 0xed, 0x74, 0x1d, 0x8a, 0xe4,
0xfc, 0xf5, 0xe0, 0x95, 0xd5, 0xd0, 0x0a, 0xf6,
0x00, 0xdb, 0x18, 0xcb, 0x2c, 0x04, 0xb3, 0xed,
0xd0, 0x3c, 0xc7, 0x44, 0xa2, 0x88, 0x8a, 0xe4,
0x0c, 0xaa, 0x23, 0x29, 0x46, 0xc5, 0xe7, 0xe1,
], 80);
const input = new Uint8Array(160);
input.set(g1Generator, 0);
// Encode scalar
const scalarBytes = Bytes32();
for (let i = 0; i < 32; i++) {
scalarBytes[31 - i] = Number((secretKey >> BigInt(i * 8)) & 0xFFn);
}
input.set(scalarBytes, 128);
const result = execute(PrecompileAddress.BLS12_G1_MUL, input, 12000n, Hardfork.PRAGUE);
if (!result.success) throw new Error('Public key derivation failed');
return result.output; // 128-byte public key in G1
}
// Step 4: Verify BLS signature using pairing check
// Check: e(PK, H(m)) = e(G1, sig)
// Rearranged: e(PK, H(m)) * e(-G1, sig) = 1
function verifySignature(
publicKey: Uint8Array, // 128 bytes (G1)
message: Uint8Array,
signature: Uint8Array // 256 bytes (G2)
): boolean {
// Hash message to G2
const messageHash = hashMessageToG2(message);
// Get negated G1 generator
const g1Generator = new Uint8Array(128);
g1Generator.set([
0x17, 0xf1, 0xd3, 0xa7, 0x31, 0x97, 0xd7, 0x94,
0x26, 0x95, 0x63, 0x8c, 0x4f, 0xa9, 0xac, 0x0f,
0xc3, 0x68, 0x8c, 0x4f, 0x97, 0x74, 0xb9, 0x05,
0xa1, 0x4e, 0x3a, 0x3f, 0x17, 0x1b, 0xac, 0x58,
0x6c, 0x55, 0xe8, 0x3f, 0xf9, 0x7a, 0x1a, 0xef,
0xfb, 0x3a, 0xf0, 0x0a, 0xdb, 0x22, 0xc6, 0xbb,
], 16);
// Negated y-coordinate (would need actual negation - simplified here)
g1Generator.set([
0x08, 0xb3, 0xf4, 0x81, 0xe3, 0xaa, 0xa0, 0xf1,
0xa0, 0x9e, 0x30, 0xed, 0x74, 0x1d, 0x8a, 0xe4,
0xfc, 0xf5, 0xe0, 0x95, 0xd5, 0xd0, 0x0a, 0xf6,
0x00, 0xdb, 0x18, 0xcb, 0x2c, 0x04, 0xb3, 0xed,
0xd0, 0x3c, 0xc7, 0x44, 0xa2, 0x88, 0x8a, 0xe4,
0x0c, 0xaa, 0x23, 0x29, 0x46, 0xc5, 0xe7, 0xe1,
], 80);
// Construct pairing input: 2 pairs (768 bytes)
const pairingInput = new Uint8Array(768);
// Pair 1: (PK, H(m))
pairingInput.set(publicKey, 0); // G1 point (128 bytes)
pairingInput.set(messageHash, 128); // G2 point (256 bytes)
// Pair 2: (-G1, sig)
pairingInput.set(g1Generator, 384); // G1 point (128 bytes)
pairingInput.set(signature, 512); // G2 point (256 bytes)
// Pairing check gas: 115,000 + 23,000 * 2 = 161,000
const result = execute(
PrecompileAddress.BLS12_PAIRING,
pairingInput,
161000n,
Hardfork.PRAGUE
);
if (!result.success) throw new Error('Pairing check failed');
// Check if pairing result is 1 (success)
return result.output[31] === 1;
}
// Complete workflow example
const secretKey = 12345678901234567890n;
const message = new TextEncoder().encode("Hello, BLS12-381!");
console.log("=== BLS Signature Workflow ===");
// 1. Derive public key
const publicKey = derivePublicKey(secretKey);
console.log("Public key generated (G1, 128 bytes)");
// 2. Hash message
const messageHash = hashMessageToG2(message);
console.log("Message hashed to G2 (256 bytes)");
// 3. Sign message
const signature = signMessage(secretKey, messageHash);
console.log("Signature generated (G2, 256 bytes)");
// 4. Verify signature
const isValid = verifySignature(publicKey, message, signature);
console.log("Signature valid:", isValid);
// Total gas used:
// - Hash to G2: 2 * 75,000 + 800 = 150,800
// - Derive PK: 12,000
// - Sign: 45,000
// - Verify (pairing): 161,000
// Total: ~368,800 gas for complete workflow
```
## Usage Examples
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress, Hardfork } from '@tevm/voltaire/precompiles';
// G1 Addition
const p1 = new Uint8Array(128); // First G1 point
const p2 = new Uint8Array(128); // Second G1 point
const addInput = new Uint8Array(256);
addInput.set(p1, 0);
addInput.set(p2, 128);
const result = execute(
PrecompileAddress.BLS12_G1_ADD,
addInput,
10000n,
Hardfork.PRAGUE
);
if (result.success) {
console.log('Sum:', result.output); // 128 bytes
console.log('Gas used:', result.gasUsed); // 500
}
// Multi-scalar multiplication (G1)
const k = 4; // 4 point-scalar pairs
const msmInput = new Uint8Array(160 * k);
// Fill with points and scalars...
const msmResult = execute(
PrecompileAddress.BLS12_G1_MSM,
msmInput,
50000n,
Hardfork.PRAGUE
);
// Gas used: (12000 × 4 × 580) / 1000 = 27840
// BLS Signature Verification via Pairing
// Verify: e(G1, sig) × e(-pubkey, H(msg)) = 1
const G1_gen = new Uint8Array(128); // Generator point
const signature = new Uint8Array(256); // G2 signature
const negPubkey = new Uint8Array(128); // Negated public key (G1)
const msgHash = new Uint8Array(256); // H(message) in G2
const pairingInput = new Uint8Array(384 * 2);
pairingInput.set(G1_gen, 0);
pairingInput.set(signature, 128);
pairingInput.set(negPubkey, 384);
pairingInput.set(msgHash, 512);
const pairingResult = execute(
PrecompileAddress.BLS12_PAIRING,
pairingInput,
200000n,
Hardfork.PRAGUE
);
const isValid = pairingResult.output[31] === 1;
console.log('Signature valid:', isValid);
```
## Implementation Status
### Zig: Complete
All 9 precompiles fully implemented in `/Users/williamcory/tevm/src/precompiles/`:
* `bls12_g1_add.zig`
* `bls12_g1_mul.zig`
* `bls12_g1_msm.zig`
* `bls12_g2_add.zig`
* `bls12_g2_mul.zig`
* `bls12_g2_msm.zig`
* `bls12_pairing.zig`
* `bls12_map_fp_to_g1.zig`
* `bls12_map_fp2_to_g2.zig`
Delegates to `crypto.Crypto.bls12_381.*` functions which wrap the audited **blst** C library.
### TypeScript: Stubs Only
**Warning:** TypeScript implementations in `src/precompiles/precompiles.ts` are currently stubs that:
* Return correctly sized zero-filled outputs
* Calculate gas costs accurately
* Provide type safety and interfaces
**No actual cryptographic computation is performed.** For production use, call Zig/WASM implementations.
### WASM: Available
BLS12-381 operations available via compiled Zig implementation.
## Use Cases
### Ethereum 2.0 Consensus
**BLS signature aggregation** enables efficient validator consensus:
* Aggregate 1000s of validator signatures into single 96-byte signature
* Single pairing check verifies all signatures
* Massively reduces bandwidth and verification time
### Threshold Signatures
**t-of-n signing schemes:**
* Distribute key shares to n parties
* Any t parties can jointly sign
* Applications: multisig wallets, distributed custody, governance
### Blind Signatures
**Anonymous credentials:**
* Signer signs message without seeing content
* User unblinds signature
* Applications: anonymous voting, privacy-preserving authentication
### Verifiable Random Functions (VRFs)
**Provable randomness:**
* Generate random value with cryptographic proof
* Anyone can verify randomness is correct
* Applications: lotteries, random leader election, proof-of-stake
### SNARKs and zkSNARKs
**Zero-knowledge proofs:**
* Prove statement without revealing witness
* Pairing-based SNARKs (like Groth16) require BN254 and BLS12-381
* Applications: privacy, scalability (rollups)
## Gas Optimization
### MSM Discount Strategies
Multi-scalar multiplication benefits from batch discounts:
```typescript theme={null}
// Bad: Individual multiplications
let sum = pointAtInfinity;
for (const [point, scalar] of pairs) {
sum = execute(PrecompileAddress.BLS12_G1_MUL, ...); // 12000 gas each
}
// Total for 16 pairs: 16 × 12000 = 192000 gas
// Good: Batch MSM
const msmInput = concatenate(pairs); // 160 bytes × 16 = 2560 bytes
const result = execute(PrecompileAddress.BLS12_G1_MSM, msmInput, ...);
// Total: (12000 × 16 × 320) / 1000 = 61440 gas
// Savings: 68% reduction
```
### Signature Aggregation
Aggregate before verification:
```typescript theme={null}
// Bad: Verify 10 signatures individually
for (const sig of signatures) {
pairing(pubkey, msg, sig); // 108000 gas each
}
// Total: 1080000 gas
// Good: Aggregate then verify once
const aggSig = aggregateSignatures(signatures);
pairing(aggPubkey, msg, aggSig); // 108000 gas
// Savings: 90% reduction
```
## Security Considerations
### Subgroup Checks
All operations enforce subgroup membership:
* Points must be in prime-order subgroup
* Prevents small subgroup attacks
* Performed automatically by blst library
### Point Validation
Input points are validated:
* Must satisfy curve equation: y² = x³ + 4
* Coordinates must be in field (\< field modulus)
* Invalid points return error (no result)
### Side-Channel Resistance
**blst** library provides:
* Constant-time scalar multiplication
* Protection against timing attacks
* Hardware-optimized assembly for major platforms
### Known Limitations
**TypeScript stubs:** Do not use TS implementations for security-critical operations. Always use Zig/WASM for actual cryptography.
**WASM:** BLS12-381 operations are available in WASM builds but inherit platform security constraints (no hardware acceleration).
## Performance
### Hardware Optimization
**blst** library features:
* Assembly implementations for x86\_64, ARM64
* AVX2/AVX512 optimizations when available
* Fallback portable C implementation
### Benchmarks
Approximate gas costs and execution times (hardware-dependent):
| Operation | Gas | Approx. Time | Throughput |
| ------------ | ------ | ------------ | ------------ |
| G1\_ADD | 500 | \~10 μs | 100K ops/s |
| G1\_MUL | 12000 | \~200 μs | 5K ops/s |
| G1\_MSM (16) | 61440 | \~1 ms | 16K points/s |
| G2\_ADD | 800 | \~20 μs | 50K ops/s |
| G2\_MUL | 45000 | \~800 μs | 1.2K ops/s |
| PAIRING (2) | 151000 | \~5 ms | 400 pairs/s |
## Implementation Details
### Zig → blst C Library
All precompiles delegate to `src/crypto/crypto.zig`:
```zig theme={null}
pub const bls12_381 = struct {
pub fn g1Add(input: []const u8, output: []u8) !void;
pub fn g1Mul(input: []const u8, output: []u8) !void;
pub fn g1Msm(input: []const u8, output: []u8) !void;
pub fn g2Add(input: []const u8, output: []u8) !void;
pub fn g2Mul(input: []const u8, output: []u8) !void;
pub fn g2Msm(input: []const u8, output: []u8) !void;
pub fn pairingCheck(input: []const u8) !bool;
pub fn mapFpToG1(input: []const u8, output: []u8) !void;
pub fn mapFp2ToG2(input: []const u8, output: []u8) !void;
};
```
These wrap **blst** (lib/blst/), a production-grade BLS12-381 library:
* Audited by NCC Group and Trail of Bits
* Used by Ethereum 2.0 clients (Prysm, Lighthouse)
* Constant-time operations, side-channel resistant
## Related
* [Crypto: BLS12-381](/crypto/bls12-381) - Underlying cryptographic primitives
* [Precompiles: BN254](/crypto/bn254) - Alternative pairing-friendly curve (cheaper, less secure)
* [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537) - Official specification
* [blst library](https://github.com/supranational/blst) - C implementation
* [BLS Signatures](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature) - IETF specification
## References
* **EIP-2537:** BLS12-381 curve operations
[https://eips.ethereum.org/EIPS/eip-2537](https://eips.ethereum.org/EIPS/eip-2537)
* **BLS12-381 Spec:**
[https://hackmd.io/@benjaminion/bls12-381](https://hackmd.io/@benjaminion/bls12-381)
* **Hash-to-Curve:**
[https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve)
* **blst Documentation:**
[https://github.com/supranational/blst](https://github.com/supranational/blst)
* **Ethereum 2.0 BLS:**
[https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#bls-signatures](https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#bls-signatures)
# 0x0B BLS12-381 G1 Add
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g1-add
BLS12-381 G1 elliptic curve point addition
**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
**Address:** `0x000000000000000000000000000000000000000b`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G1 Add precompile performs elliptic curve point addition on the BLS12-381 curve's G1 group. It takes two G1 points and returns their sum. This is essential for BLS signature verification, consensus protocols, and advanced cryptographic applications.
EIP-2537 introduces BLS12-381 curve operations to Ethereum, enabling efficient BLS signatures used in Ethereum 2.0 consensus and other cryptographic protocols requiring pairing-friendly curves.
The BLS12-381 curve is a pairing-friendly elliptic curve designed for zkSNARKs and signature aggregation, offering 128-bit security with efficient pairing operations.
## Gas Cost
**Fixed:** `500` gas
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x1 (first point x-coordinate, big-endian, left-padded)
64 | 64 | y1 (first point y-coordinate, big-endian, left-padded)
128 | 64 | x2 (second point x-coordinate, big-endian, left-padded)
192 | 64 | y2 (second point y-coordinate, big-endian, left-padded)
```
Total input length: 256 bytes (exactly)
Points must satisfy the curve equation: `y^2 = x^3 + 4` over the BLS12-381 base field (Fp).
Point at infinity is represented as all zeros (128 bytes of zeros for each point).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x (result point x-coordinate, big-endian, left-padded)
64 | 64 | y (result point y-coordinate, big-endian, left-padded)
```
Total output length: 128 bytes
## TypeScript Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// BLS12-381 G1 generator point (48 bytes, left-padded to 64)
const g1_x = Bytes64('0x000000000000000000000000000000000017f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb');
const g1_y = Bytes64('0x0000000000000000000000000000000008b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1');
// Add generator point to itself: G + G = 2G
const input = new Uint8Array(256);
input.set(g1_x, 0);
input.set(g1_y, 64);
input.set(g1_x, 128);
input.set(g1_y, 192);
const result = execute(
PrecompileAddress.BLS12_G1_ADD,
input,
1000n,
Hardfork.PRAGUE
);
if (result.success) {
const resultX = result.output.slice(0, 64);
const resultY = result.output.slice(64, 128);
console.log('Result: 2*G');
console.log('Gas used:', result.gasUsed); // 500
} else {
console.error('Error:', result.error);
}
```
## Zig Example
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// BLS12-381 G1 generator coordinates (48 bytes, padded to 64)
const g1_x = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x17, 0xf1, 0xd3, 0xa7, 0x31, 0x97, 0xd7, 0x94, 0x26, 0x95, 0x63, 0x8c, 0x4f, 0xa9, 0xac, 0x0f,
0xc3, 0x68, 0x8c, 0x4f, 0x97, 0x74, 0xb9, 0x05, 0xa1, 0x4e, 0x3a, 0x3f, 0x17, 0x1b, 0xac, 0x58,
0x6c, 0x55, 0xe8, 0x3f, 0xf9, 0x7a, 0x1a, 0xef, 0xfb, 0x3a, 0xf0, 0x0a, 0xdb, 0x22, 0xc6, 0xbb,
};
const g1_y = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0xb3, 0xf4, 0x81, 0xe3, 0xaa, 0xa0, 0xf1, 0xa0, 0x9e, 0x30, 0xed, 0x74, 0x1d, 0x8a, 0xe4,
0xfc, 0xf5, 0xe0, 0x95, 0xd5, 0xd0, 0x0a, 0xf6, 0x00, 0xdb, 0x18, 0xcb, 0x2c, 0x04, 0xb3, 0xed,
0xd0, 0x3c, 0xc7, 0x44, 0xa2, 0x88, 0x8a, 0xe4, 0x0c, 0xaa, 0x23, 0x29, 0x46, 0xc5, 0xe7, 0xe1,
};
// Construct input: G + G
var input: [256]u8 = [_]u8{0} ** 256;
@memcpy(input[0..64], &g1_x);
@memcpy(input[64..128], &g1_y);
@memcpy(input[128..192], &g1_x);
@memcpy(input[192..256], &g1_y);
const result = try precompiles.bls12_g1_add.execute(allocator, &input, 1000);
defer result.deinit(allocator);
std.debug.print("Result: 2*G\n", .{});
std.debug.print("Gas used: {}\n", .{result.gas_used});
}
```
## Error Conditions
* **Out of gas:** gasLimit \< 500
* **Invalid input length:** input.len != 256
* **Invalid point:** Point coordinates don't satisfy curve equation y² = x³ + 4
* **Point not in subgroup:** Point not in correct subgroup (fails validation)
* **Coordinate out of range:** x or y >= field modulus
Invalid inputs cause precompile to return `error.InvalidPoint`.
## Use Cases
* **BLS signature verification:** Aggregating and verifying BLS signatures
* **Ethereum 2.0 consensus:** Validator signature aggregation
* **zkSNARKs on BLS12-381:** Proof systems using BLS12-381 curve
* **Distributed key generation:** Threshold cryptography protocols
* **Verifiable delay functions:** VDFs using pairings
* **Privacy protocols:** zk-Rollups and privacy-preserving systems
## Implementation Details
* **Zig:** Uses blst library (C) via crypto module for G1 operations
* **TypeScript:** Uses @noble/curves bls12-381 implementation
* **Curve:** BLS12-381 with embedding degree 12
* **Field modulus (p):** 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
* **Group order (r):** 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001
## BLS12-381 G1 Parameters
* **Curve equation:** y² = x³ + 4
* **Base field:** Fp (381-bit prime)
* **Coordinate size:** 48 bytes (padded to 64 bytes in precompile encoding)
* **Generator G1 x:** 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb
* **Generator G1 y:** 0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1
* **Point at infinity:** All zeros (128 bytes)
## Point Addition Rules
* **P + O = P** (identity element)
* **O + P = P** (identity is commutative)
* **P + P = 2P** (point doubling)
* **P + (-P) = O** (inverse gives infinity)
* General addition uses elliptic curve group law
## Security Considerations
* All coordinates must be validated to be in field and on curve
* Points must be checked for subgroup membership
* Implementation uses constant-time operations where possible
* Uses battle-tested blst library for security-critical operations
## Performance Notes
* Fixed gas cost makes G1 addition predictable
* More efficient than generic elliptic curve operations
* Hardware acceleration available on some platforms via blst
* Point validation adds overhead but is necessary for security
## Related
* [Precompile: BLS12-381 G1 Mul](/evm/precompiles/bls12-g1-mul)
* [Precompile: BLS12-381 G1 MSM](/evm/precompiles/bls12-g1-msm)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [EIP-2537: Precompiled Contracts for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [BLS12-381 Specification](https://hackmd.io/@benjaminion/bls12-381)
# 0x0D BLS12-381 G1 MSM
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g1-msm
BLS12-381 G1 multi-scalar multiplication
**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
**Address:** `0x000000000000000000000000000000000000000d`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G1 MSM (Multi-Scalar Multiplication) precompile performs efficient batch scalar multiplication on the BLS12-381 curve's G1 group. It computes the sum of multiple points each multiplied by their respective scalars: `k1*P1 + k2*P2 + ... + kn*Pn`. This operation is fundamental for BLS signature aggregation, zkSNARK verification, and efficient batch cryptographic operations.
MSM is significantly more efficient than performing individual multiplications and additions separately. The precompile uses optimized algorithms (like Pippenger's algorithm) to compute batch operations with sublinear scaling.
EIP-2537 introduces BLS12-381 operations to enable efficient aggregate signatures used in Ethereum 2.0 consensus, where thousands of validator signatures must be verified together.
## Gas Cost
**Dynamic with discount:** `(BASE_GAS * k * discount) / 1000`
* **BASE\_GAS:** 12000
* **k:** Number of point-scalar pairs
* **discount:** Discount factor based on batch size (EIP-2537 table)
### Discount Table
| Pairs (k) | Discount | Gas per pair |
| --------- | -------- | ------------ |
| 1 | 1000 | 12000 |
| 2-3 | 820 | 9840 |
| 4-7 | 580 | 6960 |
| 8-15 | 430 | 5160 |
| 16-31 | 320 | 3840 |
| 32-63 | 250 | 3000 |
| 64-127 | 200 | 2400 |
| 128+ | 174 | 2088 |
**Example:** For 32 pairs: `(12000 * 32 * 250) / 1000 = 96000 gas`
The discount reflects the efficiency gains from batch processing, making aggregate operations economical.
## Input Format
```
Offset | Length | Description
----------|--------|-------------
0 | 64 | x1 (first point x-coordinate, big-endian, left-padded)
64 | 64 | y1 (first point y-coordinate, big-endian, left-padded)
128 | 32 | k1 (first scalar, big-endian)
160 | 64 | x2 (second point x-coordinate)
224 | 64 | y2 (second point y-coordinate)
288 | 32 | k2 (second scalar)
... | ... | (repeat for each pair)
n*160 | 64 | xn (nth point x-coordinate)
n*160+64 | 64 | yn (nth point y-coordinate)
n*160+128 | 32 | kn (nth scalar)
```
Total input length: `160 * k` bytes (must be exact multiple of 160)
Each point must satisfy the curve equation: `y^2 = x^3 + 4` over BLS12-381 base field.
Point at infinity represented as all zeros (128 bytes).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x (result point x-coordinate, big-endian, left-padded)
64 | 64 | y (result point y-coordinate, big-endian, left-padded)
```
Total output length: 128 bytes (single aggregated point)
## TypeScript Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// BLS12-381 G1 generator (48 bytes, left-padded to 64)
const g1_x = Bytes64('0x000000000000000000000000000000000017f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb');
const g1_y = Bytes64('0x0000000000000000000000000000000008b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1');
// Compute: 3*G + 5*G + 7*G = 15*G (3 pairs)
const input = new Uint8Array(160 * 3);
// First pair: (G, 3)
input.set(g1_x, 0);
input.set(g1_y, 64);
const scalar1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000003');
input.set(scalar1, 128);
// Second pair: (G, 5)
input.set(g1_x, 160);
input.set(g1_y, 224);
const scalar2 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000005');
input.set(scalar2, 288);
// Third pair: (G, 7)
input.set(g1_x, 320);
input.set(g1_y, 384);
const scalar3 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000007');
input.set(scalar3, 448);
// Gas calculation: k=3, discount=820
// gas = (12000 * 3 * 820) / 1000 = 29520
const result = execute(
PrecompileAddress.BLS12_G1_MSM,
input,
50000n,
Hardfork.PRAGUE
);
if (result.success) {
console.log('Result: 15*G (sum of 3*G + 5*G + 7*G)');
console.log('Gas used:', result.gasUsed); // 29520
} else {
console.error('Error:', result.error);
}
```
## Zig Example
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// BLS12-381 G1 generator (padded to 64 bytes)
const g1_x = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x17, 0xf1, 0xd3, 0xa7, 0x31, 0x97, 0xd7, 0x94, 0x26, 0x95, 0x63, 0x8c, 0x4f, 0xa9, 0xac, 0x0f,
0xc3, 0x68, 0x8c, 0x4f, 0x97, 0x74, 0xb9, 0x05, 0xa1, 0x4e, 0x3a, 0x3f, 0x17, 0x1b, 0xac, 0x58,
0x6c, 0x55, 0xe8, 0x3f, 0xf9, 0x7a, 0x1a, 0xef, 0xfb, 0x3a, 0xf0, 0x0a, 0xdb, 0x22, 0xc6, 0xbb,
};
const g1_y = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0xb3, 0xf4, 0x81, 0xe3, 0xaa, 0xa0, 0xf1, 0xa0, 0x9e, 0x30, 0xed, 0x74, 0x1d, 0x8a, 0xe4,
0xfc, 0xf5, 0xe0, 0x95, 0xd5, 0xd0, 0x0a, 0xf6, 0x00, 0xdb, 0x18, 0xcb, 0x2c, 0x04, 0xb3, 0xed,
0xd0, 0x3c, 0xc7, 0x44, 0xa2, 0x88, 0x8a, 0xe4, 0x0c, 0xaa, 0x23, 0x29, 0x46, 0xc5, 0xe7, 0xe1,
};
// Compute MSM with 4 pairs: 1*G + 2*G + 3*G + 4*G = 10*G
var input: [640]u8 = [_]u8{0} ** 640;
var i: usize = 0;
while (i < 4) : (i += 1) {
const offset = i * 160;
@memcpy(input[offset..offset+64], &g1_x);
@memcpy(input[offset+64..offset+128], &g1_y);
input[offset + 159] = @intCast(i + 1); // scalars: 1, 2, 3, 4
}
const result = try precompiles.bls12_g1_msm.execute(allocator, &input, 100000);
defer result.deinit(allocator);
std.debug.print("Result: 10*G (1*G + 2*G + 3*G + 4*G)\n", .{});
std.debug.print("Gas used: {}\n", .{result.gas_used});
}
```
## Error Conditions
* **Out of gas:** gasLimit \< calculated gas cost
* **Invalid input length:** input.len % 160 != 0 or input.len == 0
* **Invalid point:** Any point doesn't satisfy curve equation y² = x³ + 4
* **Point not in subgroup:** Any point not in correct subgroup
* **Coordinate out of range:** Any x or y >= field modulus
Invalid inputs cause precompile to return `error.InvalidPoint`.
## MSM Properties
* **Linearity:** MSM(P, k) = k1*P1 + k2*P2 + ... + kn\*Pn
* **Zero scalars:** Points with k=0 contribute nothing to sum
* **Point at infinity:** Infinity points with any scalar contribute nothing
* **Empty input:** Returns error (must have at least one pair)
* **Order independence:** Result same regardless of pair order
## Use Cases
* **BLS signature aggregation:** Aggregate thousands of validator signatures
* **Batch verification:** Verify multiple signatures simultaneously
* **zkSNARK verification:** Multi-scalar multiplications in proof verification
* **Threshold signatures:** Combine signature shares efficiently
* **Polynomial commitments:** KZG-style commitments on BLS12-381
* **Consensus protocols:** Ethereum 2.0 beacon chain signature aggregation
* **Privacy protocols:** Efficient batch operations in zk-Rollups
## Implementation Details
* **Zig:** Uses blst library's optimized MSM implementation
* **TypeScript:** Manual loop (naive implementation, less efficient)
* **Algorithm:** Pippenger's algorithm for efficient batch processing
* **Optimization:** Exploits parallelism and precomputation
* **Memory:** Temporary storage proportional to number of pairs
## Performance Characteristics
* **Time complexity:** O(k \* log(k)) with Pippenger's algorithm
* **Gas discount:** Increases with batch size (sublinear cost scaling)
* **Break-even point:** \~4 pairs more efficient than separate operations
* **Maximum efficiency:** Large batches (64+ pairs) get best discount
## Gas Cost Comparison
Comparing MSM vs individual operations:
```typescript theme={null}
// Individual: 3 muls + 2 adds
// Cost: 3*12000 + 2*500 = 37000 gas
// MSM with 3 pairs (discount 820)
// Cost: (12000 * 3 * 820) / 1000 = 29520 gas
// Savings: 7480 gas (20% reduction)
// With 32 pairs:
// Individual: 32*12000 + 31*500 = 399500 gas
// MSM: (12000 * 32 * 250) / 1000 = 96000 gas
// Savings: 303500 gas (76% reduction!)
```
## Algorithm: Pippenger's Method
Pippenger's algorithm efficiently computes MSM by:
1. **Bucketing:** Group scalars by bit windows
2. **Bucket sums:** Compute point sums for each bucket
3. **Window reduction:** Combine buckets with doubling
4. **Final sum:** Aggregate window results
This reduces operations from O(k \* 256) to O(k \* log(256)), where k is number of pairs.
## Discount Rationale
EIP-2537 discount table reflects:
* **Algorithmic efficiency:** Pippenger's sublinear scaling
* **Amortization:** Fixed costs spread over more operations
* **Hardware optimization:** Better cache utilization with batches
* **Incentive:** Encourage batch operations for network efficiency
## Security Considerations
* All points validated individually before processing
* Scalar range checked (any 256-bit value accepted)
* Constant-time operations prevent timing attacks
* Point at infinity handled correctly in accumulation
* Uses audited blst library for security-critical operations
## Comparison with G1 Mul
| Operation | Single (Mul) | Batch (MSM) |
| ---------- | -------------- | -------------- |
| Pairs (k) | 1 | 1-128+ |
| Base gas | 12000 | 12000 |
| Discount | None | 174-1000 |
| Algorithm | Double-and-add | Pippenger |
| Efficiency | O(log k) | O(k log log k) |
## Related
* [Precompile: BLS12-381 G1 Add](/evm/precompiles/bls12-g1-add)
* [Precompile: BLS12-381 G1 Mul](/evm/precompiles/bls12-g1-mul)
* [Precompile: BLS12-381 G2 MSM](/evm/precompiles/bls12-g2-msm)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [EIP-2537: Precompiled Contracts for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [Pippenger's Algorithm](https://link.springer.com/chapter/10.1007/3-540-46766-1_9)
* [BLS12-381 Specification](https://hackmd.io/@benjaminion/bls12-381)
# 0x0C BLS12-381 G1 Mul
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g1-mul
BLS12-381 G1 elliptic curve scalar multiplication
**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
**Address:** `0x000000000000000000000000000000000000000c`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G1 Mul precompile performs elliptic curve scalar multiplication on the BLS12-381 curve's G1 group. It takes a G1 point and a scalar, returning the point multiplied by that scalar (P \* k). This operation is fundamental for BLS signature generation, key derivation, and cryptographic commitments.
EIP-2537 introduces BLS12-381 curve operations to enable efficient BLS signatures, which are used in Ethereum 2.0 for validator consensus and signature aggregation. Scalar multiplication is one of the most common operations in elliptic curve cryptography.
The BLS12-381 curve provides 128-bit security with efficient pairing operations, making it ideal for aggregatable signatures and zkSNARK applications.
## Gas Cost
**Fixed:** `12000` gas
This reflects the computational complexity of scalar multiplication, which is significantly more expensive than point addition due to the repeated doubling-and-add algorithm.
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x (point x-coordinate, big-endian, left-padded)
64 | 64 | y (point y-coordinate, big-endian, left-padded)
128 | 32 | k (scalar, big-endian)
```
Total input length: 160 bytes (exactly)
The point must satisfy the curve equation: `y^2 = x^3 + 4` over the BLS12-381 base field (Fp).
Point at infinity is represented as all zeros (128 bytes).
Scalar is a 256-bit value (reduced modulo group order if necessary).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x (result point x-coordinate, big-endian, left-padded)
64 | 64 | y (result point y-coordinate, big-endian, left-padded)
```
Total output length: 128 bytes
## TypeScript Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// BLS12-381 G1 generator point (48 bytes, left-padded to 64)
const g1_x = Bytes64('0x000000000000000000000000000000000017f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb');
const g1_y = Bytes64('0x0000000000000000000000000000000008b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1');
// Scalar: multiply by 42
const scalar = Bytes32('0x000000000000000000000000000000000000000000000000000000000000002a');
// Compute: 42 * G
const input = new Uint8Array(160);
input.set(g1_x, 0);
input.set(g1_y, 64);
input.set(scalar, 128);
const result = execute(
PrecompileAddress.BLS12_G1_MUL,
input,
20000n,
Hardfork.PRAGUE
);
if (result.success) {
const resultX = result.output.slice(0, 64);
const resultY = result.output.slice(64, 128);
console.log('Result: 42*G');
console.log('Gas used:', result.gasUsed); // 12000
} else {
console.error('Error:', result.error);
}
```
## Zig Example
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// BLS12-381 G1 generator (padded to 64 bytes)
const g1_x = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x17, 0xf1, 0xd3, 0xa7, 0x31, 0x97, 0xd7, 0x94, 0x26, 0x95, 0x63, 0x8c, 0x4f, 0xa9, 0xac, 0x0f,
0xc3, 0x68, 0x8c, 0x4f, 0x97, 0x74, 0xb9, 0x05, 0xa1, 0x4e, 0x3a, 0x3f, 0x17, 0x1b, 0xac, 0x58,
0x6c, 0x55, 0xe8, 0x3f, 0xf9, 0x7a, 0x1a, 0xef, 0xfb, 0x3a, 0xf0, 0x0a, 0xdb, 0x22, 0xc6, 0xbb,
};
const g1_y = [_]u8{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0xb3, 0xf4, 0x81, 0xe3, 0xaa, 0xa0, 0xf1, 0xa0, 0x9e, 0x30, 0xed, 0x74, 0x1d, 0x8a, 0xe4,
0xfc, 0xf5, 0xe0, 0x95, 0xd5, 0xd0, 0x0a, 0xf6, 0x00, 0xdb, 0x18, 0xcb, 0x2c, 0x04, 0xb3, 0xed,
0xd0, 0x3c, 0xc7, 0x44, 0xa2, 0x88, 0x8a, 0xe4, 0x0c, 0xaa, 0x23, 0x29, 0x46, 0xc5, 0xe7, 0xe1,
};
// Construct input: 5 * G
var input: [160]u8 = [_]u8{0} ** 160;
@memcpy(input[0..64], &g1_x);
@memcpy(input[64..128], &g1_y);
input[159] = 5; // scalar = 5
const result = try precompiles.bls12_g1_mul.execute(allocator, &input, 20000);
defer result.deinit(allocator);
std.debug.print("Result: 5*G\n", .{});
std.debug.print("Gas used: {}\n", .{result.gas_used});
}
```
## Error Conditions
* **Out of gas:** gasLimit \< 12000
* **Invalid input length:** input.len != 160
* **Invalid point:** Point coordinates don't satisfy curve equation y² = x³ + 4
* **Point not in subgroup:** Point not in correct subgroup (fails validation)
* **Coordinate out of range:** x or y >= field modulus
Invalid inputs cause precompile to return `error.InvalidPoint`.
## Scalar Multiplication Properties
* **P \* 0 = O** (multiplication by zero gives point at infinity)
* **P \* 1 = P** (multiplication by one is identity)
* **O \* k = O** (infinity times any scalar is infinity)
* **P \* (a + b) = P \* a + P \* b** (distributive property)
* **P \* (-k) = -(P \* k)** (negation of scalar negates point)
## Use Cases
* **BLS signature generation:** Computing signatures from secret keys
* **Public key derivation:** Deriving public keys from private keys
* **Threshold cryptography:** Secret sharing schemes
* **Cryptographic commitments:** Pedersen commitments on BLS12-381
* **Zero-knowledge proofs:** zkSNARK/zkSTARK operations
* **Distributed key generation:** Multi-party computation protocols
* **Verifiable random functions:** VRF implementations
## Implementation Details
* **Zig:** Uses blst library for secure scalar multiplication
* **TypeScript:** Uses @noble/curves bls12-381 implementation
* **Algorithm:** Windowed scalar multiplication (efficient for large scalars)
* **Constant-time:** Implementation uses constant-time operations where possible
* **Scalar range:** Full 256-bit range, reduced modulo group order internally
## Performance Characteristics
* **Time complexity:** O(log k) where k is scalar value
* **Fixed gas cost:** Predictable cost regardless of scalar value
* **Optimizations:** Uses precomputed tables and efficient field arithmetic
* **Hardware acceleration:** blst library can use CPU-specific optimizations
## BLS12-381 G1 Parameters
* **Curve equation:** y² = x³ + 4
* **Base field:** Fp (381-bit prime)
* **Group order (r):** 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001
* **Coordinate size:** 48 bytes (padded to 64 bytes in encoding)
* **Generator G1:** (x, y) as defined in BLS12-381 spec
* **Point at infinity:** All zeros (128 bytes)
## Test Vectors
```typescript theme={null}
// G * 0 = O (point at infinity)
const result = g1Mul(G, 0n);
// result = O (all zeros)
// G * 1 = G (identity)
const result = g1Mul(G, 1n);
// result = G
// G * 2 = 2G (doubling)
const result = g1Mul(G, 2n);
// result = G + G
// O * k = O (infinity times any scalar)
const result = g1Mul(O, 42n);
// result = O
// Large scalar
const result = g1Mul(G, 2n ** 256n - 1n);
// result = valid point (scalar reduced mod group order)
```
## Security Considerations
* Point validation ensures input is on curve and in correct subgroup
* Scalar can be any 256-bit value (automatically reduced)
* Uses constant-time operations to prevent timing attacks
* blst library is audited and battle-tested
* Point at infinity handled correctly as identity element
## Comparison with BN254 Mul
| Feature | BLS12-381 G1 Mul | BN254 Mul |
| --------------- | -------------------- | ----------------- |
| Address | 0x0c | 0x07 |
| Gas cost | 12000 | 6000 |
| Security | 128-bit | \~100-bit |
| Coordinate size | 48 bytes (64 padded) | 32 bytes |
| Input size | 160 bytes | 96 bytes |
| Use case | BLS signatures, ETH2 | zkSNARKs, privacy |
## Related
* [Precompile: BLS12-381 G1 Add](/evm/precompiles/bls12-g1-add)
* [Precompile: BLS12-381 G1 MSM](/evm/precompiles/bls12-g1-msm)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [EIP-2537: Precompiled Contracts for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [BLS12-381 Specification](https://hackmd.io/@benjaminion/bls12-381)
# 0x0e BLS12-381 G2 Add
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g2-add
BLS12-381 G2 point addition
**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
**Address:** `0x000000000000000000000000000000000000000e`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G2 Add precompile performs point addition on the BLS12-381 curve's G2 group. It adds two G2 points together, computing `point1 + point2`. This operation is essential for BLS signature aggregation and advanced cryptographic protocols requiring operations over extension fields.
BLS12-381 provides 128 bits of security (compared to BN254's 80 bits) and is used in Ethereum 2.0's consensus layer for validator signature verification.
## Gas Cost
**Fixed:** `800` gas
## G2 vs G1
**G2 points** are defined over the extension field Fp2 (quadratic extension of the base field):
* **G1 points:** 128 bytes (64 bytes per coordinate, 2 coordinates)
* **G2 points:** 256 bytes (128 bytes per coordinate, 2 coordinates)
* **Field representation:** Each G2 coordinate is an Fp2 element (c0 + c1\*u)
* **Computational cost:** G2 operations are more expensive than G1 due to extension field arithmetic
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0 (point1 x-coordinate c0 component, big-endian)
64 | 64 | x.c1 (point1 x-coordinate c1 component, big-endian)
128 | 64 | y.c0 (point1 y-coordinate c0 component, big-endian)
192 | 64 | y.c1 (point1 y-coordinate c1 component, big-endian)
256 | 64 | x.c0 (point2 x-coordinate c0 component, big-endian)
320 | 64 | x.c1 (point2 x-coordinate c1 component, big-endian)
384 | 64 | y.c0 (point2 y-coordinate c0 component, big-endian)
448 | 64 | y.c1 (point2 y-coordinate c1 component, big-endian)
```
Total input length: 512 bytes (256 bytes per G2 point)
Each G2 point coordinate is an Fp2 element represented as: `c0 + c1*u` where u is the extension field element.
Points must satisfy the G2 curve equation: `y^2 = x^3 + 4(1 + u)` over Fp2.
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0 (result point x-coordinate c0 component, big-endian)
64 | 64 | x.c1 (result point x-coordinate c1 component, big-endian)
128 | 64 | y.c0 (result point y-coordinate c0 component, big-endian)
192 | 64 | y.c1 (result point y-coordinate c1 component, big-endian)
```
Total output length: 256 bytes
## Usage Example
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Add two G2 points (each 256 bytes: 4x 64-byte Fp2 components)
// Point at infinity for both (valid operation: O + O = O)
const point1 = new Uint8Array(256); // All zeros = point at infinity
const point2 = new Uint8Array(256); // All zeros = point at infinity
const input = new Uint8Array(512);
input.set(point1, 0);
input.set(point2, 256);
const result = execute(
PrecompileAddress.BLS12_G2_ADD,
input,
10000n,
Hardfork.PRAGUE
);
if (result.success) {
const resultPoint = result.output; // 256 bytes
const xc0 = result.output.slice(0, 64);
const xc1 = result.output.slice(64, 128);
const yc0 = result.output.slice(128, 192);
const yc1 = result.output.slice(192, 256);
console.log('Result G2 point:', { xc0, xc1, yc0, yc1 });
console.log('Gas used:', result.gasUsed); // 800
} else {
console.error('Error:', result.error);
}
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// Create input: two G2 points (512 bytes)
var input = [_]u8{0} ** 512;
// ... populate input with G2 point coordinates
// Execute G2 addition
const result = try precompiles.bls12_g2_add.execute(
allocator,
&input,
10000
);
defer result.deinit(allocator);
std.debug.print("Gas used: {}\n", .{result.gas_used});
std.debug.print("Output length: {}\n", .{result.output.len}); // 256
}
```
## Error Conditions
* **Out of gas:** gasLimit \< 800
* **Invalid input length:** input.len != 512
* **Point not on curve:** coordinates don't satisfy G2 curve equation
* **Invalid field element:** coordinate component >= field modulus
* **Invalid encoding:** malformed Fp2 element representation
## Use Cases
* **BLS signature aggregation:** Combine multiple G2 signatures
* **Multi-signature schemes:** Aggregate public keys or signatures
* **Threshold cryptography:** Combine signature shares
* **Proof aggregation:** Combine multiple proofs efficiently
* **Ethereum 2.0 consensus:** Validator signature operations
## Implementation Details
* **Zig:** Uses BLST library via crypto module
* **TypeScript:** Wraps @noble/curves bls12-381 G2 operations
* **Algorithm:** Projective coordinates for efficiency
* **Security:** 128-bit security level (vs BN254's 80-bit)
* **Constant-time:** Implementation resistant to timing attacks
## Special Cases
* **Point at infinity:** All zeros (256 bytes) represents identity element
* **Identity + P:** Returns P
* **P + (-P):** Returns point at infinity
* **Identity + identity:** Returns identity
The point at infinity is represented as 256 bytes of zeros and acts as the identity element for G2 addition.
## Extension Field Arithmetic
G2 points use the quadratic extension field Fp2:
* **Field elements:** `a = a.c0 + a.c1*u` where u^2 + 1 = 0
* **Addition:** `(a + b) = (a.c0 + b.c0) + (a.c1 + b.c1)*u`
* **Multiplication:** More complex due to extension field rules
* **Encoding:** Each component (c0, c1) is 64 bytes big-endian
## Gas Comparison
| Operation | G1 Gas | G2 Gas | Ratio |
| --------------- | -------- | -------- | ----- |
| Addition | 500 | 800 | 1.6x |
| Multiplication | 12,000 | 45,000 | 3.75x |
| MSM (per point) | \~12,000 | \~45,000 | 3.75x |
G2 operations are more expensive due to:
* Extension field arithmetic (Fp2 vs Fp)
* Larger point representation (256 vs 128 bytes)
* More complex coordinate operations
## Security Considerations
BLS12-381 advantages over BN254:
* **Security level:** 128 bits vs 80 bits
* **Future-proof:** Resistant to known attacks on pairing curves
* **Standardization:** Used in Ethereum 2.0, Zcash, Filecoin
* **Performance:** Efficient pairing computation
## Performance Notes
* G2 addition is \~60% more expensive than G1 addition (800 vs 500 gas)
* Prefer batching operations when possible
* Consider using MSM for multiple operations with same points
* G2 operations required for signature verification in BLS schemes
## Related
* [Precompile: BLS12-381 G2 Mul](/evm/precompiles/bls12-g2-mul)
* [Precompile: BLS12-381 G2 MSM](/evm/precompiles/bls12-g2-msm)
* [Precompile: BLS12-381 G1 Add](/evm/precompiles/bls12-g1-add)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [Crypto: BLS12-381](/crypto/bls12-381)
* [EIP-2537: Precompile for BLS12-381 curve operations](https://eips.ethereum.org/EIPS/eip-2537)
# 0x10 BLS12-381 G2 MSM
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g2-msm
BLS12-381 G2 multi-scalar multiplication
**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
**Address:** `0x0000000000000000000000000000000000000010`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G2 MSM (multi-scalar multiplication) precompile efficiently computes the sum of multiple scalar multiplications on G2 points: `scalar1*point1 + scalar2*point2 + ... + scalarN*pointN`. This operation is critical for batch signature verification, proof aggregation, and efficient cryptographic protocols over extension fields.
MSM provides significant gas savings through bulk discounts when performing multiple scalar multiplications.
## Gas Cost
**Formula:** `(BASE_GAS * k * discount(k)) / 1000`
Where:
* **BASE\_GAS:** 45,000
* **k:** Number of point-scalar pairs
* **discount(k):** Discount multiplier based on batch size
## Discount Table
| Pairs (k) | Discount | Example Gas |
| --------- | -------- | ----------- |
| 1 | 1000 | 45,000 |
| 2 | 820 | 73,800 |
| 4 | 580 | 104,400 |
| 8 | 430 | 154,800 |
| 16 | 320 | 230,400 |
| 32 | 250 | 360,000 |
| 64 | 200 | 576,000 |
| 128 | 174 | 1,003,200 |
Discount improves with batch size, making MSM much more efficient than individual multiplications.
## G2 vs G1 MSM
**G2 MSM characteristics:**
* **G1 base gas:** 12,000
* **G2 base gas:** 45,000 (3.75x more expensive)
* **Reason:** Fp2 extension field arithmetic complexity
* **Discount schedule:** Same for both G1 and G2
* **Point size:** G2 uses 256 bytes vs G1's 128 bytes
* **Input size:** 288 bytes per pair (256 point + 32 scalar) vs G1's 160 bytes
## Input Format
```
Offset | Length | Description
------------|--------|-------------
0 | 64 | x.c0 (point1 x-coordinate c0, big-endian)
64 | 64 | x.c1 (point1 x-coordinate c1, big-endian)
128 | 64 | y.c0 (point1 y-coordinate c0, big-endian)
192 | 64 | y.c1 (point1 y-coordinate c1, big-endian)
256 | 32 | scalar1 (multiplier, big-endian)
288 | 64 | x.c0 (point2 x-coordinate c0, big-endian)
352 | 64 | x.c1 (point2 x-coordinate c1, big-endian)
416 | 64 | y.c0 (point2 y-coordinate c0, big-endian)
480 | 64 | y.c1 (point2 y-coordinate c1, big-endian)
544 | 32 | scalar2 (multiplier, big-endian)
... | ... | (repeating pattern)
```
Total input length: `288 * k` bytes (must be exact multiple of 288)
Each G2 point is 256 bytes (4 x 64-byte Fp2 components), followed by 32-byte scalar.
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0 (result point x-coordinate c0, big-endian)
64 | 64 | x.c1 (result point x-coordinate c1, big-endian)
128 | 64 | y.c0 (result point y-coordinate c0, big-endian)
192 | 64 | y.c1 (result point y-coordinate c1, big-endian)
```
Total output length: 256 bytes (single G2 point)
## Usage Example
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Compute MSM: s1*P1 + s2*P2 + s3*P3
const numPairs = 3;
const input = new Uint8Array(288 * numPairs);
// First pair: (point at infinity, 2)
const point1 = new Uint8Array(256); // All zeros = point at infinity
const scalar1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000002');
input.set(point1, 0);
input.set(scalar1, 256);
// Second pair: (point at infinity, 3)
const point2 = new Uint8Array(256); // All zeros
const scalar2 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000003');
input.set(point2, 288);
input.set(scalar2, 544);
// Third pair: (point at infinity, 5)
const point3 = new Uint8Array(256); // All zeros
const scalar3 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000005');
input.set(point3, 576);
input.set(scalar3, 832);
const result = execute(
PrecompileAddress.BLS12_G2_MSM,
input,
150000n,
Hardfork.PRAGUE
);
if (result.success) {
console.log('Result G2 point:', result.output); // 256 bytes
console.log('Gas used:', result.gasUsed);
// Gas savings vs individual muls:
// MSM: ~78,300 (3 pairs with discount 580)
// Individual: 135,000 (3 * 45,000)
// Savings: ~42% reduction
} else {
console.error('Error:', result.error);
}
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// Create input: 4 point-scalar pairs (288 * 4 = 1152 bytes)
const num_pairs = 4;
var input = try allocator.alloc(u8, 288 * num_pairs);
defer allocator.free(input);
// ... populate points and scalars
// Execute G2 MSM
const result = try precompiles.bls12_g2_msm.execute(
allocator,
input,
200000
);
defer result.deinit(allocator);
// With 4 pairs and discount 580:
// Gas = (45000 * 4 * 580) / 1000 = 104,400
std.debug.print("Gas used: {}\n", .{result.gas_used});
std.debug.print("Output length: {}\n", .{result.output.len}); // 256
}
```
## Error Conditions
* **Out of gas:** gasLimit \< calculated gas cost
* **Invalid input length:** input.len % 288 != 0 or input.len == 0
* **Empty input:** Must have at least one pair
* **Point not on curve:** Any point doesn't satisfy G2 curve equation
* **Invalid field element:** Coordinate component >= field modulus
* **Subgroup check failure:** Points not in correct subgroup
## Use Cases
* **Batch signature verification:** Verify multiple BLS signatures efficiently
* **Proof aggregation:** Combine multiple zero-knowledge proofs
* **Multi-signature schemes:** Aggregate signatures from multiple parties
* **Threshold cryptography:** Combine signature shares with coefficients
* **Ethereum 2.0 consensus:** Batch verify validator signatures
* **Cross-chain bridges:** Aggregate attestations efficiently
## Implementation Details
* **Zig:** Uses BLST library with optimized MSM algorithms
* **TypeScript:** Leverages @noble/curves bls12-381 batch operations
* **Algorithm:** Pippenger's algorithm for optimal batch multiplication
* **Optimization:** Exploits shared computation across multiplications
* **Security:** Constant-time execution within discount tiers
## Gas Savings Analysis
Comparing MSM vs individual multiplications:
```typescript theme={null}
// 8 individual G2 muls
const individualGas = 8 * 45000; // 360,000 gas
// MSM with 8 pairs (discount 430)
const msmGas = (45000 * 8 * 430) / 1000; // 154,800 gas
// Savings: 205,200 gas (57% reduction)
```
Larger batches yield greater savings:
* **2 pairs:** 18% savings
* **4 pairs:** 42% savings
* **8 pairs:** 57% savings
* **16 pairs:** 68% savings
* **64 pairs:** 80% savings
## Extension Field Complexity
G2 MSM operates over Fp2:
* **Each point operation** requires Fp2 arithmetic
* **Fp2 multiplication:** \~4x cost of Fp multiplication
* **Pippenger's algorithm:** Amortizes point operations
* **Trade-off:** More memory for precomputed tables, fewer point operations
This explains why base gas is 3.75x higher than G1 MSM.
## Performance Considerations
* **Batch threshold:** MSM becomes beneficial at 2+ pairs
* **Memory usage:** Precomputation tables scale with input size
* **Optimal batch size:** 16-64 pairs balances cost and memory
* **Point at infinity:** Zero scalars handled efficiently
* **Input validation:** All points validated before computation
## Practical Example: Signature Aggregation
```typescript theme={null}
// Verify 10 BLS signatures on different messages
// Each verification needs: e(sig_i, H(m_i)) * e(pk_i, -G2)
// Instead of 10 individual operations:
// Cost: 10 * 45,000 = 450,000 gas
// Use MSM to aggregate signature components:
// 1. MSM over 10 signatures with random coefficients
// 2. MSM over 10 public keys with same coefficients
// Cost with discount 430: ~193,500 gas
// Savings: 256,500 gas (57% reduction)
```
## Discount Calculation Details
The discount schedule follows EIP-2537:
```zig theme={null}
pub fn msmDiscount(k: usize) u64 {
return if (k >= 128) 174
else if (k >= 64) 200
else if (k >= 32) 250
else if (k >= 16) 320
else if (k >= 8) 430
else if (k >= 4) 580
else if (k >= 2) 820
else 1000; // No discount for single pair
}
```
Discount improves in tiers, incentivizing larger batches.
## Test Vectors
```typescript theme={null}
// Empty input (invalid)
const result = bls12G2Msm([]);
// Error: Invalid input length
// Single pair (no discount)
const result = bls12G2Msm([{point: P1, scalar: s1}]);
// Gas: 45,000
// Two pairs (18% discount)
const result = bls12G2Msm([
{point: P1, scalar: s1},
{point: P2, scalar: s2}
]);
// Gas: (45,000 * 2 * 820) / 1000 = 73,800
// Result: s1*P1 + s2*P2
```
## Special Cases
* **All zero scalars:** Returns point at infinity
* **Single non-zero scalar:** Equivalent to G2 mul (but more expensive)
* **Point at infinity in input:** Contributes identity to sum
* **Duplicate points:** Handled correctly, scalars are summed
* **Mixed identity and non-identity:** Only non-identity points contribute
## Security Considerations
* **Subgroup validation:** All points checked for correct subgroup membership
* **Scalar overflow:** Scalars automatically reduced modulo curve order
* **Side-channel resistance:** Implementation uses constant-time algorithms
* **Memory bounds:** Input size limited by gas and block limits
## Gas Cost Justification
The 45,000 base gas reflects:
1. **Extension field operations:** Fp2 arithmetic overhead
2. **Pippenger's algorithm:** Precomputation and bucket operations
3. **Point validation:** Subgroup checks for all inputs
4. **Security overhead:** Constant-time guarantees
Discounts recognize that marginal cost per point decreases with batch size due to shared precomputation.
## When to Use MSM
✅ **Use MSM when:**
* Processing 2+ point-scalar pairs
* Batch verifying signatures
* Aggregating proofs or attestations
* Gas optimization is critical
❌ **Avoid MSM when:**
* Single scalar multiplication (use G2 mul directly)
* Points/scalars not known upfront
* Input preparation cost exceeds savings
## Related
* [Precompile: BLS12-381 G2 Add](/evm/precompiles/bls12-g2-add)
* [Precompile: BLS12-381 G2 Mul](/evm/precompiles/bls12-g2-mul)
* [Precompile: BLS12-381 G1 MSM](/evm/precompiles/bls12-g1-msm)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [Crypto: BLS12-381](/crypto/bls12-381)
* [EIP-2537: Precompile for BLS12-381 curve operations](https://eips.ethereum.org/EIPS/eip-2537)
# 0x0f BLS12-381 G2 Mul
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-g2-mul
BLS12-381 G2 scalar multiplication
**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
**Address:** `0x000000000000000000000000000000000000000f`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 G2 Mul precompile performs scalar multiplication on the BLS12-381 curve's G2 group. It multiplies a G2 point by a scalar, computing `scalar * point`. This operation is fundamental for BLS signature schemes, zero-knowledge proofs, and cryptographic protocols requiring operations over extension fields.
BLS12-381 provides 128 bits of security and is the foundation of Ethereum 2.0's consensus layer signature scheme.
## Gas Cost
**Fixed:** `45000` gas
## G2 vs G1
**G2 scalar multiplication** operates on points over the Fp2 extension field:
* **G1 points:** 128 bytes (2 Fp coordinates)
* **G2 points:** 256 bytes (2 Fp2 coordinates)
* **G1 mul gas:** 12,000
* **G2 mul gas:** 45,000 (3.75x more expensive)
* **Cost driver:** Extension field arithmetic is significantly more complex
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0 (point x-coordinate c0 component, big-endian)
64 | 64 | x.c1 (point x-coordinate c1 component, big-endian)
128 | 64 | y.c0 (point y-coordinate c0 component, big-endian)
192 | 64 | y.c1 (point y-coordinate c1 component, big-endian)
256 | 32 | scalar (multiplier, big-endian)
```
Total input length: 288 bytes (256 bytes G2 point + 32 bytes scalar)
G2 point must satisfy curve equation: `y^2 = x^3 + 4(1 + u)` over Fp2.
Scalar can be any 256-bit value (automatically reduced modulo curve order).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0 (result point x-coordinate c0 component, big-endian)
64 | 64 | x.c1 (result point x-coordinate c1 component, big-endian)
128 | 64 | y.c0 (result point y-coordinate c0 component, big-endian)
192 | 64 | y.c1 (result point y-coordinate c1 component, big-endian)
```
Total output length: 256 bytes
## Usage Example
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Multiply G2 point by scalar
// Using point at infinity (valid edge case: O * k = O)
const point = new Uint8Array(256); // All zeros = point at infinity
const scalar = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000005'); // multiply by 5
const input = new Uint8Array(288);
input.set(point, 0);
input.set(scalar, 256);
const result = execute(
PrecompileAddress.BLS12_G2_MUL,
input,
50000n,
Hardfork.PRAGUE
);
if (result.success) {
const resultPoint = result.output; // 256 bytes
const xc0 = result.output.slice(0, 64);
const xc1 = result.output.slice(64, 128);
const yc0 = result.output.slice(128, 192);
const yc1 = result.output.slice(192, 256);
console.log('Result G2 point:', { xc0, xc1, yc0, yc1 });
console.log('Gas used:', result.gasUsed); // 45000
} else {
console.error('Error:', result.error);
}
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// Create input: G2 point (256 bytes) + scalar (32 bytes)
var input = [_]u8{0} ** 288;
// ... populate G2 point coordinates
input[287] = 5; // scalar = 5
// Execute G2 multiplication
const result = try precompiles.bls12_g2_mul.execute(
allocator,
&input,
100000
);
defer result.deinit(allocator);
std.debug.print("Gas used: {}\n", .{result.gas_used}); // 45000
std.debug.print("Output length: {}\n", .{result.output.len}); // 256
}
```
## Error Conditions
* **Out of gas:** gasLimit \< 45,000
* **Invalid input length:** input.len != 288
* **Point not on curve:** coordinates don't satisfy G2 curve equation
* **Invalid field element:** coordinate component >= field modulus
* **Invalid point:** point not in correct subgroup
## Use Cases
* **BLS signature verification:** Key derivation and signature operations
* **Threshold signatures:** Generate signature shares
* **Key generation:** Derive public keys from private scalars
* **Commitment schemes:** Pedersen-like commitments over G2
* **Zero-knowledge proofs:** zkSNARKs and zkSTARKs on BLS12-381
* **Ethereum 2.0:** Validator key operations
## Implementation Details
* **Zig:** Uses BLST library optimized for BLS12-381
* **TypeScript:** Wraps @noble/curves bls12-381 G2 operations
* **Algorithm:** Windowed scalar multiplication for efficiency
* **Security:** Constant-time execution prevents timing attacks
* **Optimization:** Double-and-add with precomputed tables
## Special Cases
* **Scalar = 0:** Returns point at infinity (256 bytes of zeros)
* **Scalar = 1:** Returns input point unchanged
* **Scalar = group order:** Returns point at infinity (r\*P = O)
* **Point at infinity input:** Returns point at infinity regardless of scalar
* **Scalar > group order:** Automatically reduced modulo group order
## Scalar Arithmetic
Scalars are elements of F\_r where r is the curve order:
* **Group order (r):** Same as BLS12-381 scalar field order
* **Modular reduction:** Scalars wrap around modulo r
* **Zero scalar:** Always produces point at infinity
* **Negative scalars:** Equivalent to positive via modular arithmetic
## Extension Field Operations
G2 scalar multiplication involves Fp2 arithmetic:
* **Field elements:** `a = a.c0 + a.c1*u` where u^2 + 1 = 0
* **Point doubling:** Requires Fp2 squaring and multiplication
* **Point addition:** Complex formula over extension field
* **Cost:** Each Fp2 operation is \~3-4x more expensive than Fp
This complexity explains why G2 mul is 3.75x more expensive than G1 mul.
## Gas Comparison
| Operation | G1 Gas | G2 Gas | Ratio |
| -------------- | ------ | ------ | ----- |
| Addition | 500 | 800 | 1.6x |
| Multiplication | 12,000 | 45,000 | 3.75x |
| MSM (base) | 12,000 | 45,000 | 3.75x |
The multiplication cost ratio reflects the increased complexity of extension field arithmetic.
## Performance Considerations
* **Expensive operation:** 45,000 gas is substantial
* **Batch with MSM:** For multiple scalar muls, use G2 MSM with discount
* **Precomputation:** Cache commonly used multiples when possible
* **G1 vs G2 choice:** Use G1 operations when either group works
* **Signature verification:** Typically requires 1-2 G2 muls
## Test Vectors
```typescript theme={null}
// Generator * 0 = Identity
const scalar = 0n;
const result = bls12G2Mul(G2_GENERATOR, scalar);
// result = point at infinity (256 bytes of zeros)
// Generator * 1 = Generator
const result = bls12G2Mul(G2_GENERATOR, 1n);
// result = G2_GENERATOR
// Point * group_order = Identity
const result = bls12G2Mul(somePoint, groupOrder);
// result = point at infinity
```
## BLS Signature Context
In BLS signature schemes:
* **Public keys:** Often G2 points derived via scalar multiplication
* **Signature verification:** Requires G2 scalar operations
* **Key aggregation:** Combine public keys via G2 addition
* **Threshold schemes:** Generate key shares with G2 mul
## Security Considerations
* **128-bit security:** BLS12-381 provides quantum-resistant classical security
* **Side-channel resistance:** Constant-time implementation prevents timing attacks
* **Subgroup checks:** Implementation validates points are in correct subgroup
* **Field validation:** Coordinates must be valid field elements
## Gas Cost Justification
The 45,000 gas cost reflects:
1. **Extension field arithmetic:** Fp2 operations are computationally intensive
2. **Security overhead:** Subgroup and validity checks
3. **Scalar multiplication:** Requires \~255 point operations on average
4. **Memory operations:** 256-byte point representation
Compared to BN254 mul (6,000 gas), the higher cost accounts for stronger security and extension field complexity.
## Related
* [Precompile: BLS12-381 G2 Add](/evm/precompiles/bls12-g2-add)
* [Precompile: BLS12-381 G2 MSM](/evm/precompiles/bls12-g2-msm)
* [Precompile: BLS12-381 G1 Mul](/evm/precompiles/bls12-g1-mul)
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [Crypto: BLS12-381](/crypto/bls12-381)
* [EIP-2537: Precompile for BLS12-381 curve operations](https://eips.ethereum.org/EIPS/eip-2537)
# 0x12 BLS12-381 Map Fp to G1
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-map-fp-to-g1
Deterministic hash-to-curve mapping from base field element to G1 point
**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
**Address:** `0x0000000000000000000000000000000000000012`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 Map Fp to G1 precompile maps a field element from the base field Fp to a point on the G1 curve. This is a core building block for hash-to-curve operations, enabling deterministic point generation for BLS signatures, VRFs, and other cryptographic protocols.
Hash-to-curve provides a way to hash arbitrary messages to curve points in a way that is:
* **Deterministic:** Same input always produces same output
* **Uniform:** Output distribution is indistinguishable from random
* **One-way:** Cannot reverse the mapping
* **Collision-resistant:** Hard to find different inputs mapping to same point
## Hash-to-Curve Overview
The complete hash-to-curve process typically involves:
1. **Hash message to field elements** using hash\_to\_field (external)
2. **Map field elements to curve points** using this precompile (0x12)
3. **Clear cofactor** to ensure point is in correct subgroup (if needed)
This precompile implements step 2: the deterministic mapping from a field element to a G1 curve point.
## Gas Cost
**Fixed cost:** `5,500` gas (constant, independent of input)
Much cheaper than elliptic curve operations since it's a single mapping operation without scalar multiplication.
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | Field element in Fp (big-endian, padded)
```
Total input length: **64 bytes** (exactly)
**Field element constraints:**
* Must be \< field modulus p
* Big-endian encoding
* Left-padded with zeros to 64 bytes
* All values 0 to p-1 are valid inputs
**BLS12-381 base field modulus p:**
```
0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
```
(381-bit prime, \~48 bytes, padded to 64)
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x coordinate (big-endian, padded)
64 | 64 | y coordinate (big-endian, padded)
```
Total output length: **128 bytes** (G1 point in uncompressed form)
Output is always a valid G1 point on the curve. The mapping ensures:
* Point is on curve: y² = x³ + 4
* Point is in correct subgroup (after cofactor clearing if protocol requires)
* Mapping is deterministic and injective
## Usage Examples
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Map a hash to a G1 point for signature schemes
function hashToG1Point(message: Uint8Array): Uint8Array {
// Step 1: Hash message to field element
const hash = Keccak256.hash(message);
// Pad to 64 bytes (field element size)
const fpElement = Bytes64(hash); // Automatically handles padding
// Step 2: Map to G1 using precompile
const result = execute(
PrecompileAddress.BLS12_MAP_FP_TO_G1,
fpElement,
5500n,
Hardfork.PRAGUE
);
if (!result.success) {
throw new Error(`Map failed: ${result.error}`);
}
return result.output; // 128-byte G1 point
}
// Use in BLS signature scheme
const message = new TextEncoder().encode("Sign this message");
const messagePoint = hashToG1Point(message);
console.log('Message mapped to G1 point:', messagePoint);
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
const crypto = @import("crypto");
/// Hash message to G1 point for BLS signatures
pub fn hashToG1(
allocator: std.mem.Allocator,
message: []const u8,
) ![]u8 {
// Step 1: Hash to field element
var fp_element: [64]u8 = undefined;
@memset(&fp_element, 0);
const hash = crypto.Crypto.keccak256(message);
// Right-align hash in 64-byte buffer
@memcpy(fp_element[32..64], &hash);
// Step 2: Map to G1
const result = try precompiles.bls12_map_fp_to_g1.execute(
allocator,
&fp_element,
5500,
);
return result.output; // Caller owns memory
}
test "hash message to G1" {
const msg = "Hello BLS12-381";
const point = try hashToG1(std.testing.allocator, msg);
defer std.testing.allocator.free(point);
try std.testing.expectEqual(@as(usize, 128), point.len);
// Point should not be point at infinity
const is_zero = for (point) |byte| {
if (byte != 0) break false;
} else true;
try std.testing.expect(!is_zero);
}
```
## Error Conditions
* **Out of gas:** Gas limit less than 5,500
* **Invalid input length:** Input not exactly 64 bytes
* **Field element overflow:** Input value >= field modulus p
* **Invalid encoding:** Malformed field element
Note: All field elements in range \[0, p-1] are valid inputs and will successfully map to G1 points.
## Use Cases
### BLS Signature Hash-to-Curve
BLS signatures require hashing messages to curve points:
```typescript theme={null}
// BLS signature: sig = H(m)^sk where H maps to G2
// For G1 variant: sig = sk * H(m) where H maps to G1
function signMessage(secretKey: bigint, message: Uint8Array): Uint8Array {
// Hash message to G1 point
const messagePoint = hashToG1(message);
// Multiply by secret key (use G1_MUL precompile 0x0c)
// signature = secretKey * messagePoint
// ...
return signature;
}
```
### Verifiable Random Functions (VRF)
VRFs use hash-to-curve for deterministic randomness:
```typescript theme={null}
// VRF: Prove you know secret key that produces output
// Gamma = H(alpha)^sk
// Proof = NIZK that discrete logs match
function vrfProve(secretKey: bigint, alpha: Uint8Array) {
const h = hashToG1(alpha); // H(alpha)
// Gamma = sk * h (use G1_MUL precompile)
// Generate NIZK proof...
}
```
### Identity-Based Encryption
Map identities (email addresses, etc.) to public keys:
```typescript theme={null}
function identityToPublicKey(identity: string): Uint8Array {
const identityBytes = new TextEncoder().encode(identity);
return hashToG1(identityBytes);
}
// Now can encrypt to "alice@example.com" without prior key exchange
const alicePubKey = identityToPublicKey("alice@example.com");
```
### Threshold Cryptography
Deterministic point generation for distributed key generation:
```typescript theme={null}
function generateCommitment(coefficientIndex: number): Uint8Array {
const input = Bytes64();
new DataView(input.buffer).setBigUint64(56, BigInt(coefficientIndex), false);
const result = execute(
PrecompileAddress.BLS12_MAP_FP_TO_G1,
input,
5500n,
Hardfork.PRAGUE
);
return result.output;
}
```
## Implementation Details
* **Algorithm:** Simplified SWU (Shallue-van de Woestijne-Ulas) map
* **Curve:** BLS12-381 G1 over Fp (equation: y² = x³ + 4)
* **Properties:** Deterministic, injective (one-to-one), constant-time
* **Zig:** Uses blst library implementation via C FFI
* **TypeScript:** Uses @noble/curves BLS12-381 hash-to-curve
### Simplified SWU Method
The map uses an isogeny-based approach:
1. Map Fp element to point on isogenous curve E'
2. Evaluate isogeny map to get point on target curve E
3. Result is valid G1 point
This provides better distribution properties than older try-and-increment methods.
## Hash-to-Curve Standards
This precompile implements the mapping function from:
* **RFC:** [draft-irtf-cfrg-hash-to-curve](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve)
* **Suite:** BLS12381G1\_XMD:SHA-256\_SSWU\_RO\_
* **Method:** Simplified Shallue-van de Woestijne-Ulas (SSWU)
For complete hash-to-curve:
1. Use hash\_to\_field to get two field elements u₀, u₁
2. Map both to curve: Q₀ = map(u₀), Q₁ = map(u₁)
3. Add points: Q = Q₀ + Q₁
4. Clear cofactor: P = clear\_cofactor(Q)
This precompile handles step 2. Steps 1, 3, 4 done in application code.
## Security Considerations
### Constant-Time Execution
The mapping must be constant-time to prevent timing side-channels:
* No branches based on input value
* Uniform execution path for all inputs
* Protects secret keys in signature schemes
### Distribution Uniformity
The map produces points with distribution indistinguishable from random:
* Important for VRF security
* Prevents bias in cryptographic protocols
* Two-map approach (u₀, u₁) improves uniformity
### Domain Separation
Different protocols should use different domain separation tags:
```typescript theme={null}
const DST = "MY_PROTOCOL_V1_HASH_TO_G1";
// Include DST in hash_to_field step before calling this precompile
```
## Comparison with Other Approaches
### Try-and-Increment (Legacy)
* Hash + point validation loop
* Variable time (security risk)
* Non-uniform distribution
* Not recommended
### Simplified SWU (This Precompile)
* Constant time
* Uniform distribution
* Standards-compliant
* Recommended
## Test Vectors
### Zero Element
```typescript theme={null}
const input = Bytes64(); // All zeros
const result = execute(
PrecompileAddress.BLS12_MAP_FP_TO_G1,
input,
5500n,
Hardfork.PRAGUE
);
// Should succeed with valid G1 point
console.log('Mapped point:', result.output);
```
### Maximum Field Element
```typescript theme={null}
// p-1 is maximum valid input
const input = Bytes64();
input.set([
0x1a, 0x01, 0x11, 0xea, 0x39, 0x7f, 0xe6, 0x9a,
0x4b, 0x1b, 0xa7, 0xb6, 0x43, 0x4b, 0xac, 0xd7,
0x64, 0x77, 0x4b, 0x84, 0xf3, 0x85, 0x12, 0xbf,
0x67, 0x30, 0xd2, 0xa0, 0xf6, 0xb0, 0xf6, 0x24,
0x1e, 0xab, 0xff, 0xfe, 0xb1, 0x53, 0xff, 0xff,
0xb9, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xaa,
], 16); // Right-align in 64 bytes
const result = execute(
PrecompileAddress.BLS12_MAP_FP_TO_G1,
input,
5500n,
Hardfork.PRAGUE
);
// Should succeed
```
### Determinism Test
```typescript theme={null}
const input = Bytes64();
input[63] = 42;
const result1 = execute(PrecompileAddress.BLS12_MAP_FP_TO_G1, input, 5500n, Hardfork.PRAGUE);
const result2 = execute(PrecompileAddress.BLS12_MAP_FP_TO_G1, input, 5500n, Hardfork.PRAGUE);
// Same input always produces same output
console.assert(result1.output.every((b, i) => b === result2.output[i]));
```
## Related
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [Precompile: BLS12-381 Map Fp2 to G2](/evm/precompiles/bls12-map-fp2-to-g2)
* [Precompile: BLS12-381 G1 Mul](/evm/precompiles/bls12-g1-mul)
* [Precompile: BLS12-381 G1 Add](/evm/precompiles/bls12-g1-add)
* [EIP-2537: Precompiles for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [Hash to Curve RFC](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve)
* [BLS Signatures Spec](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature)
# 0x13 BLS12-381 Map Fp2 to G2
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-map-fp2-to-g2
Deterministic hash-to-curve mapping from extension field element to G2 point
**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
**Address:** `0x0000000000000000000000000000000000000013`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 Map Fp2 to G2 precompile maps an element from the quadratic extension field Fp2 to a point on the G2 curve. This is the G2 equivalent of the G1 hash-to-curve operation, essential for BLS signatures where messages are hashed to G2 (the standard BLS variant).
G2 operates over Fp2, the quadratic extension field Fp2 = Fp\[u]/(u²+1), providing additional algebraic structure required for pairing-based cryptography. Most BLS signature schemes hash messages to G2 rather than G1 for efficiency reasons.
## Hash-to-Curve for G2
The complete hash-to-curve process for G2:
1. **Hash message to two Fp2 elements** using hash\_to\_field (external)
2. **Map each Fp2 element to G2 point** using this precompile (0x13)
3. **Add the two points** (use G2\_ADD precompile 0x0e)
4. **Clear cofactor** to ensure point is in correct subgroup (if needed)
This precompile implements step 2: mapping a single Fp2 element to a G2 curve point.
## Extension Field Fp2
Fp2 is constructed as Fp\[u]/(u²+1), where:
* Elements have form: `a = c0 + c1*u`
* Addition: `(a0 + a1*u) + (b0 + b1*u) = (a0+b0) + (a1+b1)*u`
* Multiplication: `(a0 + a1*u) * (b0 + b1*u) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)*u`
* Constraint: `u² = -1`
Each component c0, c1 is an element of the base field Fp.
## Gas Cost
**Fixed cost:** `75,000` gas (current implementation)
**Note:** The EIP-2537 specification proposes 23,800 gas for this operation. The current implementation uses 75,000 gas which may represent a pre-repricing value or conservative estimate. Consult the latest EIP-2537 status for the finalized gas cost. Code uses 75,000 in `/Users/williamcory/voltaire/src/precompiles/precompiles.ts` line 1196.
Higher than G1 mapping (5,500 gas) due to:
* Larger field (Fp2 vs Fp)
* More complex curve arithmetic
* G2 point operations are inherently more expensive
Still much cheaper than scalar multiplication operations.
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | c0: First component of Fp2 element (big-endian)
64 | 64 | c1: Second component of Fp2 element (big-endian)
```
Total input length: **128 bytes** (exactly)
**Fp2 element encoding:**
* Element is `c0 + c1*u` where u² = -1
* Each component must be \< field modulus p
* Both components big-endian, left-padded to 64 bytes
* All values where c0, c1 ∈ \[0, p-1] are valid
**BLS12-381 field modulus p:**
```
0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
```
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | x.c0: First component of x coordinate
64 | 64 | x.c1: Second component of x coordinate
128 | 64 | y.c0: First component of y coordinate
192 | 64 | y.c1: Second component of y coordinate
```
Total output length: **256 bytes** (G2 point in uncompressed form)
**G2 point structure:**
* x = x.c0 + x.c1\*u (Fp2 element)
* y = y.c0 + y.c1\*u (Fp2 element)
* Satisfies curve equation: y² = x³ + 4(1+u)
## Usage Examples
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Hash message to G2 point (standard BLS signature scheme)
function hashToG2Point(message: Uint8Array): Uint8Array {
// Step 1: Hash message to two field elements (simplified)
const hash1 = Keccak256.hash(message);
const hash2 = Keccak256.hash(hash1);
// Create two Fp2 elements (128 bytes each: c0 + c1)
const u0 = new Uint8Array(128);
const u0c0 = Bytes64(hash1); // c0 component from hash
u0.set(u0c0, 0);
// c1 component stays zero for simplification (bytes 64-127)
const u1 = new Uint8Array(128);
const u1c0 = Bytes64(hash2); // c0 component from hash
u1.set(u1c0, 0);
// Step 2: Map both to G2
const q0Result = execute(
PrecompileAddress.BLS12_MAP_FP2_TO_G2,
u0,
75000n, // Current implementation gas cost
Hardfork.PRAGUE
);
const q1Result = execute(
PrecompileAddress.BLS12_MAP_FP2_TO_G2,
u1,
75000n, // Current implementation gas cost
Hardfork.PRAGUE
);
if (!q0Result.success || !q1Result.success) {
throw new Error('Mapping failed');
}
// Step 3: Add points (use G2_ADD precompile 0x0e)
const addInput = new Uint8Array(512);
addInput.set(q0Result.output, 0);
addInput.set(q1Result.output, 256);
const addResult = execute(
PrecompileAddress.BLS12_G2_ADD,
addInput,
800n,
Hardfork.PRAGUE
);
return addResult.output; // 256-byte G2 point
}
// BLS signature: Sign by multiplying message point by secret key
const message = new TextEncoder().encode("Sign this");
const messagePoint = hashToG2Point(message);
console.log('Message hashed to G2:', messagePoint.length, 'bytes');
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
const crypto = @import("crypto");
/// Hash message to G2 point for BLS signatures
pub fn hashToG2(
allocator: std.mem.Allocator,
message: []const u8,
) ![]u8 {
// Step 1: Hash to two Fp2 elements
var u0: [128]u8 = undefined;
var u1: [128]u8 = undefined;
@memset(&u0, 0);
@memset(&u1, 0);
// Hash message
const hash1 = crypto.Crypto.keccak256(message);
const hash2 = crypto.Crypto.keccak256(&hash1);
// Create Fp2 elements (simplified - c1 components zero)
@memcpy(u0[96..128], hash1[0..32]);
@memcpy(u1[96..128], hash2[0..32]);
// Step 2: Map both to G2
const q0_result = try precompiles.bls12_map_fp2_to_g2.execute(
allocator,
&u0,
75000, // Current implementation gas cost
);
defer allocator.free(q0_result.output);
const q1_result = try precompiles.bls12_map_fp2_to_g2.execute(
allocator,
&u1,
75000, // Current implementation gas cost
);
defer allocator.free(q1_result.output);
// Step 3: Add points
var add_input = try allocator.alloc(u8, 512);
defer allocator.free(add_input);
@memcpy(add_input[0..256], q0_result.output);
@memcpy(add_input[256..512], q1_result.output);
const add_result = try precompiles.bls12_g2_add.execute(
allocator,
add_input,
800,
);
return add_result.output; // Caller owns memory
}
test "hash to G2" {
const msg = "Hello BLS!";
const point = try hashToG2(std.testing.allocator, msg);
defer std.testing.allocator.free(point);
try std.testing.expectEqual(@as(usize, 256), point.len);
}
```
## Error Conditions
* **Out of gas:** Gas limit less than 75,000 (current implementation)
* **Invalid input length:** Input not exactly 128 bytes
* **Field element overflow:** c0 >= p or c1 >= p
* **Invalid Fp2 encoding:** Malformed extension field element
All Fp2 elements with both components in range \[0, p-1] are valid inputs.
## Use Cases
### BLS Signature Scheme (Standard Variant)
Standard BLS hashes messages to G2, signs in G2:
```typescript theme={null}
// Secret key: sk ∈ Zr (scalar)
// Public key: PK = sk * G1 (point in G1)
// Signature: sig = sk * H(m) where H(m) ∈ G2
// Verify: e(PK, H(m)) = e(G1, sig)
function blsSign(secretKey: bigint, message: Uint8Array): Uint8Array {
// Hash message to G2
const h = hashToG2Point(message);
// Multiply by secret key (use G2_MUL precompile 0x0f)
const mulInput = new Uint8Array(288);
mulInput.set(h, 0);
// Set scalar (32 bytes at offset 256)
// ... secretKey encoding
const result = execute(
PrecompileAddress.BLS12_G2_MUL,
mulInput,
45000n,
Hardfork.PRAGUE
);
return result.output; // Signature in G2
}
```
### Aggregate Signatures
Multiple signatures on different messages:
```typescript theme={null}
// Each signer signs their message
const sig1 = blsSign(sk1, msg1); // H(msg1)^sk1
const sig2 = blsSign(sk2, msg2); // H(msg2)^sk2
// Aggregate signatures (point addition in G2)
const aggInput = new Uint8Array(512);
aggInput.set(sig1, 0);
aggInput.set(sig2, 256);
const aggSig = execute(
PrecompileAddress.BLS12_G2_ADD,
aggInput,
800n,
Hardfork.PRAGUE
).output;
// Verify aggregate:
// e(PK1, H(msg1)) * e(PK2, H(msg2)) = e(G1, aggSig)
```
### Threshold Signatures
Distribute signing authority across multiple parties:
```typescript theme={null}
// Each party holds share of secret key
// Hash message to G2 once
const messagePoint = hashToG2Point(message);
// Each party signs with their share
const shares = parties.map(party =>
party.signWithShare(messagePoint)
);
// Combine t-of-n shares to reconstruct signature
const signature = lagrangeInterpolate(shares);
```
### Boneh-Lynn-Shacham Signatures
Original BLS paper construction:
* Short signatures (G2 points)
* Aggregation without interaction
* Batch verification
```typescript theme={null}
// Verify batch of signatures
function batchVerify(
publicKeys: Uint8Array[], // G1 points
messages: Uint8Array[],
signatures: Uint8Array[] // G2 points
): boolean {
// Compute pairings for each (PK, H(msg), sig)
// Product of all pairings should equal 1
// Use BLS12_PAIRING precompile (0x11)
}
```
## Implementation Details
* **Algorithm:** Simplified SWU map for G2 curve
* **Curve:** BLS12-381 G2 over Fp2 (twist curve)
* **Equation:** y² = x³ + 4(1+u) where u² = -1
* **Properties:** Deterministic, constant-time, uniform distribution
* **Zig:** Uses blst library via C FFI
* **TypeScript:** Uses @noble/curves BLS12-381
### G2 Curve Properties
G2 is the twist of the base curve:
* Defined over Fp2 instead of Fp
* Same group order as G1
* Larger representation (256 bytes vs 128 bytes)
* Slower arithmetic but richer structure for pairings
### Why Hash to G2?
BLS signatures typically hash to G2 because:
1. **Verification efficiency:** Public keys in G1 (smaller)
2. **Signature aggregation:** Addition in G2 during signing
3. **Pairing efficiency:** G1 in first position of pairing is faster
Alternative (hash to G1) is used when aggregating public keys instead.
## Hash-to-Curve Standards
Implements mapping from:
* **RFC:** [draft-irtf-cfrg-hash-to-curve](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve)
* **Suite:** BLS12381G2\_XMD:SHA-256\_SSWU\_RO\_
* **Method:** Simplified SWU for G2 twist curve
Complete hash-to-curve (standards-compliant):
1. hash\_to\_field: message → (u0, u1) where ui ∈ Fp2
2. map\_to\_curve: ui → Qi for i = 0,1 (this precompile)
3. Q = Q0 + Q1 (use G2\_ADD)
4. P = clear\_cofactor(Q)
## Security Considerations
### Constant-Time Execution
Critical for signature schemes:
* No timing leakage of field element values
* Uniform execution across all valid inputs
* Protects against side-channel attacks on secret keys
### Uniform Distribution
Two-map construction (u0, u1) ensures:
* Output distribution indistinguishable from random
* No bias toward specific curve points
* Security proofs require uniformity
### Domain Separation Tags
Use unique DST per protocol:
```typescript theme={null}
const DST = "MY_PROTOCOL_V1_G2_HASH";
// Include in hash_to_field before calling precompile
```
Prevents cross-protocol attacks.
### Subgroup Checking
After mapping, ensure point is in correct subgroup:
* G2 has cofactor h = 0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5
* Clear cofactor by multiplying: `P = h * Q`
* Or use cofactor clearing map (protocol-specific)
## Performance Notes
### Gas Comparison
| Operation | Gas | Notes |
| ------------- | ------ | ----------------------- |
| Map Fp to G1 | 5,500 | Base field |
| Map Fp2 to G2 | 75,000 | Extension field (13.6x) |
| G1 Add | 500 | Point addition |
| G2 Add | 800 | Point addition |
| G1 Mul | 12,000 | Scalar multiplication |
| G2 Mul | 45,000 | Scalar multiplication |
G2 operations consistently \~3-13x more expensive than G1.
### Complete Hash-to-G2 Cost
```
2 × MAP_FP2_TO_G2: 2 × 75,000 = 150,000
1 × G2_ADD: 1 × 800 = 800
Total: = 150,800 gas
```
Plus external hash\_to\_field computation. Note: If EIP-2537 repricing occurs (23,800 per map), total would be \~48,400 gas.
## Test Vectors
### Zero Fp2 Element
```typescript theme={null}
const input = new Uint8Array(128); // All zeros (0 + 0*u)
const result = execute(
PrecompileAddress.BLS12_MAP_FP2_TO_G2,
input,
75000n,
Hardfork.PRAGUE
);
// Should succeed with valid G2 point
console.log('Zero mapped to G2:', result.success);
```
### Non-zero c0, Zero c1
```typescript theme={null}
const input = new Uint8Array(128);
input[63] = 1; // c0 = 1, c1 = 0
// Represents Fp2 element: 1 + 0*u
const result = execute(
PrecompileAddress.BLS12_MAP_FP2_TO_G2,
input,
75000n,
Hardfork.PRAGUE
);
console.log('Success:', result.success);
console.log('Point length:', result.output.length); // 256
```
### Both Components Non-zero
```typescript theme={null}
const input = new Uint8Array(128);
input[63] = 2; // c0 = 2
input[127] = 3; // c1 = 3
// Represents: 2 + 3*u
const result = execute(
PrecompileAddress.BLS12_MAP_FP2_TO_G2,
input,
75000n,
Hardfork.PRAGUE
);
// Should produce different point than previous examples
```
### Determinism Verification
```typescript theme={null}
const input = new Uint8Array(128);
input[63] = 42;
input[127] = 137;
const result1 = execute(PrecompileAddress.BLS12_MAP_FP2_TO_G2, input, 75000n, Hardfork.PRAGUE);
const result2 = execute(PrecompileAddress.BLS12_MAP_FP2_TO_G2, input, 75000n, Hardfork.PRAGUE);
// Same input must produce identical output
console.assert(result1.output.every((b, i) => b === result2.output[i]));
```
## Related
* [Precompile: BLS12-381 Pairing](/evm/precompiles/bls12-pairing)
* [Precompile: BLS12-381 Map Fp to G1](/evm/precompiles/bls12-map-fp-to-g1)
* [Precompile: BLS12-381 G2 Add](/evm/precompiles/bls12-g2-add)
* [Precompile: BLS12-381 G2 Mul](/evm/precompiles/bls12-g2-mul)
* [EIP-2537: Precompiles for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [Hash to Curve RFC](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve)
* [BLS Signatures Spec](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature)
* [Boneh-Lynn-Shacham Signatures](https://www.iacr.org/archive/asiacrypt2001/22480516.pdf)
# 0x11 BLS12-381 Pairing
Source: https://voltaire.tevm.sh/evm/precompiles/bls12-pairing
BLS12-381 elliptic curve pairing check for signature verification and advanced cryptography
**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
**Address:** `0x0000000000000000000000000000000000000011`
**Introduced:** Prague (EIP-2537)
**EIP:** [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537)
The BLS12-381 Pairing precompile performs a pairing check on the BLS12-381 curve. It verifies whether the product of pairings equals identity: `e(G1_1, G2_1) * e(G1_2, G2_2) * ... * e(G1_k, G2_k) = 1`. This operation is fundamental for BLS signature verification, zkSNARK systems, and advanced cryptographic protocols.
BLS12-381 offers 128-bit security (vs BN254's \~100 bits), making it the preferred curve for modern applications. It's used by Ethereum 2.0 for validator signatures.
## Pairing-Based Cryptography
A pairing is a bilinear map `e: G1 × G2 → GT` with these properties:
* **Bilinearity:** `e(aP, bQ) = e(P, Q)^(ab) = e(bP, aQ)`
* **Non-degeneracy:** `e(G1, G2) ≠ 1` for generators G1, G2
* **Computability:** Can be efficiently calculated
This enables:
* **Signature aggregation:** Combine multiple signatures into one
* **Zero-knowledge proofs:** Efficient proof verification
* **Identity-based encryption:** Encrypt to public identity
## Gas Cost
**Formula:** `115000 + 23000 * k` where k = number of point pairs
**Examples:**
* Empty input (k=0): 115,000 gas
* 1 pair: 138,000 gas
* 2 pairs: 161,000 gas
* 5 pairs: 230,000 gas
Note: Higher base cost than BN254 due to larger field size and higher security level.
## Input Format
Input must be a multiple of 384 bytes. Each pair consists of:
```
Offset | Length | Description
-------|--------|-------------
0 | 128 | G1 point (64-byte x, 64-byte y in Fp)
128 | 256 | G2 point (four 64-byte values: x.c0, x.c1, y.c0, y.c1 in Fp2)
```
Each 384-byte chunk represents one (G1, G2) pair.
* k pairs = 384 \* k bytes
* Empty input (0 bytes) is valid and returns success (empty product = 1)
**Field encoding:**
* **G1:** Points on E(Fp) where Fp has 381-bit prime modulus
* **G2:** Points on E'(Fp2) where Fp2 = Fp\[u]/(u²+1)
* All coordinates are big-endian, left-padded to 64 bytes
* Point at infinity: all zeros (128 bytes for G1, 256 bytes for G2)
**BLS12-381 field modulus p:**
```
0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
```
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | 1 if pairing check passes, 0 otherwise
```
Total output length: 32 bytes (single word)
* Success: `0x0000...0001` (last byte = 1)
* Failure: `0x0000...0000` (all zeros)
## Usage Examples
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Verify BLS signature: e(pubkey, H(msg)) = e(G1, signature)
// Rearranged: e(pubkey, H(msg)) * e(-G1, signature) = 1
const numPairs = 2;
const input = new Uint8Array(384 * numPairs);
// Pair 1: (pubkey, H(msg))
// G1 point: pubkey (128 bytes) - would be actual public key in production
const pubkeyG1Point = new Uint8Array(128);
// G2 point: H(msg) (256 bytes) - would be hash-to-curve result in production
const hashToG2Point = new Uint8Array(256);
input.set(pubkeyG1Point, 0);
input.set(hashToG2Point, 128);
// Pair 2: (-G1_generator, signature)
// G1 point: negated generator (128 bytes) - would be computed negation in production
const negatedG1Generator = new Uint8Array(128);
// G2 point: signature (256 bytes) - would be actual signature in production
const signatureG2Point = new Uint8Array(256);
input.set(negatedG1Generator, 384);
input.set(signatureG2Point, 512);
const gasNeeded = 115000n + 23000n * 2n;
const result = execute(
PrecompileAddress.BLS12_PAIRING,
input,
gasNeeded,
Hardfork.PRAGUE
);
if (result.success && result.output[31] === 1) {
console.log('BLS signature verified!');
} else {
console.log('Signature invalid');
}
console.log('Gas used:', result.gasUsed);
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn verifyBLSSignature(
allocator: std.mem.Allocator,
pubkey: []const u8, // 128 bytes G1
message_hash: []const u8, // 256 bytes G2
signature: []const u8, // 256 bytes G2
) !bool {
// Create input: pubkey || H(msg) || -G1 || sig
var input = try allocator.alloc(u8, 768); // 2 pairs
defer allocator.free(input);
// Pair 1: (pubkey, H(msg))
@memcpy(input[0..128], pubkey);
@memcpy(input[128..384], message_hash);
// Pair 2: (-G1, signature)
@memcpy(input[384..512], &negated_g1_generator);
@memcpy(input[512..768], signature);
const gas_limit = 115000 + 23000 * 2;
const result = try precompiles.bls12_pairing.execute(
allocator,
input,
gas_limit,
);
defer allocator.free(result.output);
// Check if pairing succeeded
return result.output[31] == 1;
}
```
## Error Conditions
* **Out of gas:** Gas limit less than required
* **Invalid input length:** Not multiple of 384 bytes
* **Invalid G1 point:** Point not on curve or not in correct subgroup
* **Invalid G2 point:** Point not on curve or not in correct subgroup
* **Field element overflow:** Coordinate >= field modulus p
* **Invalid Fp2 encoding:** G2 point coordinates not in Fp2
Failures return error (not false). Only valid inputs that fail the pairing check return false (32 zero bytes).
## Use Cases
### BLS Signature Verification
BLS signatures use pairing to verify:
```
e(PK, H(m)) = e(G1, sig)
```
Rearranged for single pairing check:
```
e(PK, H(m)) * e(-G1, sig) = 1
```
### BLS Signature Aggregation
Multiple signatures can be aggregated:
```
sig_agg = sig1 + sig2 + ... + sigN
```
Verify with multi-pairing:
```
e(PK1, H(m1)) * e(PK2, H(m2)) * ... * e(PKN, H(mN)) * e(-G1, sig_agg) = 1
```
Gas cost scales linearly: `115000 + 23000 * (N+1)`
### zkSNARK Verification
Pairing enables efficient verification of zero-knowledge proofs:
* Groth16 requires multiple pairings
* PLONK uses KZG commitments (pairing-based)
* BLS12-381's higher security suitable for long-term proofs
### Validator Signatures (Ethereum 2.0)
Ethereum 2.0 uses BLS12-381 for:
* Block proposal signatures
* Attestation signatures
* Aggregate signatures (efficient verification)
## Implementation Details
* **Zig:** Uses blst library via C FFI for production-grade performance
* **TypeScript:** Uses @noble/curves BLS12-381 implementation
* **Algorithm:** Optimal Ate pairing with final exponentiation
* **Optimization:** Miller loop computed simultaneously for all pairs
* **Security:** 128-bit security level, suitable for long-term use
## Pairing Properties
### Bilinearity
```
e(a*P, b*Q) = e(P, Q)^(a*b)
e(P1 + P2, Q) = e(P1, Q) * e(P2, Q)
e(P, Q1 + Q2) = e(P, Q1) * e(P, Q2)
```
### Multi-Pairing Optimization
Computing k pairings together is more efficient than k separate calls:
* Shared Miller loop computation
* Single final exponentiation
* \~40% gas savings vs individual calls
### Empty Pairing
Empty input (0 pairs) returns success because empty product equals 1 (identity element).
## Comparison: BLS12-381 vs BN254
| Property | BLS12-381 | BN254 |
| ------------ | ------------- | ----------------- |
| Security | 128-bit | \~100-bit |
| Field size | 381 bits | 254 bits |
| G1 encoding | 128 bytes | 64 bytes |
| G2 encoding | 256 bytes | 128 bytes |
| Base gas | 115,000 | 45,000 |
| Per-pair gas | 23,000 | 34,000 |
| Use case | Modern (ETH2) | Legacy (zkSNARKs) |
BLS12-381 is preferred for new applications due to higher security margin.
## Test Vectors
### Empty Pairing
```typescript theme={null}
const input = new Uint8Array(0);
// Expected: output[31] === 1 (empty product = 1)
```
### Single Pair (Generators)
```typescript theme={null}
// e(G1, G2) should not equal 1 (non-degeneracy)
const input = new Uint8Array(384);
// Set G1 generator at [0..128]
// Set G2 generator at [128..384]
// Expected: output[31] === 0
```
### Identity Check
```typescript theme={null}
// e(P, Q) * e(-P, Q) = e(0, Q) = 1
// Two pairs: (P, Q) and (-P, Q)
const input = new Uint8Array(768);
// Expected: output[31] === 1
```
## Related
* [Precompile: BLS12-381 Map Fp to G1](/evm/precompiles/bls12-map-fp-to-g1)
* [Precompile: BLS12-381 Map Fp2 to G2](/evm/precompiles/bls12-map-fp2-to-g2)
* [Precompile: BLS12-381 G1 Add](/evm/precompiles/bls12-g1-add)
* [Precompile: BLS12-381 G2 Add](/evm/precompiles/bls12-g2-add)
* [EIP-2537: Precompiles for BLS12-381 Curve Operations](https://eips.ethereum.org/EIPS/eip-2537)
* [BLS Signatures Spec](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature)
# 0x06 BN254 Add
Source: https://voltaire.tevm.sh/evm/precompiles/bn254-add
BN254 elliptic curve point addition
**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
**Address:** `0x0000000000000000000000000000000000000006`
**Introduced:** Byzantium (EIP-196)
**EIP:** [EIP-196](https://eips.ethereum.org/EIPS/eip-196), [EIP-1108](https://eips.ethereum.org/EIPS/eip-1108)
The BN254 Add precompile performs elliptic curve point addition on the BN254 (alt\_bn128) curve. It takes two G1 points and returns their sum. This is essential for zkSNARK verification and other zero-knowledge proof systems.
EIP-196 introduced BN254 operations in Byzantium. EIP-1108 (Istanbul) reduced gas costs by 91% to enable practical zkSNARK verification.
The BN254 curve is defined over a 254-bit prime field and is widely used in Zcash, Ethereum's zkSNARKs (Groth16), and other privacy protocols.
## Gas Cost
**Fixed:** `150` gas (reduced from 500 in Istanbul via EIP-1108)
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | x1 (first point x-coordinate, big-endian)
32 | 32 | y1 (first point y-coordinate, big-endian)
64 | 32 | x2 (second point x-coordinate, big-endian)
96 | 32 | y2 (second point y-coordinate, big-endian)
```
Total input length: 128 bytes (padded/truncated to this size)
Points must satisfy the curve equation: `y^2 = x^3 + 3` over the BN254 field.
Point at infinity is represented as (0, 0).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | x (result point x-coordinate, big-endian)
32 | 32 | y (result point y-coordinate, big-endian)
```
Total output length: 64 bytes
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Add two G1 points on BN254 curve
// Point 1: Generator (1, 2)
const x1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000001');
const y1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000002');
// Point 2: Generator (1, 2) - will compute 2*G
const x2 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000001');
const y2 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000002');
const input = new Uint8Array(128);
input.set(x1, 0);
input.set(y1, 32);
input.set(x2, 64);
input.set(y2, 96);
const result = execute(
PrecompileAddress.BN254_ADD,
input,
1000n,
Hardfork.CANCUN
);
if (result.success) {
const resultX = result.output.slice(0, 32);
const resultY = result.output.slice(32, 64);
console.log('Result point:', { x: resultX, y: resultY });
console.log('Gas used:', result.gasUsed); // 150
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (gasLimit \< 150)
* Point not on curve (x, y don't satisfy `y^2 = x^3 + 3`)
* Coordinate >= field modulus (`p = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47`)
Invalid points cause the precompile to fail, returning error.
## Use Cases
* **zkSNARK verification:** Groth16 proof verification requires G1 point operations
* **Rollup verification:** zk-Rollups use BN254 for proof aggregation
* **Privacy protocols:** Zcash-style shielded transactions
* **Zero-knowledge applications:** zkEVMs, private DeFi, anonymous voting
* **Cryptographic commitments:** Pedersen commitments on BN254
## Implementation Details
* **Zig:** Pure Zig implementation using arkworks-rs for point arithmetic
* **TypeScript:** Wraps BN254 crypto module (arkworks bindings)
* **Integration:** Part of BN254 crypto suite (add, mul, pairing)
* **Curve:** BN254 (alt\_bn128) with embedding degree 12
* **Field modulus:** `0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47`
## BN254 Curve Parameters
* **Curve equation:** y² = x³ + 3
* **Field modulus (p):** 21888242871839275222246405745257275088696311157297823662689037894645226208583
* **Group order (r):** 21888242871839275222246405745257275088548364400416034343698204186575808495617
* **Generator G1:** (1, 2)
* **Point at infinity:** (0, 0) by convention
## Point Addition Rules
* P + O = P (identity element)
* P + P = 2P (point doubling)
* P + (-P) = O (inverse)
* General addition uses elliptic curve addition formula
## Test Vectors
```typescript theme={null}
// Test 1: Identity + Identity = Identity
const input1 = new Uint8Array(128); // All zeros (point at infinity)
// Expected: (0, 0)
const expected1 = Bytes64(); // All zeros
// Test 2: Generator + Generator = 2*Generator (from geth tests)
const input2 = new Uint8Array(128);
// P1 = (1, 2), P2 = (1, 2)
input2[31] = 1; // x1 = 1
input2[63] = 2; // y1 = 2
input2[95] = 1; // x2 = 1
input2[127] = 2; // y2 = 2
// Expected: 0x030644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd3
// 15ed738c0e0a7c92e7845f96b2ae9c0a68a6a449e3538fc7ff3ebf7a5a18a2c4
// Test 3: Invalid point (not on curve)
const input3 = new Uint8Array(128);
input3[31] = 1; // x1 = 1
input3[63] = 2; // y1 = 2
// x2 = 0, y2 = 0 (second point is identity, valid)
// Expected: Success (returns first point)
// Test 4: Point outside field modulus
const input4 = new Uint8Array(128);
// Set coordinate >= field modulus
// Expected: Error (InvalidPoint)
```
## Gas Cost History
| Hardfork | Gas Cost | Change |
| ------------------- | -------- | ------- |
| Byzantium | 500 | Initial |
| Istanbul (EIP-1108) | 150 | -70% |
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [EIP-196: Precompiled Contracts for Addition and Scalar Multiplication on alt\_bn128](https://eips.ethereum.org/EIPS/eip-196)
* [EIP-1108: Reduce alt\_bn128 Gas Costs](https://eips.ethereum.org/EIPS/eip-1108)
### Related
* [Crypto: BN254](/crypto/bn254)
* [Precompile: BN254 Mul](/evm/precompiles/bn254-mul)
* [Precompile: BN254 Pairing](/evm/precompiles/bn254-pairing)
* [Precompiles Overview](/precompiles)
# 0x07 BN254 Mul
Source: https://voltaire.tevm.sh/evm/precompiles/bn254-mul
BN254 elliptic curve scalar multiplication
**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
**Address:** `0x0000000000000000000000000000000000000007`
**Introduced:** Byzantium (EIP-196)
**EIP:** [EIP-196](https://eips.ethereum.org/EIPS/eip-196), [EIP-1108](https://eips.ethereum.org/EIPS/eip-1108)
The BN254 Mul precompile performs scalar multiplication on the BN254 (alt\_bn128) curve. It multiplies a G1 point by a scalar, computing `scalar * point`. This operation is crucial for zkSNARK verification and cryptographic protocols.
EIP-1108 (Istanbul) reduced gas costs by 99% compared to Byzantium, making zkSNARK verification practical.
## Gas Cost
**Fixed:** `6000` gas (reduced from 40,000 in Istanbul via EIP-1108)
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | x (point x-coordinate, big-endian)
32 | 32 | y (point y-coordinate, big-endian)
64 | 32 | scalar (multiplier, big-endian)
```
Total input length: 96 bytes (padded/truncated to this size)
Point must satisfy curve equation: `y^2 = x^3 + 3` over BN254 field.
Scalar can be any 256-bit value (automatically reduced modulo curve order).
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | x (result point x-coordinate, big-endian)
32 | 32 | y (result point y-coordinate, big-endian)
```
Total output length: 64 bytes
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Multiply BN254 G1 generator point by scalar
// Generator point: (1, 2)
const x = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000001');
const y = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000002');
const scalar = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000005'); // multiply by 5
const input = new Uint8Array(96);
input.set(x, 0);
input.set(y, 32);
input.set(scalar, 64);
const result = execute(
PrecompileAddress.BN254_MUL,
input,
10000n,
Hardfork.CANCUN
);
if (result.success) {
const resultX = result.output.slice(0, 32);
const resultY = result.output.slice(32, 64);
console.log('Result point:', { x: resultX, y: resultY });
console.log('Gas used:', result.gasUsed); // 6000
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (gasLimit \< 6000)
* Point not on curve (x, y don't satisfy `y^2 = x^3 + 3`)
* Coordinate >= field modulus
Invalid points cause failure. Invalid scalars (including zero) are accepted - the operation completes normally.
## Use Cases
* **zkSNARK verification:** Groth16 proofs require scalar multiplications
* **Key derivation:** Generate public keys from private scalars
* **Commitment schemes:** Pedersen commitments use scalar multiplication
* **Signature schemes:** BLS-like signatures on BN254
* **Zero-knowledge protocols:** Privacy-preserving applications
## Implementation Details
* **Zig:** Pure Zig implementation using arkworks-rs bindings
* **TypeScript:** Wraps BN254 crypto module scalar multiplication
* **Integration:** Part of BN254 crypto suite
* **Algorithm:** Double-and-add (windowed for performance)
* **Optimization:** Constant-time execution to prevent timing attacks
## Special Cases
* **Scalar = 0:** Returns point at infinity (0, 0)
* **Scalar = 1:** Returns input point unchanged
* **Scalar = group order:** Returns point at infinity (nP = O)
* **Point at infinity input:** Returns point at infinity regardless of scalar
* **Scalar > group order:** Automatically reduced modulo group order
## Scalar Arithmetic
Scalars are elements of F\_r where r is the curve order:
* **Group order (r):** 21888242871839275222246405745257275088548364400416034343698204186575808495617
* Scalars wrap around: `(r + k) * P = k * P`
* Scalar = 0 or r: result is point at infinity
## Test Vectors
```typescript theme={null}
// Test 1: Any point * 0 = Identity
const input1 = new Uint8Array(96);
input1[31] = 1; // x = 1
input1[63] = 2; // y = 2
// scalar = 0 (already zero-filled)
// Expected: (0, 0)
// Test 2: Generator * 1 = Generator
const input2 = new Uint8Array(96);
input2[31] = 1; // x = 1
input2[63] = 2; // y = 2
input2[95] = 1; // scalar = 1
// Expected: (1, 2)
// Test 3: Generator * 2 = 2*Generator
const input3 = new Uint8Array(96);
input3[31] = 1; // x = 1
input3[63] = 2; // y = 2
input3[95] = 2; // scalar = 2
// Expected: 0x1d739bd53b93e2d05f48f9626e5c6803e8cf53e8afb48a62337e42e555e44fa3
// 0f13d0f0fbf2aa7969e5b86f27ca82e381bb0b495dc2be5e6ed7d28ce5efde77
// Test 4: Invalid point (not on curve)
const input4 = new Uint8Array(96);
input4[31] = 1; // x = 1
input4[63] = 2; // y = 2 (but let's say this was wrong)
input4[95] = 5; // scalar = 5
// If point not on curve: Error (InvalidPoint)
```
## Gas Cost History
| Hardfork | Gas Cost | Change |
| ------------------- | -------- | ------- |
| Byzantium | 40,000 | Initial |
| Istanbul (EIP-1108) | 6,000 | -85% |
The 85% reduction made zkSNARK verification economically viable.
## Performance Considerations
* Scalar multiplication is \~40x more expensive than addition (6000 vs 150 gas)
* Prefer addition when possible (e.g., precompute multiples)
* Batch operations to amortize costs
* Typical Groth16 proof verification uses 2-3 scalar multiplications
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [EIP-196: Precompiled Contracts for Addition and Scalar Multiplication on alt\_bn128](https://eips.ethereum.org/EIPS/eip-196)
* [EIP-1108: Reduce alt\_bn128 Gas Costs](https://eips.ethereum.org/EIPS/eip-1108)
### Related
* [Crypto: BN254](/crypto/bn254)
* [Precompile: BN254 Add](/evm/precompiles/bn254-add)
* [Precompile: BN254 Pairing](/evm/precompiles/bn254-pairing)
* [Precompiles Overview](/evm/precompiles)
# 0x08 BN254 Pairing
Source: https://voltaire.tevm.sh/evm/precompiles/bn254-pairing
BN254 elliptic curve pairing check for zkSNARK verification
**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
**Address:** `0x0000000000000000000000000000000000000008`
**Introduced:** Byzantium (EIP-197)
**EIP:** [EIP-197](https://eips.ethereum.org/EIPS/eip-197), [EIP-1108](https://eips.ethereum.org/EIPS/eip-1108)
The BN254 Pairing precompile performs a pairing check on the BN254 (alt\_bn128) elliptic curve. It verifies whether a product of pairings equals the identity element: `e(A1,B1) * e(A2,B2) * ... * e(Ak,Bk) = 1`. This is the fundamental cryptographic operation for Groth16 zkSNARK verification, enabling zero-knowledge proofs on Ethereum.
A pairing is a special bilinear map that takes two elliptic curve points (one from group G1, one from group G2) and produces a value in a third group GT. The bilinear property means `e(aP, bQ) = e(P, Q)^(ab)`, which is what makes zero-knowledge proofs mathematically possible. Think of it as a one-way function that lets you verify relationships between encrypted values without decrypting them.
EIP-1108 (Istanbul hardfork) reduced gas costs by 56-57%, making zkSNARK verification practical for production applications like Tornado Cash and zk-rollups.
## Gas Cost
**Formula:** `45000 + 34000 * k` where k = number of point pairs
**Examples:**
* Empty input (k=0): 45,000 gas
* 1 pair: 79,000 gas
* 2 pairs: 113,000 gas
* 4 pairs: 181,000 gas
Pre-Istanbul: 100,000 + 80,000\*k (much more expensive)
## Input Format
Input must be a multiple of 192 bytes. Each pair consists of:
```
Offset | Length | Description
-------|--------|-------------
0 | 64 | G1 point (32-byte x, 32-byte y)
64 | 128 | G2 point (four 32-byte values: x1, x2, y1, y2)
```
Each 192-byte chunk represents one (G1, G2) pair.
* k pairs = 192 \* k bytes
* Empty input (0 bytes) is valid and returns success (empty product = 1)
**G2 point encoding:** G2 points have coordinates in Fp2 = Fp\[i]/(i²+1):
* x = x1 + x2\*i (offset 64: x1, offset 96: x2)
* y = y1 + y2\*i (offset 128: y1, offset 160: y2)
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | 1 if pairing check passes, 0 otherwise
```
Total output length: 32 bytes (single word)
* Success: 0x0000...0001 (last byte = 1)
* Failure: 0x0000...0000 (all zeros)
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Verify Groth16 zkSNARK proof
// Need to check: e(A, B) * e(alpha, beta) * e(C, delta) * e(input, gamma) = 1
// Rearranged: e(-A, B) * e(alpha, beta) * e(-C, delta) * e(input, gamma) = 1
const numPairs = 4;
const input = new Uint8Array(192 * numPairs);
// Each pair: 64-byte G1 point + 128-byte G2 point
// Points would come from actual zkSNARK proof - using placeholders for structure
// In production, these would be computed values from the proof and verification key
const gasNeeded = 45000n + 34000n * BigInt(numPairs);
const result = execute(
PrecompileAddress.BN254_PAIRING,
input,
gasNeeded,
Hardfork.CANCUN
);
if (result.success && result.output[31] === 1) {
console.log('Proof verified!');
} else {
console.log('Proof invalid');
}
console.log('Gas used:', result.gasUsed);
```
## Error Conditions
* Out of gas
* Input length not multiple of 192
* G1 point not on curve
* G2 point not on curve
* Coordinate >= field modulus
* Invalid G2 point encoding
Failures return error (not false). Only valid inputs that fail the pairing check return false (32 zero bytes).
## Use Cases
**Production Applications:**
* **Tornado Cash:** Privacy-preserving Ethereum transactions using Groth16 proofs. Each withdrawal verifies a pairing check proving knowledge of a deposit without revealing which one (181,000 gas).
* **zk-Rollups:** Layer 2 scaling solutions verify validity proofs on L1:
* **zkSync Era:** Uses PLONK (different proof system, but same curve)
* **Polygon zkEVM:** Groth16 verification for batches of thousands of transactions
* **Scroll:** zkEVM using different proof systems but BN254 pairing primitives
* **Semaphore:** Anonymous signaling and voting. Proves "I'm in this group" without revealing identity. Used by privacy protocols and DAO voting systems.
* **Aztec Protocol:** Privacy-preserving smart contracts on Ethereum. Each private transaction includes zkSNARK proof verified via pairing.
**Why Pairing Instead of Pure Software?**
Computing a BN254 pairing in EVM bytecode would cost millions of gas. The precompile uses optimized native code (via arkworks-rs) and reduces cost by 99%+. Without this precompile, zkSNARKs on Ethereum would be economically infeasible.
**BLS Signatures (Historical):** Early BLS signature schemes used BN254, but modern implementations prefer BLS12-381 (see precompiles 0x0a-0x0d) for better security margins.
## Implementation Details
* **Zig:** Uses arkworks-rs via Rust FFI for optimal pairing performance
* **TypeScript:** Wraps BN254 crypto module pairing implementation
* **Integration:** Most complex of BN254 operations, uses Miller loop + final exponentiation
* **Algorithm:** Optimal Ate pairing on BN254
* **Optimization:** Multi-pairing optimization (Miller loop shared across pairs)
## Mathematical Background
**What is a Pairing?**
A pairing is a bilinear map: `e: G1 × G2 → GT`
Key properties:
* **Bilinearity:** `e(aP, bQ) = e(P, Q)^(ab) = e(bP, aQ)` for all scalars a, b
* **Non-degeneracy:** `e(G1_generator, G2_generator) ≠ 1`
* **Computability:** Efficiently computable (using Miller loop + final exponentiation)
**Why This Enables zkSNARKs:**
The bilinear property lets verifiers check polynomial equations without knowing the polynomial coefficients:
* Prover commits to polynomial: `C = p(τ) * G1` (where τ is trusted setup secret)
* Verifier checks relationships: `e(C, G2) = e(proof, verifier_key)`
* If equation holds, proof is valid - but verifier never learns τ or polynomial coefficients
This is why a trusted setup is needed: someone generates τ and computes powers of τ, then deletes τ. As long as one person in the ceremony is honest, the system is secure.
**BN254 Curve Details:**
* **Prime field:** 254-bit prime `p = 21888242871839275222246405745257275088696311157297823662689037894645226208583`
* **Embedding degree:** 12 (pairing uses degree-12 extension field)
* **Security:** \~100-bit security level (approximately equivalent to 2048-bit RSA)
* **Groups:** G1 over Fp, G2 over Fp2, GT in Fp12
## Groth16 zkSNARK Verification
Groth16 is the most widely used zkSNARK system. A typical proof consists of three G1 points (A, B, C), and verification checks:
```
e(A, B) * e(alpha, beta) * e(C, delta) * e(public_inputs, gamma) = 1
```
Rearranging for implementation (using negation to avoid inversions):
```
e(-A, B) * e(alpha, beta) * e(-C, delta) * e(public_inputs, gamma) = 1
```
**Verification key elements:**
* `alpha, beta, delta, gamma`: Points from trusted setup
* `public_inputs`: Derived from circuit public inputs and verification key
**Gas cost for Groth16:** `45000 + 34000*4 = 181,000 gas`
**Real-world example:** Tornado Cash uses Groth16 to prove "I know a secret that was deposited" without revealing which deposit. The circuit has \~2,000 constraints, proving knowledge of a Merkle path in the deposit tree.
## Gas Cost Comparison
| Operation | Pre-Istanbul | Istanbul | Improvement |
| ----------------- | ------------ | -------- | ------------- |
| 1 pair | 180,000 | 79,000 | 56% reduction |
| 2 pairs | 260,000 | 113,000 | 57% reduction |
| 4 pairs (Groth16) | 420,000 | 181,000 | 57% reduction |
## Test Vectors
From official Ethereum test suite:
```typescript theme={null}
// Vector 1: Empty input (identity check)
// Empty product of pairings should equal 1 (success)
const input1 = new Uint8Array(0);
const result1 = execute(PrecompileAddress.BN254_PAIRING, input1, 50000n, Hardfork.CANCUN);
// result1.output[31] === 1
// result1.gasUsed === 45000
// Vector 2: Valid pairing with generators
// e(G1, G2) where G1 and G2 are curve generators
const input2 = new Uint8Array(192);
// G1 generator (x, y):
input2.set(hexToBytes('0000000000000000000000000000000000000000000000000000000000000001'), 0);
input2.set(hexToBytes('0000000000000000000000000000000000000000000000000000000000000002'), 32);
// G2 generator (x1, x2, y1, y2):
input2.set(hexToBytes('1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed'), 64);
input2.set(hexToBytes('198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2'), 96);
input2.set(hexToBytes('12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa'), 128);
input2.set(hexToBytes('090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b'), 160);
const result2 = execute(PrecompileAddress.BN254_PAIRING, input2, 100000n, Hardfork.CANCUN);
// result2.output[31] === 1
// result2.gasUsed === 79000
// Vector 3: Invalid pairing (should return 0)
// e(G1, G2) * e(G1, G2) = e(G1, G2)^2 ≠ 1
const input3 = new Uint8Array(384);
input3.set(input2, 0); // First pair
input3.set(input2, 192); // Second pair (duplicate)
const result3 = execute(PrecompileAddress.BN254_PAIRING, input3, 150000n, Hardfork.CANCUN);
// result3.output[31] === 0 (pairing check fails)
// result3.gasUsed === 113000
// Vector 4: Groth16-style verification (4 pairs)
// This simulates a real zkSNARK proof verification
const input4 = new Uint8Array(768);
// ... (fill with actual proof verification pairs)
const result4 = execute(PrecompileAddress.BN254_PAIRING, input4, 200000n, Hardfork.CANCUN);
// result4.gasUsed === 181000
```
## Related
* [Crypto: BN254](/crypto/bn254)
* [Precompile: BN254 Add](/evm/precompiles/bn254-add)
* [Precompile: BN254 Mul](/evm/precompiles/bn254-mul)
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E
* [EIP-197: Precompiled Contracts for Optimal Ate Pairing Check on alt\_bn128](https://eips.ethereum.org/EIPS/eip-197)
* [EIP-1108: Reduce alt\_bn128 Gas Costs](https://eips.ethereum.org/EIPS/eip-1108)
* [Groth16 Paper](https://eprint.iacr.org/2016/260.pdf)
# 0x01 ecRecover
Source: https://voltaire.tevm.sh/evm/precompiles/ecrecover
Elliptic curve signature recovery for Ethereum transactions
**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
**Address:** `0x0000000000000000000000000000000000000001`
**Introduced:** Frontier
**EIP:** [EIP-2](https://eips.ethereum.org/EIPS/eip-2) (Signature Malleability Protection)
The ecRecover precompile recovers the Ethereum address from an ECDSA signature using the secp256k1 elliptic curve. Given a message hash and signature components (v, r, s), it returns the 20-byte Ethereum address of the signer. This is fundamental for transaction validation and signature verification in Ethereum.
EIP-2 enhanced this precompile by enforcing signature malleability protection, requiring that the `s` value be in the lower half of the curve order. This prevents transaction replay attacks where the same signature could be used with different `s` values.
## Gas Cost
**Fixed:** `3000` gas
The cost is constant regardless of input validity. Even invalid signatures consume the full gas amount.
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | Message hash (keccak256 of signed data)
32 | 32 | v (recovery id, padded - last byte is 27, 28, 0, or 1)
64 | 32 | r (signature component)
96 | 32 | s (signature component, must be ≤ secp256k1_n/2)
```
Total input length: 128 bytes (padded/truncated to this size)
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 12 | Zero padding
12 | 20 | Recovered Ethereum address
```
Total output length: 32 bytes
Returns 32 zero bytes if signature is invalid.
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import * as Hex from '@tevm/voltaire/Hex';
// Prepare input (hash || v || r || s)
// Message hash (keccak256 of signed data)
const hash = Hex('0x47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad');
// v = 27 (padded to 32 bytes)
const v = Hex('0x000000000000000000000000000000000000000000000000000000000000001b');
// Signature r component
const r = Hex('0x9242685bf161793cc25603c231bc2f568eb630ea16aa137d2664ac8038825608');
// Signature s component
const s = Hex('0x4f8ae3bd7535248d0bd448298cc2e2071e56992d0774dc340c368ae950852ada');
const input = new Uint8Array(128);
input.set(hash, 0);
input.set(v, 32);
input.set(r, 64);
input.set(s, 96);
// Execute precompile
const result = execute(
PrecompileAddress.ECRECOVER,
input,
10000n,
Hardfork.CANCUN
);
if (result.success) {
// Address is in last 20 bytes
const address = result.output.slice(12, 32);
console.log('Recovered address:', address);
console.log('Gas used:', result.gasUsed); // 3000
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (gasLimit \< 3000)
* Invalid v value (not 0, 1, 27, or 28) → returns zero address
* r = 0 or r ≥ secp256k1\_n → returns zero address
* s = 0 or s > secp256k1\_n/2 → returns zero address (EIP-2)
* Point not on curve → returns zero address
* Invalid signature → returns zero address
Note: Invalid signatures do NOT revert. They return a zero address and consume gas.
## Use Cases
* **Transaction validation:** Ethereum nodes use this to recover sender addresses from transaction signatures
* **Signature verification:** Smart contracts verify off-chain signed messages (EIP-191, EIP-712)
* **Meta-transactions:** Contracts validate user signatures for gasless transactions
* **Multisig wallets:** Verify multiple signers approved a transaction
* **Account abstraction:** Validate custom signature schemes
## Implementation Details
* **Zig:** Uses secp256k1 public key recovery from crypto module, applies keccak256 to derive address
* **TypeScript:** Wraps Secp256k1.recoverPublicKey and Keccak256.hash
* **Integration:** Depends on Secp256k1 and Keccak256 crypto modules
* **Security:** Enforces EIP-2 malleability protection - rejects s > secp256k1\_n/2
* **Validation:** Checks r and s are in valid range \[1, secp256k1\_n)
## Signature Malleability (EIP-2)
Before EIP-2, signatures had malleability: for every valid signature (r, s, v), there exists another valid signature (r, -s mod n, v'). This allowed attackers to modify transaction signatures without invalidating them.
EIP-2 solved this by requiring `s ≤ secp256k1_n/2`, where secp256k1\_n = `0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141`. Any signature with s in the upper half is rejected.
## Test Vectors
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
// Valid signature recovery
const hash = Hex('0x4747474747474747474747474747474747474747474747474747474747474747');
const v = Hex('0x000000000000000000000000000000000000000000000000000000000000001c');
const r = Hex('0x6969696969696969696969696969696969696969696969696969696969696969');
const s = Hex('0x7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a');
// Should recover valid address
// Invalid: s too high (EIP-2 violation)
const s_high = Hex('0x8000000000000000000000000000000000000000000000000000000000000000');
// Should return zero address
// Invalid: v out of range
const v_invalid = Hex('0x000000000000000000000000000000000000000000000000000000000000001d');
// Should return zero address
```
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [EIP-2: Homestead Hard-fork Changes](https://eips.ethereum.org/EIPS/eip-2)
* [secp256k1 Curve Parameters](https://www.secg.org/sec2-v2.pdf)
### Related
* [Crypto: Secp256k1](/crypto/secp256k1)
* [Crypto: Keccak256](/crypto/keccak256)
* [Primitives: Signature](/primitives/signature)
* [Precompiles Overview](/precompiles)
# 0x04 Identity
Source: https://voltaire.tevm.sh/evm/precompiles/identity
Identity function that returns input data unchanged
**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
**Address:** `0x0000000000000000000000000000000000000004`
**Introduced:** Frontier
The Identity precompile is the simplest precompile - it returns the input data unchanged. While this may seem trivial, it serves important purposes for data copying, memory operations, and gas accounting in the EVM.
## Gas Cost
**Formula:** `15 + 3 * ceil(input_length / 32)`
* Base cost: `15` gas
* Per-word cost: `3` gas per 32-byte word
* Partial words round up
**Examples:**
* 0 bytes: 15 gas
* 32 bytes: 18 gas (15 + 3\*1)
* 33 bytes: 21 gas (15 + 3\*2)
* 64 bytes: 21 gas (15 + 3\*2)
## Input Format
Accepts arbitrary-length byte array. No restrictions on input size or content.
## Output Format
Identical to input - returns input bytes unchanged.
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import * as Hex from '@tevm/voltaire/Hex';
// Copy some data
const input = Hex('0x0102030405');
// Calculate required gas
const words = Math.ceil(input.length / 32);
const gasNeeded = 15n + 3n * BigInt(words);
// Execute precompile
const result = execute(
PrecompileAddress.IDENTITY,
input,
gasNeeded,
Hardfork.CANCUN
);
if (result.success) {
// Output === input
console.log('Output:', result.output);
console.log('Gas used:', result.gasUsed);
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (insufficient for 15 + 3 \* ceil(len/32))
## Use Cases
* **Data copying:** Efficient way to copy data between memory locations
* **Gas metering:** Test gas consumption for data operations
* **Calldata to memory:** Copy calldata to memory efficiently
* **Proxy contracts:** Forward data without modification
* **Testing:** Validate precompile execution mechanics
## Implementation Details
* **Zig:** Simple allocate + copy operation using allocator.dupe
* **TypeScript:** Creates new Uint8Array copy of input
* **Integration:** Standalone, no dependencies
* **Optimization:** Most efficient data copy operation in EVM
## Performance Characteristics
The Identity precompile is the cheapest way to copy data in the EVM:
* Base cost: 15 gas
* Per-byte cost: \~0.09375 gas/byte
* More efficient than CODECOPY (3 gas/word + memory expansion)
* Cheaper than manual byte-by-byte copying
## Why Does Identity Exist?
While it seems trivial, Identity serves several purposes:
1. **Efficient memory operations:** Copying data via precompile avoids expensive EVM opcodes
2. **Gas accounting:** Provides predictable gas cost for data operations
3. **Testing:** Validates precompile calling mechanism
4. **Historical:** Part of original Ethereum design, maintained for compatibility
## Comparison with Other Copy Operations
| Operation | Base Gas | Per-Word Gas | Use Case |
| ---------------- | -------- | ------------ | ------------------ |
| IDENTITY | 15 | 3 | General data copy |
| CALLDATACOPY | 3 | 3 | Calldata to memory |
| CODECOPY | 3 | 3 | Code to memory |
| MCOPY (EIP-5656) | 3 | 3 | Memory to memory |
Identity has higher base cost but same per-word cost. Use MCOPY (if available) for memory-to-memory copies.
## Test Vectors
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
// Test 1: Empty input
const input1 = new Uint8Array(0);
const result1 = executeIdentity(input1);
// Expected: empty array (0 bytes)
// Gas: 15 + 3 * 0 = 15
// Test 2: 5 bytes
const input2 = Hex('0x0102030405');
const result2 = executeIdentity(input2);
// Expected: [1, 2, 3, 4, 5]
// Gas: 15 + 3 * ceil(5/32) = 15 + 3*1 = 18
// Test 3: Exact 32-byte boundary
const input3 = Hex('0x' + 'ff'.repeat(32));
const result3 = executeIdentity(input3);
// Expected: 32 bytes of 0xFF
// Gas: 15 + 3 * 1 = 18
// Test 4: Partial word (33 bytes)
const input4 = Hex('0x' + '00'.repeat(33));
const result4 = executeIdentity(input4);
// Expected: 33 bytes (unchanged)
// Gas: 15 + 3 * ceil(33/32) = 15 + 3*2 = 21
```
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [EIP-5656: MCOPY Opcode](https://eips.ethereum.org/EIPS/eip-5656)
### Related
* [Precompiles Overview](/precompiles)
# EVM Precompiles
Source: https://voltaire.tevm.sh/evm/precompiles/index
Complete reference for all Ethereum precompiled contracts with implementations in TypeScript and Zig
**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
Precompiled contracts are special Ethereum addresses (0x01-0x13+) that execute optimized native code instead of EVM bytecode. They provide gas-efficient implementations of computationally expensive operations like cryptographic primitives, hashing, and elliptic curve operations.
Voltaire provides low-level tree-shakable implementations of all standard precompiles in both TypeScript and Zig, with WASM compilation support for portable high-performance execution. For complete spec-compliant EVM implementations that use these precompiles, see [evmts/guillotine](https://github.com/evmts/guillotine) and [evmts/tevm-monorepo](https://github.com/evmts/voltaire-monorepo).
## Complete Precompile Reference
| Address | Name | Gas Cost | Hardfork | Category | Description |
| ------- | --------------------------------------------------------------- | ----------------- | --------- | -------- | ---------------------------------------- |
| 0x01 | [ECRECOVER](/evm/precompiles/ecrecover) | 3,000 | Frontier | Crypto | Recover ECDSA signer address |
| 0x02 | [SHA256](/evm/precompiles/sha256) | 60 + 12/word | Frontier | Hash | SHA-256 hash function |
| 0x03 | [RIPEMD160](/evm/precompiles/ripemd160) | 600 + 120/word | Frontier | Hash | RIPEMD-160 hash function |
| 0x04 | [IDENTITY](/evm/precompiles/identity) | 15 + 3/word | Frontier | Data | Copy input to output |
| 0x05 | [MODEXP](/evm/precompiles/modexp) | Dynamic | Byzantium | Math | Modular exponentiation |
| 0x06 | [BN254\_ADD](/evm/precompiles/bn254-add) | 150 | Byzantium | zkSNARKs | BN254 G1 point addition |
| 0x07 | [BN254\_MUL](/evm/precompiles/bn254-mul) | 6,000 | Byzantium | zkSNARKs | BN254 G1 scalar multiplication |
| 0x08 | [BN254\_PAIRING](/evm/precompiles/bn254-pairing) | 45,000 + 34,000k | Byzantium | zkSNARKs | BN254 pairing check |
| 0x09 | [BLAKE2F](/evm/precompiles/blake2f) | Dynamic | Istanbul | Hash | BLAKE2b compression function |
| 0x0A | [POINT\_EVALUATION](/evm/precompiles/point-evaluation) | 50,000 | Cancun | Blobs | KZG point evaluation (EIP-4844) |
| 0x0B | [BLS12\_G1\_ADD](/evm/precompiles/bls12-g1-add) | 500 | Prague | ETH2 | BLS12-381 G1 point addition |
| 0x0C | [BLS12\_G1\_MUL](/evm/precompiles/bls12-g1-mul) | 12,000 | Prague | ETH2 | BLS12-381 G1 scalar multiplication |
| 0x0D | [BLS12\_G1\_MSM](/evm/precompiles/bls12-g1-msm) | Variable | Prague | ETH2 | BLS12-381 G1 multi-scalar multiplication |
| 0x0E | [BLS12\_G2\_ADD](/evm/precompiles/bls12-g2-add) | 800 | Prague | ETH2 | BLS12-381 G2 point addition |
| 0x0F | [BLS12\_G2\_MUL](/evm/precompiles/bls12-g2-mul) | 45,000 | Prague | ETH2 | BLS12-381 G2 scalar multiplication |
| 0x10 | [BLS12\_G2\_MSM](/evm/precompiles/bls12-g2-msm) | Variable | Prague | ETH2 | BLS12-381 G2 multi-scalar multiplication |
| 0x11 | [BLS12\_PAIRING](/evm/precompiles/bls12-pairing) | 115,000 + 23,000k | Prague | ETH2 | BLS12-381 pairing check |
| 0x12 | [BLS12\_MAP\_FP\_TO\_G1](/evm/precompiles/bls12-map-fp-to-g1) | 5,500 | Prague | ETH2 | Map field element to G1 (hash-to-curve) |
| 0x13 | [BLS12\_MAP\_FP2\_TO\_G2](/evm/precompiles/bls12-map-fp2-to-g2) | 75,000 | Prague | ETH2 | Map Fp2 element to G2 (hash-to-curve) |
## Precompile Categories
### Cryptography (0x01)
**ECRECOVER** recovers the Ethereum address from an ECDSA signature. Essential for transaction validation and signature verification.
* Gas: 3,000 (fixed)
* Input: 128 bytes (hash, v, r, s)
* Output: 20-byte address
* Use: Transaction signing, off-chain authentication
### Hashing (0x02, 0x03, 0x09)
**SHA256, RIPEMD160, BLAKE2F** provide standard cryptographic hash functions.
* SHA256: Bitcoin compatibility, Merkle trees
* RIPEMD160: Bitcoin address generation
* BLAKE2F: High-performance modern hash (Zcash)
### Data Operations (0x04)
**IDENTITY** is a simple memcpy operation, mainly used for:
* Gas benchmarking
* Data copying in complex contracts
* ABI encoding/decoding optimization
### Mathematics (0x05)
**MODEXP** performs modular exponentiation: `(base^exp) mod modulus`
* RSA signature verification
* Zero-knowledge proof systems
* Cryptographic protocols
* Dynamic gas based on input sizes
### zkSNARKs - BN254 Curve (0x06-0x08)
**BN254** precompiles enable efficient zero-knowledge proofs:
* **ADD (150 gas):** Point addition for proof verification
* **MUL (6,000 gas):** Scalar multiplication
* **PAIRING (45k + 34k/pair):** Bilinear pairing checks
Used by: Zcash, Tornado Cash, zkSync, StarkNet, Polygon zkEVM
**Security:** \~100-bit (sufficient but aging)
### Ethereum 2.0 - BLS12-381 Curve (0x0B-0x13)
**BLS12-381** precompiles power Ethereum 2.0 consensus:
#### G1 Operations (128-byte points)
* **G1\_ADD (500 gas):** Fast point addition
* **G1\_MUL (12,000 gas):** Scalar multiplication
* **G1\_MSM (variable):** Batch operations with discounts
#### G2 Operations (256-byte points)
* **G2\_ADD (800 gas):** Extension field addition
* **G2\_MUL (45,000 gas):** More expensive than G1
* **G2\_MSM (variable):** Batch operations
#### Pairing & Hash-to-Curve
* **PAIRING (115k + 23k/pair):** Signature verification
* **MAP\_FP\_TO\_G1 (5,500 gas):** Hash messages to G1
* **MAP\_FP2\_TO\_G2 (75,000 gas):** Hash messages to G2
**Security:** 128-bit (future-proof)
**Applications:**
* Validator signature aggregation
* BLS multi-signatures
* Threshold cryptography
* Advanced zkSNARKs
### Blob Data (0x0A)
**POINT\_EVALUATION** verifies KZG commitments for EIP-4844 blob transactions:
* Gas: 50,000 (fixed)
* Enables proto-danksharding
* Reduces rollup costs by 10-100x
* Critical for Ethereum scalability
## Gas Cost Patterns
### Fixed Cost
Simple operations with predictable computation:
* ECRECOVER: 3,000
* BLS12\_G1\_ADD: 500
* POINT\_EVALUATION: 50,000
### Linear Cost
Scales with input size:
* SHA256: 60 + 12 per word
* IDENTITY: 15 + 3 per word
### Dynamic Cost
Complex calculation based on inputs:
* MODEXP: Based on base/exp/mod sizes
* BLS12\_MSM: Batch discounts
### Multi-Element Cost
Per-item pricing:
* BN254\_PAIRING: 45,000 + 34,000 per pair
* BLS12\_PAIRING: 115,000 + 23,000 per pair
## Performance Comparison
### Elliptic Curve Operations
| Operation | BN254 | BLS12-381 | Security | Use Case |
| ---------- | ------------ | ------------------------- | ----------------- | ------------------- |
| Point Add | 150 | 500 (G1) / 800 (G2) | 100-bit / 128-bit | zkSNARKs / ETH2 |
| Scalar Mul | 6,000 | 12,000 (G1) / 45,000 (G2) | 100-bit / 128-bit | Proofs / Signatures |
| Pairing | 45k+34k/pair | 115k+23k/pair | 100-bit / 128-bit | Verification |
### Hashing Performance
| Function | Gas/KB | Speed | Use Case |
| --------- | -------- | ------- | -------------- |
| SHA256 | \~380 | Fast | Bitcoin compat |
| RIPEMD160 | \~3,750 | Slower | Legacy |
| BLAKE2F | Variable | Fastest | Modern |
| Keccak256 | \~1,000 | Fast | Native EVM |
## Usage Statistics
Most frequently used precompiles by gas consumption:
1. **ECRECOVER (0x01)** - Every transaction signature
2. **BLS12\_PAIRING (0x11)** - ETH2 consensus (thousands per block)
3. **POINT\_EVALUATION (0x0A)** - Blob transactions
4. **BN254\_PAIRING (0x08)** - zkRollup proofs
5. **SHA256 (0x02)** - Bridge verifications
Least used:
* **RIPEMD160 (0x03)** - Legacy Bitcoin compatibility
* **IDENTITY (0x04)** - Specialized optimization
## Implementation Guide
### TypeScript
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Execute any precompile
const result = execute(
PrecompileAddress.ECRECOVER,
input, // Uint8Array
gasLimit, // bigint
Hardfork.CANCUN
);
if (result.success) {
console.log('Output:', result.output);
console.log('Gas used:', result.gasUsed);
} else {
console.error('Error:', result.error);
}
```
### Zig
```zig theme={null}
const std = @import("std");
const precompiles = @import("precompiles");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// Execute precompile
const result = try precompiles.ecrecover.execute(
allocator,
input, // []const u8
gas_limit, // u64
);
defer result.deinit(allocator);
if (result.success) {
std.debug.print("Output: {any}\n", .{result.output});
}
}
```
### WASM
All precompiles available via WASM. Import and use like the TypeScript implementation.
## Security Considerations
### Input Validation
All precompiles validate:
* Input length (exact or range)
* Field element bounds (curve operations)
* Point validity (on curve, in subgroup)
* Gas sufficiency (before computation)
Invalid inputs return error, not false results.
### Constant-Time Execution
Cryptographic precompiles use constant-time algorithms:
* ECRECOVER: Prevents timing attacks on signatures
* BN254/BLS12-381: Side-channel resistant scalar multiplication
* MODEXP: Protects secret exponents
### Gas DoS Protection
Dynamic gas prevents abuse:
* MODEXP: Exponential cost for large inputs
* MSM operations: Bounded by block gas limit
* Pairing: Linear cost per pair
### Curve Security
| Curve | Security | Status | Notes |
| --------- | --------- | ------------ | ------------------------------- |
| secp256k1 | 128-bit | Mature | Bitcoin/Ethereum standard |
| BN254 | \~100-bit | Aging | Sufficient for current zkSNARKs |
| BLS12-381 | 128-bit | Future-proof | ETH2, modern protocols |
## Hardfork Availability
```typescript theme={null}
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Check precompile availability
const precompiles = {
[Hardfork.FRONTIER]: [0x01, 0x02, 0x03, 0x04],
[Hardfork.BYZANTIUM]: [0x05, 0x06, 0x07, 0x08],
[Hardfork.ISTANBUL]: [0x09],
[Hardfork.CANCUN]: [0x0A],
[Hardfork.PRAGUE]: [0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13],
};
```
Always check hardfork before calling newer precompiles.
## Implementation Status
### Zig: Complete
All precompiles fully implemented with native C library integration:
* secp256k1: libsecp256k1
* BN254: arkworks (Rust FFI)
* BLS12-381: blst
* KZG: c-kzg-4844
* Hashes: libwally-core
### TypeScript: Functional
* **Production-ready:** ECRECOVER, SHA256, RIPEMD160, IDENTITY, BLAKE2F
* **Stubs (use WASM):** BLS12-381 operations (return correct size, calculate gas, no crypto)
* **Working:** BN254 via @noble/curves, MODEXP, POINT\_EVALUATION via c-kzg
For security-critical operations, always use Zig/WASM implementations.
## Related Documentation
### Curve Documentation
* [BLS12-381 Overview](/crypto/bls12-381) - Complete guide to 9 BLS precompiles
* [BN254 Operations](/crypto/bn254) - zkSNARK curve primitives
* [Secp256k1](/crypto/secp256k1) - ECDSA and ECRECOVER
### Cryptography
* [Keccak256](/crypto/keccak256) - Native EVM hash (not a precompile)
* [KZG Commitments](/crypto/kzg) - Blob verification
* [Signature Schemes](/crypto) - ECDSA, BLS, Schnorr
### Primitives
* [Transaction](/primitives/transaction) - Uses ECRECOVER
* [Address](/primitives/address) - Derived from signatures
* [Gas Constants](/primitives/gas-constants) - Precompile gas costs
## References
* **EIPs:**
* [EIP-196/197](https://eips.ethereum.org/EIPS/eip-196): BN254 (Byzantium)
* [EIP-198](https://eips.ethereum.org/EIPS/eip-198): MODEXP (Byzantium)
* [EIP-152](https://eips.ethereum.org/EIPS/eip-152): BLAKE2F (Istanbul)
* [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844): POINT\_EVALUATION (Cancun)
* [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537): BLS12-381 (Prague)
* **Standards:**
* [SEC2](https://www.secg.org/sec2-v2.pdf): secp256k1 specification
* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf): SHA-256
* [RFC 1321](https://www.rfc-editor.org/rfc/rfc1321): RIPEMD-160
* [RFC 7693](https://www.rfc-editor.org/rfc/rfc7693): BLAKE2
* [BLS Signatures](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature): BLS12-381
* **Libraries:**
* [blst](https://github.com/supranational/blst): BLS12-381 (audited)
* [c-kzg-4844](https://github.com/ethereum/c-kzg-4844): KZG commitments
* [@noble/curves](https://github.com/paulmillr/noble-curves): Pure JS curves
* [arkworks](https://github.com/arkworks-rs): BN254 Rust implementation
## Contributing
Precompile implementations require:
* Exact adherence to EIP specifications
* Comprehensive test vectors
* Gas cost validation
* Security audits for crypto operations
* Cross-language parity (TypeScript ↔ Zig)
See [CONTRIBUTING.md](https://github.com/evmts/voltaire/blob/main/CONTRIBUTING.md)
# 0x05 ModExp
Source: https://voltaire.tevm.sh/evm/precompiles/modexp
Modular exponentiation for RSA and other cryptographic operations
**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
**Address:** `0x0000000000000000000000000000000000000005`
**Introduced:** Byzantium (EIP-198)
**EIP:** [EIP-198](https://eips.ethereum.org/EIPS/eip-198), [EIP-2565](https://eips.ethereum.org/EIPS/eip-2565)
The ModExp precompile computes modular exponentiation: `(base^exponent) mod modulus`. This enables efficient RSA signature verification, Fermat primality testing, and other advanced cryptographic operations in smart contracts.
EIP-198 introduced ModExp in Byzantium. EIP-2565 (Berlin) reduced gas costs to make RSA verification practical.
## Gas Cost
**Complex formula that varies by hardfork:**
Pre-Berlin: `max(200, complexity * iteration_count / GQUADDIVISOR)`
Berlin+: `max(200, complexity * iteration_count / GQUADDIVISOR_v2)`
Where:
* `complexity = mult_complexity * max(length(base), length(modulus))`
* `mult_complexity = (max(length(base), length(modulus)) / 8)^2` if max > 64, else `mult_complexity = max(length(base), length(modulus))^2 / 4`
* `iteration_count = max(exponent_bitlength - 1, 1)` adjusted for exponent head
* Minimum gas: `200`
The exact calculation is in `src/crypto/ModExp/calculateGas`
**Examples:**
* Small inputs (1-byte each): \~200 gas
* 256-byte RSA (2048-bit): \~50,000+ gas
* 512-byte RSA (4096-bit): \~200,000+ gas
## Input Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | base_length (big-endian u256)
32 | 32 | exponent_length (big-endian u256)
64 | 32 | modulus_length (big-endian u256)
96 | base_length | base value (big-endian)
96+base_length | exponent_length | exponent value (big-endian)
96+base_length+exponent_length | modulus_length | modulus value (big-endian)
```
Minimum input length: 96 bytes (length headers only)
## Output Format
Output length equals `modulus_length` specified in input.
```
Offset | Length | Description
-------|--------|-------------
0 | modulus_length | (base^exponent mod modulus) as big-endian
```
Returns empty output if `modulus_length = 0`.
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
import * as Hex from '@tevm/voltaire/Hex';
// Compute 2^3 mod 5 = 8 mod 5 = 3
const input = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000001' + // base_length = 1
'0000000000000000000000000000000000000000000000000000000000000001' + // exponent_length = 1
'0000000000000000000000000000000000000000000000000000000000000001' + // modulus_length = 1
'02' + // base = 2
'03' + // exponent = 3
'05' // modulus = 5
);
const result = execute(
PrecompileAddress.MODEXP,
input,
100000n,
Hardfork.CANCUN
);
if (result.success) {
console.log('Result:', result.output[0]); // 3
console.log('Gas used:', result.gasUsed);
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Input length \< 96 bytes
* Out of gas (gas cost depends on input sizes)
* Modulus = 0 (returns error)
* Integer overflow in length values
## Use Cases
* **RSA signature verification:** Verify RSA-2048, RSA-4096 signatures on-chain
* **Zero-knowledge proofs:** Perform modular arithmetic for zkSNARKs
* **Cryptographic protocols:** Diffie-Hellman key exchange, ElGamal encryption
* **Primality testing:** Fermat and Miller-Rabin primality tests
* **Number theory:** Modular inverses, Chinese remainder theorem
## Implementation Details
* **Zig:** Uses multi-precision arithmetic from ModExp crypto module
* **TypeScript:** BigInt-based modular exponentiation with square-and-multiply
* **Integration:** Depends on ModExp.calculateGas for hardfork-specific gas calculation
* **Optimization:** Binary exponentiation (square-and-multiply algorithm)
## RSA Verification Example
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
// RSA-2048 verification (256-byte values)
const baseLen = 256;
const expLen = 3; // Common public exponent: 65537
const modLen = 256;
// Example RSA-2048 input (signature verification)
const base = Hex('0x' + 'ab'.repeat(256)); // Signature (256 bytes)
const exponent = Hex('0x010001'); // Public exponent 65537 (3 bytes)
const modulus = Hex('0x' + 'cd'.repeat(256)); // RSA modulus (256 bytes)
const input = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000100' + // base_length = 256
'0000000000000000000000000000000000000000000000000000000000000003' + // exponent_length = 3
'0000000000000000000000000000000000000000000000000000000000000100' + // modulus_length = 256
Hex.toHex(base).slice(2) +
Hex.toHex(exponent).slice(2) +
Hex.toHex(modulus).slice(2)
);
const result = execute(
PrecompileAddress.MODEXP,
input,
1000000n, // RSA needs significant gas
Hardfork.CANCUN
);
// result.output should equal expected message hash
```
## Gas Cost Reduction (EIP-2565)
Berlin hard fork (EIP-2565) reduced gas costs significantly:
| Input Size | Pre-Berlin | Berlin | Reduction |
| ------------ | ----------- | --------- | --------- |
| 2048-bit RSA | \~300,000 | \~50,000 | 83% |
| 4096-bit RSA | \~1,200,000 | \~200,000 | 83% |
This made RSA verification practical for many use cases.
## Edge Cases
* **Zero exponent:** Returns 1 (any number to power 0 is 1)
* **Modulus = 1:** Returns 0 (anything mod 1 is 0)
* **Base > modulus:** Automatically reduced mod modulus
* **Truncated input:** Missing bytes treated as zero
* **Zero modulus:** Returns error (division by zero)
## Test Vectors
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
// Test 1: 2^3 mod 5 = 3
const input1 = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000001' + // base_len = 1
'0000000000000000000000000000000000000000000000000000000000000001' + // exp_len = 1
'0000000000000000000000000000000000000000000000000000000000000001' + // mod_len = 1
'02' + '03' + '05' // base=2, exp=3, mod=5
);
// Expected: 0x03
// Test 2: 3^1 mod 5 = 3
const input2 = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'03' + '01' + '05' // base=3, exp=1, mod=5
);
// Expected: 0x03
// Test 3: 5^0 mod 7 = 1 (zero exponent)
const input3 = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'05' + '00' + '07' // base=5, exp=0, mod=7
);
// Expected: 0x01
// Test 4: Zero modulus error
const input4 = Hex(
'0x' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'02' + '03' + '00' // base=2, exp=3, mod=0
);
// Expected: Error (division by zero)
```
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [EIP-198: Big Integer Modular Exponentiation](https://eips.ethereum.org/EIPS/eip-198)
* [EIP-2565: ModExp Gas Cost](https://eips.ethereum.org/EIPS/eip-2565)
### Related
* [Crypto: ModExp](/crypto/modexp)
* [Primitives: GasConstants](/primitives/gasconstants)
* [Precompiles Overview](/precompiles)
# 0x0A Point Evaluation
Source: https://voltaire.tevm.sh/evm/precompiles/point-evaluation
KZG point evaluation for EIP-4844 blob verification
**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
**Address:** `0x000000000000000000000000000000000000000a`
**Introduced:** Cancun (EIP-4844)
**EIP:** [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844)
The Point Evaluation precompile verifies KZG (Kate-Zaverucha-Goldberg) polynomial commitment proofs for EIP-4844 blob transactions. It proves that a blob (up to 128KB of data) committed to by a KZG commitment evaluates to a specific value at a random point, without revealing the full blob data. This enables Proto-Danksharding, the critical stepping stone to full Ethereum sharding.
EIP-4844 introduced "blobs" - large data attachments to transactions that are stored by consensus nodes but not by execution layer. Rollups can post transaction batches as blobs (\~128KB each) for \~10x cheaper than calldata, while the KZG proof ensures data availability. This precompile is the cryptographic verification that makes blob trust guarantees possible.
Without this precompile, rollups would remain economically constrained by expensive calldata (\~16 gas/byte). With it, Ethereum scales to support global rollup activity at acceptable costs, making the "world computer" vision practical.
## Gas Cost
**Fixed:** `50,000` gas
Cost is constant regardless of input validity. This covers the expensive BLS12-381 pairing operation.
## Input Format
**Exactly 192 bytes required:**
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | versioned_hash (SHA-256(commitment) with version prefix)
32 | 32 | z (evaluation point, BLS field element)
64 | 32 | y (claimed evaluation value, BLS field element)
96 | 48 | commitment (KZG commitment, BLS12-381 G1 point)
144 | 48 | proof (KZG proof, BLS12-381 G1 point)
```
Total input length: **Exactly 192 bytes**
**Versioned hash validation:**
* Must equal `SHA256(commitment)` with first byte set to `0x01`
* Version byte `0x01` indicates EIP-4844 blob commitment
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | FIELD_ELEMENTS_PER_BLOB (0x1000 = 4096)
32 | 32 | BLS_MODULUS (BLS12-381 field modulus)
```
Total output length: 64 bytes
**Success output values:**
* Bytes 0-29: zero
* Bytes 30-31: `0x1000` (4096 field elements per blob)
* Bytes 32-63: BLS modulus `0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001`
**Failure:** All zeros (64 zero bytes)
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Verify KZG proof for blob data
const versionedHash = Bytes32('0x01...'); // From blob transaction (version 0x01 + SHA256(commitment))
const z = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000000'); // Random evaluation point
const y = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000000'); // Claimed value at z
// Commitment and proof would be actual BLS12-381 G1 points from KZG ceremony
const commitment = new Uint8Array(48); // 48-byte BLS12-381 G1 point
const proof = new Uint8Array(48); // 48-byte KZG opening proof
const input = new Uint8Array(192);
input.set(versionedHash, 0);
input.set(z, 32);
input.set(y, 64);
input.set(commitment, 96);
input.set(proof, 144);
const result = execute(
PrecompileAddress.POINT_EVALUATION,
input,
60000n,
Hardfork.CANCUN
);
if (result.success) {
// Check if proof is valid (non-zero output)
const valid = result.output[31] === 0x00 && result.output[30] === 0x10;
console.log('Proof valid:', valid);
console.log('Gas used:', result.gasUsed); // 50000
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Input length ≠ 192 bytes
* Out of gas (gasLimit \< 50,000)
* Versioned hash mismatch (doesn't match SHA256(commitment) with version byte)
* Invalid KZG commitment (not valid BLS12-381 G1 point)
* Invalid KZG proof (not valid BLS12-381 G1 point)
* Invalid field elements (z or y >= BLS modulus)
Invalid proofs that pass format validation return 64 zero bytes (not an error).
## Use Cases
**Production Applications (Post-Cancun):**
* **Optimism (OP Stack):** Posts transaction batches as blobs instead of calldata. Reduces L1 data costs by \~90%. Each blob contains \~1000-2000 L2 transactions compressed. The Point Evaluation precompile verifies each blob's KZG proof to ensure data availability.
* **Arbitrum One:** Migrated to blobs post-Cancun. Blob-based batches cost \~0.01 ETH vs \~0.10 ETH for calldata equivalents. Processes 40+ TPS on L2 while keeping L1 costs manageable.
* **Base (Coinbase L2):** Uses blobs exclusively for data posting. Handles 10M+ transactions/day with blob-based data availability, keeping fees under \$0.01 per transaction.
* **zkSync Era:** Posts compressed transaction data and zk-proofs as blobs. Combines proof verification with blob data availability for maximum efficiency.
* **Polygon zkEVM:** Blob-based batch submission. Each blob contains validity proofs + transaction data for an entire batch.
* **Starknet:** Posts STARK proofs and transaction data as blobs. Cairo VM state transitions verified on L1 using blob data.
**Why This Matters:**
Before EIP-4844 (pre-Cancun), rollups paid \~16 gas/byte for calldata. A 128KB batch cost \~2M gas ≈ 0.05-0.2 ETH depending on gas prices.
After EIP-4844 (post-Cancun), same data as blob costs \~50K gas (this precompile) + blob gas (separate fee market). Typical cost: 0.001-0.01 ETH for 128KB.
**Result:** 10-20x cost reduction enables rollups to scale from \~10 TPS to 100+ TPS while maintaining decentralization and security.
**Future: Full Danksharding**
Proto-Danksharding (EIP-4844) is step 1. Future upgrades will add:
* **Data availability sampling (DAS):** Clients verify data by sampling random chunks
* **More blobs per block:** From 3-6 blobs to 64+ blobs (8MB+ per block)
* **KZG multi-proofs:** This precompile will verify multiple evaluation points efficiently
Target: 1MB/second sustainable data throughput (enough for global rollup adoption)
## Implementation Details
* **Zig:** Uses c-kzg-4844 library with BLS12-381 pairing
* **TypeScript:** Wraps KZG crypto module (c-kzg bindings)
* **Integration:** Depends on KZG trusted setup (powers of tau ceremony)
* **Curve:** BLS12-381 (embedding degree 12, 381-bit prime)
* **Algorithm:** KZG polynomial commitment opening verification
## Mathematical Background: KZG Commitments Explained
**What is a Polynomial Commitment?**
A polynomial commitment scheme lets you commit to a polynomial `p(x)` with a short commitment `C`, then later prove `p(z) = y` for any point `z` without revealing the polynomial. Think of it like a sealed envelope containing a graph - you can prove the graph passes through specific points without opening the envelope.
**KZG (Kate-Zaverucha-Goldberg) Scheme:**
1. **Trusted Setup:** A multi-party ceremony generates powers of a secret `τ`:
* `[1]₁, [τ]₁, [τ²]₁, ..., [τ⁴⁰⁹⁵]₁` (in elliptic curve group G1)
* The secret `τ` is discarded - nobody knows it
* Ethereum's KZG ceremony had 140,000+ participants in 2023
2. **Commitment:** To commit to polynomial `p(x) = a₀ + a₁x + a₂x² + ... + aₙxⁿ`:
* Compute `C = [p(τ)]₁ = a₀[1]₁ + a₁[τ]₁ + a₂[τ²]₁ + ... + aₙ[τⁿ]₁`
* This is a single 48-byte elliptic curve point (BLS12-381 G1)
3. **Opening Proof:** To prove `p(z) = y`:
* Compute quotient polynomial: `q(x) = (p(x) - y) / (x - z)`
* Proof is `π = [q(τ)]₁` (another 48-byte point)
4. **Verification (this precompile):** Check using pairing:
* `e(C - [y]₁, [1]₂) = e(π, [τ]₂ - [z]₂)`
* This is a single BLS12-381 pairing operation (\~50,000 gas)
* If equation holds, proof is valid
**Why This Works:**
The pairing check verifies: `q(τ) * (τ - z) = p(τ) - y`
This is only true if `q(x) * (x - z) = p(x) - y`, which means `p(z) = y`. Since nobody knows `τ`, you can't fake a proof without actually knowing `p(x)`.
**Security:** Breaking KZG requires either:
* Solving discrete log on BLS12-381 (\~128-bit security)
* All trusted setup participants colluding (impossibly unlikely with 140,000+ participants)
**Why BLS12-381 Instead of BN254?**
* **Higher security:** \~128-bit vs \~100-bit security
* **Longer term:** BN254 security degrades over time, BLS12-381 more future-proof
* **Standardization:** BLS12-381 is industry standard (Zcash, Filecoin, Ethereum 2.0)
## EIP-4844 Blob Structure and Encoding
**Blob Anatomy:**
Each blob is 131,072 bytes (128 KB) of raw data, encoded as a polynomial for KZG commitment:
* **Raw size:** 131,072 bytes (128 KB)
* **Encoded as:** 4096 field elements × 32 bytes each = 131,072 bytes
* **Field elements:** Values in BLS12-381 scalar field Fr (255-bit prime)
* **Polynomial degree:** 4095 (degree n-1 for n points)
* **Commitment:** Single 48-byte BLS12-381 G1 point
* **Proof size:** 48 bytes per evaluation point
**Encoding Process:**
1. Split blob data into 4096 chunks of 32 bytes each
2. Interpret each chunk as a field element in Fr (must be \< BLS modulus)
3. These 4096 values become coefficients of a degree-4095 polynomial
4. Commitment is computed using KZG: `C = [p(τ)]₁`
**Why 4096 Field Elements?**
* **FFT-friendly:** 4096 = 2¹² allows efficient FFT operations
* **Data availability sampling:** Future full Danksharding will sample random subsets
* **Proof size:** Constant 48 bytes regardless of blob size
* **Verification:** Single pairing check regardless of blob size
**Field Element Constraints:**
Each 32-byte chunk must be interpreted as an integer less than the BLS12-381 field modulus:
```
BLS_MODULUS = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001
≈ 2^255 (slightly less)
```
Values ≥ modulus are invalid and cause blob rejection.
## Versioned Hash Format
```
versioned_hash[0] = 0x01 // Version (EIP-4844)
versioned_hash[1:32] = SHA256(commitment)[1:32]
```
Version byte allows future commitment schemes:
* `0x01`: EIP-4844 KZG commitments
* `0x02`: Reserved for future schemes
* `0x03+`: Reserved
## Gas Cost Justification
50,000 gas covers:
* BLS12-381 pairing operation (\~45,000 gas equivalent)
* Field arithmetic and validation
* SHA-256 hash for versioned hash check
Cheaper than equivalent BLS precompiles due to single pairing.
## KZG Trusted Setup
Point evaluation requires KZG trusted setup (powers of tau):
* Ceremony completed in 2023 with 140,000+ participants
* Powers: \[1]₁, \[τ]₁, \[τ²]₁, ..., \[τ⁴⁰⁹⁵]₁
* Security: Safe unless all participants colluded
* Reusable across Ethereum and other systems
## Test Vectors
From EIP-4844 official test suite:
```typescript theme={null}
// Vector 1: Point at infinity (trivial valid proof)
// This is the simplest valid KZG proof - empty polynomial
const input1 = new Uint8Array(192);
// Commitment: point at infinity (0xc0... in BLS12-381 compressed format)
input1[96] = 0xc0; // Infinity flag for commitment
// Proof: point at infinity
input1[144] = 0xc0; // Infinity flag for proof
// z and y are zero (default) - using Bytes32 for clarity
const z1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000000');
const y1 = Bytes32('0x0000000000000000000000000000000000000000000000000000000000000000');
input1.set(z1, 32);
input1.set(y1, 64);
// Compute versioned hash: SHA256(commitment) with version byte 0x01
const commitmentBytes = input1.slice(96, 144);
const hash1 = sha256(commitmentBytes);
hash1[0] = 0x01; // Version byte
const versionedHash1 = Bytes32(hash1);
input1.set(versionedHash1, 0);
const result1 = execute(PrecompileAddress.POINT_EVALUATION, input1, 60000n, Hardfork.CANCUN);
// result1.success === true
// result1.gasUsed === 50000
// result1.output[30] === 0x10, result1.output[31] === 0x00 // FIELD_ELEMENTS_PER_BLOB = 4096
// Vector 2: Valid proof with non-zero values
// From EIP-4844 verify_kzg_proof_case_correct_proof_1_0
const commitment2 = hexToBytes('a572cbea904d67468808c8eb50a9450c9721db309128012543902d0ac358a62ae28f75bb8f1c7c42c39a8c5529bf0f4e');
const z2 = hexToBytes('0000000000000000000000000000000000000000000000000000000000000000');
const y2 = hexToBytes('0000000000000000000000000000000000000000000000000000000000000002');
const proof2 = hexToBytes('c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
const input2 = new Uint8Array(192);
input2.set(z2, 32);
input2.set(y2, 64);
input2.set(commitment2, 96);
input2.set(proof2, 144);
// Compute versioned hash
const hash2 = sha256(commitment2);
hash2[0] = 0x01;
input2.set(hash2, 0);
const result2 = execute(PrecompileAddress.POINT_EVALUATION, input2, 60000n, Hardfork.CANCUN);
// result2.success === true
// result2.output[30] === 0x10, result2.output[31] === 0x00 // Valid proof
// Vector 3: Invalid proof (wrong proof for commitment)
// From EIP-4844 verify_kzg_proof_case_incorrect_proof_0_0
const commitment3 = hexToBytes('c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
const z3 = hexToBytes('0000000000000000000000000000000000000000000000000000000000000000');
const y3 = hexToBytes('0000000000000000000000000000000000000000000000000000000000000000');
const proof3 = hexToBytes('97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb');
const input3 = new Uint8Array(192);
input3.set(z3, 32);
input3.set(y3, 64);
input3.set(commitment3, 96);
input3.set(proof3, 144);
const hash3 = sha256(commitment3);
hash3[0] = 0x01;
input3.set(hash3, 0);
const result3 = execute(PrecompileAddress.POINT_EVALUATION, input3, 60000n, Hardfork.CANCUN);
// result3.success === true
// result3.output === all zeros (proof verification failed, but no error)
// Vector 4: Versioned hash mismatch
const input4 = new Uint8Array(192);
input4[96] = 0xc0; // Valid commitment
input4[144] = 0xc0; // Valid proof
input4[0] = 0xFF; // Wrong versioned hash (should be SHA256(commitment) with 0x01)
const result4 = execute(PrecompileAddress.POINT_EVALUATION, input4, 60000n, Hardfork.CANCUN);
// result4.success === false
// result4.error === 'InvalidInput' (versioned hash doesn't match commitment)
```
## Complete Blob Transaction Flow
**Step-by-step from rollup to verification:**
1. **Rollup Sequencer:** Batches 1000+ L2 transactions, compresses to \~100KB
2. **Blob Preparation:**
* Encodes data as 4096 BLS field elements (polynomial coefficients)
* Computes KZG commitment: `C = [p(τ)]₁` using trusted setup
* Generates versioned hash: `SHA256(C)` with version byte `0x01`
3. **Transaction Submission:**
* Submits Type-3 blob transaction to Ethereum
* Transaction includes: versioned\_hash in `blob_versioned_hashes` field
* Actual blob data sent separately to consensus layer (not in block)
4. **Consensus Layer Storage:**
* Beacon chain stores full blob (\~128KB) in blob sidecar
* Blob stored for minimum 4096 epochs (\~18 days)
* After 18 days, blob is pruned (only commitment remains on chain)
5. **Verification on L1 (this precompile):**
* L1 contract receives blob transaction
* Calls POINT\_EVALUATION precompile with (versioned\_hash, z, y, commitment, proof)
* Precompile verifies: commitment matches hash AND KZG proof is valid
* If valid, rollup contract accepts the batch
6. **Long-term Storage:**
* KZG commitment (48 bytes) remains on-chain forever
* Full blob (128KB) pruned after \~18 days
* Archive nodes may retain blobs longer (optional)
* Anyone who needs historical blob data must have downloaded it during 18-day window
**Data Availability Guarantee:**
The KZG proof guarantees that:
* Data existed and was available for 18 days minimum
* The commitment is a binding commitment to specific data
* Cannot be changed retroactively (commitment is on-chain forever)
* Enough time for anyone to challenge invalid state transitions
**Separate Blob Gas Market:**
Blob gas is independent from regular gas:
* Target: 3 blobs per block (384 KB)
* Max: 6 blobs per block (768 KB)
* Price adjusts via EIP-1559 style mechanism
* Typical blob gas price: 1-10 wei (vs 10-50 gwei for regular gas)
* 1000x+ cheaper than calldata per byte
## Related
* [Crypto: KZG](/crypto/kzg) - KZG polynomial commitment implementation
* [Crypto: BLS12-381](/crypto/bls12-381) - BLS12-381 elliptic curve operations
* [Primitives: Blob](/primitives/blob) - Blob data type and utilities
* [Primitives: FeeMarket (EIP-4844)](/primitives/feemarket/eip4844) - Blob gas pricing
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E
* [EIP-4844: Shard Blob Transactions](https://eips.ethereum.org/EIPS/eip-4844) - Complete specification
* [KZG Ceremony](https://ceremony.ethereum.org/) - Trusted setup details
* [Proto-Danksharding FAQ](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq) - High-level overview
* [c-kzg-4844 Library](https://github.com/ethereum/c-kzg-4844) - Reference implementation
# 0x03 RIPEMD160
Source: https://voltaire.tevm.sh/evm/precompiles/ripemd160
RIPEMD-160 cryptographic hash function
**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
**Address:** `0x0000000000000000000000000000000000000003`
**Introduced:** Frontier
The RIPEMD160 precompile implements the RIPEMD-160 cryptographic hash function, producing a 20-byte hash of arbitrary input data. RIPEMD-160 is used in Bitcoin for generating addresses from public keys.
This precompile enables Ethereum contracts to verify Bitcoin addresses, validate Bitcoin-style address generation, and interact with systems using RIPEMD-160.
## Gas Cost
**Formula:** `600 + 120 * ceil(input_length / 32)`
* Base cost: `600` gas
* Per-word cost: `120` gas per 32-byte word
* Partial words round up
**Examples:**
* 0 bytes: 600 gas
* 32 bytes: 720 gas (600 + 120\*1)
* 33 bytes: 840 gas (600 + 120\*2)
* 64 bytes: 840 gas (600 + 120\*2)
## Input Format
Accepts arbitrary-length byte array. No restrictions on input size.
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 12 | Zero padding (left-padded to 32 bytes)
12 | 20 | RIPEMD-160 hash of input
```
Total output length: 32 bytes (20-byte hash + 12 bytes padding)
The hash is right-aligned in a 32-byte word with 12 leading zero bytes.
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Hash some data
const input = new TextEncoder().encode("Hello, Bitcoin!");
// Calculate required gas
const words = Math.ceil(input.length / 32);
const gasNeeded = 600n + 120n * BigInt(words);
// Execute precompile
const result = execute(
PrecompileAddress.RIPEMD160,
input,
gasNeeded,
Hardfork.CANCUN
);
if (result.success) {
// Extract 20-byte hash from right side
const hash = result.output.slice(12, 32);
console.log('RIPEMD-160 hash:', hash);
console.log('Gas used:', result.gasUsed);
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (insufficient for 600 + 120 \* ceil(len/32))
## Use Cases
* **Bitcoin address generation:** Generate Bitcoin P2PKH addresses from public keys
* **Bitcoin integration:** Verify Bitcoin address ownership in Ethereum contracts
* **Cross-chain bridges:** Validate Bitcoin-style addresses
* **Legacy cryptography:** Interface with systems using RIPEMD-160
## Implementation Details
* **Zig:** Uses RIPEMD-160 implementation from crypto module, left-pads output to 32 bytes
* **TypeScript:** Wraps Ripemd160.hash from crypto module, applies padding
* **Integration:** Standalone, no dependencies on other primitives
* **Output format:** Right-aligned 20-byte hash in 32-byte word
## Bitcoin Address Generation
Bitcoin P2PKH addresses use RIPEMD-160:
```typescript theme={null}
// Bitcoin address generation:
// 1. SHA-256 hash of public key
const sha256Hash = executeSHA256(publicKey);
// 2. RIPEMD-160 hash of SHA-256 hash
const ripemd160Hash = executeRIPEMD160(sha256Hash.output);
// 3. Add version byte (0x00 for mainnet)
// 4. Double SHA-256 for checksum
// 5. Base58 encode
```
## Performance Considerations
RIPEMD-160 is the most expensive hash precompile (600 base gas vs 60 for SHA256, 30 for Keccak256). The high cost reflects its computational complexity and relatively rare usage.
Gas costs favor larger inputs:
* Per-byte cost: \~3.75 gas/byte
* 10x more expensive than SHA-256 per byte
Use SHA-256 or Keccak256 for general-purpose hashing when RIPEMD-160 compatibility is not required.
## Test Vectors
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
import { Bytes32 } from '@tevm/voltaire/primitives/Bytes32';
// Test 1: Empty input
const input1 = new Uint8Array(0);
// Expected: 9c1185a5c5e9fc54612808977ee8f548b2258d31 (20 bytes, padded to 32)
const expected1 = Bytes32('0x0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31');
// Test 2: Small input
const input2 = Hex('0x0102030405');
// Gas: 600 + 120 * ceil(5/32) = 600 + 120*1 = 720
// Output: 32 bytes (12 zero padding + 20 hash bytes)
// Test 3: Exact 32-byte boundary
const input3 = Hex('0x' + '00'.repeat(32));
// Gas: 600 + 120 * 1 = 720
```
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [Bitcoin Address Generation](https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses)
* [RIPEMD-160 Specification](https://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
### Related
* [Crypto: RIPEMD160](/crypto/ripemd160)
* [Precompile: SHA256](/evm/precompiles/sha256)
* [Precompiles Overview](/precompiles)
# 0x02 SHA256
Source: https://voltaire.tevm.sh/evm/precompiles/sha256
SHA-256 cryptographic hash function
**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
**Address:** `0x0000000000000000000000000000000000000002`
**Introduced:** Frontier
The SHA256 precompile implements the SHA-256 cryptographic hash function, producing a 32-byte hash of arbitrary input data. SHA-256 is part of the SHA-2 family standardized by NIST and is widely used in Bitcoin and other systems.
This precompile enables Ethereum contracts to verify Bitcoin SPV proofs, validate SHA-256 based signatures, and interact with systems that use SHA-256 hashing.
## Gas Cost
**Formula:** `60 + 12 * ceil(input_length / 32)`
* Base cost: `60` gas
* Per-word cost: `12` gas per 32-byte word
* Partial words round up
**Examples:**
* 0 bytes: 60 gas
* 32 bytes: 72 gas (60 + 12\*1)
* 33 bytes: 84 gas (60 + 12\*2)
* 64 bytes: 84 gas (60 + 12\*2)
## Input Format
Accepts arbitrary-length byte array. No restrictions on input size.
## Output Format
```
Offset | Length | Description
-------|--------|-------------
0 | 32 | SHA-256 hash of input
```
Total output length: 32 bytes (256 bits)
## Usage Example
```typescript theme={null}
import { execute, PrecompileAddress } from '@tevm/voltaire/precompiles';
import { Hardfork } from '@tevm/voltaire/primitives/Hardfork';
// Hash some data
const input = new TextEncoder().encode("Hello, Ethereum!");
// Calculate required gas
const words = Math.ceil(input.length / 32);
const gasNeeded = 60n + 12n * BigInt(words);
// Execute precompile
const result = execute(
PrecompileAddress.SHA256,
input,
gasNeeded,
Hardfork.CANCUN
);
if (result.success) {
console.log('SHA-256 hash:', result.output);
console.log('Gas used:', result.gasUsed);
} else {
console.error('Error:', result.error);
}
```
## Error Conditions
* Out of gas (insufficient for 60 + 12 \* ceil(len/32))
## Use Cases
* **Bitcoin SPV proofs:** Verify Bitcoin block headers and transactions in Ethereum contracts
* **Cross-chain bridges:** Validate proofs from SHA-256 based blockchains
* **Legacy system integration:** Interface with systems using SHA-256 hashing
* **Document verification:** Hash and verify document integrity
* **Merkle trees:** Build SHA-256 based Merkle trees for data verification
## Implementation Details
* **Zig:** Uses hardware-accelerated SHA-256 implementation from crypto module
* **TypeScript:** Wraps SHA256.hash from crypto module
* **Integration:** Standalone, no dependencies on other primitives
* **Performance:** Optimized for throughput with SIMD instructions where available
## Test Vectors
```typescript theme={null}
import * as Hex from '@tevm/voltaire/Hex';
import { Bytes32 } from '@tevm/voltaire/primitives/Bytes32';
// Test 1: Empty input
const input1 = new Uint8Array(0);
// Expected: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
const expected1 = Bytes32('0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
// Test 2: "abc"
const input2 = new TextEncoder().encode("abc");
// Expected: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
const expected2 = Hash('0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
// Test 3: Large input (1000 bytes of zeros)
const input3 = Hex('0x' + '00'.repeat(1000));
// Gas: 60 + 12 * ceil(1000/32) = 60 + 12*32 = 444
```
## Bitcoin Integration
Bitcoin uses double SHA-256 for block hashes. To verify Bitcoin blocks in Ethereum:
```typescript theme={null}
// Bitcoin block hash = SHA256(SHA256(header))
const firstHash = executeSHA256(blockHeader);
const blockHash = executeSHA256(firstHash.output);
```
## Performance Considerations
SHA-256 is more expensive than Keccak256 on Ethereum (60 vs 30 base gas). Use Keccak256 for Ethereum-native hashing when possible.
Gas costs favor larger batches:
* Per-byte cost: \~0.375 gas/byte
* Prefer hashing larger inputs over multiple small ones
## References
### Specifications
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Appendix E (Precompiled Contracts)
* [FIPS 180-4: SHA-2 Standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf)
### Related
* [Crypto: SHA256](/crypto/sha256)
* [Precompile: RIPEMD160](/evm/precompiles/ripemd160)
* [Precompiles Overview](/precompiles)
# EVM Types
Source: https://voltaire.tevm.sh/evm/types
Type-safe execution primitives for Ethereum Virtual Machine operations
Type-first EVM architecture. Every execution primitive is a strongly-typed branded Uint8Array or interface.
These are low-level primitives for EVM operations, not a full EVM implementation. For complete EVM implementations, see [evmts/guillotine-mini](https://github.com/evmts/guillotine-mini) (lightweight) or [evmts/guillotine](https://github.com/evmts/guillotine) (full-featured).
## Core Types
### Opcode
Branded number type for EVM instructions (0x00-0xFF).
```typescript theme={null}
import { Opcode } from "@tevm/voltaire";
// Opcode type is a branded number
type OpcodeType = number & { readonly __tag: "Opcode" };
// Create opcodes
const add: Opcode = Opcode.ADD; // 0x01
const push1: Opcode = Opcode.PUSH1; // 0x60
const sload: Opcode = Opcode.SLOAD; // 0x54
// Type safety prevents passing arbitrary numbers
// ❌ const invalid: Opcode = 0x01; // Type error!
```
See [Opcode documentation](/primitives/opcode) for complete reference.
### Instruction
Opcode with program counter offset and optional immediate data.
```typescript theme={null}
import { Instruction, Opcode } from "@tevm/voltaire";
type Instruction = {
/** Program counter offset */
offset: number;
/** The opcode */
opcode: OpcodeType;
/** Immediate data for PUSH operations */
immediate?: Uint8Array;
};
// PUSH1 0x42 at offset 0
const push: Instruction = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42]),
};
// ADD at offset 2
const add: Instruction = {
offset: 2,
opcode: Opcode.ADD,
};
```
Instructions are returned by bytecode analysis:
```typescript theme={null}
import { Bytecode } from "@tevm/voltaire";
const code = Bytecode.from("0x6001600201");
const analysis = code.analyze();
// analysis.instructions: Instruction[]
// [
// { offset: 0, opcode: 0x60, immediate: Uint8Array([0x01]) }, // PUSH1 1
// { offset: 2, opcode: 0x60, immediate: Uint8Array([0x02]) }, // PUSH1 2
// { offset: 4, opcode: 0x01 } // ADD
// ]
```
## Execution Types
### Frame
EVM execution frame with stack, memory, and execution state.
```typescript theme={null}
import type { BrandedFrame } from "@tevm/voltaire/evm";
import type { Address } from "@tevm/voltaire";
type BrandedFrame = {
readonly __tag: "Frame";
// Stack (max 1024 items, 256-bit words)
stack: bigint[];
// Memory (sparse map, byte-addressable)
memory: Map;
memorySize: number; // Word-aligned size
// Execution state
pc: number; // Program counter
gasRemaining: bigint;
bytecode: Uint8Array;
// Call context
caller: Address;
address: Address;
value: bigint;
calldata: Uint8Array;
output: Uint8Array;
returnData: Uint8Array;
// Flags
stopped: boolean;
reverted: boolean;
isStatic: boolean;
// Block context (for block opcodes)
blockNumber?: bigint;
blockTimestamp?: bigint;
blockGasLimit?: bigint;
chainId?: bigint;
blockBaseFee?: bigint;
blobBaseFee?: bigint;
// Logs (LOG0-LOG4 opcodes)
logs?: Array<{
address: Address;
topics: bigint[];
data: Uint8Array;
}>;
};
```
Frame represents the complete execution state at any point in EVM execution.
### Host
Interface for external state access (accounts, storage, code) and nested execution.
```typescript theme={null}
import type { BrandedHost, CallParams, CallResult, CreateParams, CreateResult } from "@tevm/voltaire/evm";
import type { Address } from "@tevm/voltaire";
type BrandedHost = {
readonly __tag: "Host";
// Account balance
getBalance: (address: Address) => bigint;
setBalance: (address: Address, balance: bigint) => void;
// Contract code
getCode: (address: Address) => Uint8Array;
setCode: (address: Address, code: Uint8Array) => void;
// Persistent storage
getStorage: (address: Address, slot: bigint) => bigint;
setStorage: (address: Address, slot: bigint, value: bigint) => void;
// Account nonce
getNonce: (address: Address) => bigint;
setNonce: (address: Address, nonce: bigint) => void;
// Transient storage (EIP-1153, transaction-scoped)
getTransientStorage: (address: Address, slot: bigint) => bigint;
setTransientStorage: (address: Address, slot: bigint, value: bigint) => void;
// Nested execution (optional - for CALL/CREATE opcodes)
call?: (params: CallParams) => CallResult;
create?: (params: CreateParams) => CreateResult;
};
```
The `call` and `create` methods are optional. When not provided, system opcodes (CALL, CREATE, etc.) return a `NotImplemented` error. For full EVM execution with nested calls, use:
* **[guillotine](https://github.com/evmts/guillotine)**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
Host provides pluggable state backend - implement for custom chains or test environments.
### InstructionHandler
Function signature for opcode implementations.
```typescript theme={null}
import type { InstructionHandler, BrandedFrame, BrandedHost, EvmError } from "@tevm/voltaire/evm";
type InstructionHandler = (
frame: BrandedFrame,
host: BrandedHost,
) => EvmError | { type: "Success" };
```
Example handler implementation:
```typescript theme={null}
// ADD opcode (0x01): Pop two values, push sum
const addHandler: InstructionHandler = (frame, host) => {
// Check stack depth
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
// Check gas
if (frame.gasRemaining < 3n) {
return { type: "OutOfGas" };
}
// Execute
const b = frame.stack.pop()!;
const a = frame.stack.pop()!;
const result = (a + b) % 2n**256n; // Mod 2^256 for overflow
frame.stack.push(result);
frame.gasRemaining -= 3n;
frame.pc += 1;
return { type: "Success" };
};
```
All 166 EVM opcodes follow this pattern. See [Instructions](/evm/instructions).
## Call Types
### CallParams
Parameters for cross-contract calls (CALL, STATICCALL, DELEGATECALL).
```typescript theme={null}
import type { CallParams, CallType, Address } from "@tevm/voltaire";
type CallType = "CALL" | "STATICCALL" | "DELEGATECALL" | "CALLCODE";
type CallParams = {
callType: CallType;
target: Address;
value: bigint;
gasLimit: bigint;
input: Uint8Array;
caller: Address;
isStatic: boolean;
depth: number;
};
```
Example usage:
```typescript theme={null}
// STATICCALL to view function
const params: CallParams = {
callType: "STATICCALL",
target: contractAddress,
value: 0n,
gasLimit: 100000n,
input: encodedCalldata,
caller: myAddress,
isStatic: true,
depth: 1,
};
```
### CallResult
Result of call operation.
```typescript theme={null}
import type { CallResult, Address } from "@tevm/voltaire";
type CallResult = {
success: boolean; // False if reverted
gasUsed: bigint;
output: Uint8Array; // Return data or revert reason
logs: Array<{
address: Address;
topics: bigint[];
data: Uint8Array;
}>;
gasRefund: bigint;
};
```
Example:
```typescript theme={null}
// Successful call
const result: CallResult = {
success: true,
gasUsed: 21000n,
output: returnData,
logs: [],
gasRefund: 0n,
};
// Reverted call
const revertResult: CallResult = {
success: false,
gasUsed: 50000n,
output: revertReason, // Revert message
logs: [],
gasRefund: 0n,
};
```
## Creation Types
### CreateParams
Parameters for contract deployment (CREATE, CREATE2).
```typescript theme={null}
import type { CreateParams, Address } from "@tevm/voltaire";
type CreateParams = {
caller: Address;
value: bigint;
initCode: Uint8Array;
gasLimit: bigint;
salt?: bigint; // For CREATE2
depth: number;
};
```
Example:
```typescript theme={null}
// CREATE2 deployment with deterministic address
const params: CreateParams = {
caller: deployerAddress,
value: 0n,
initCode: contractBytecode,
gasLimit: 1000000n,
salt: 0x1234n, // Determines address
depth: 1,
};
```
### CreateResult
Result of contract creation.
```typescript theme={null}
import type { CreateResult, Address } from "@tevm/voltaire";
type CreateResult = {
success: boolean;
address: Address | null; // Null if failed
gasUsed: bigint;
output: Uint8Array; // Runtime code or revert reason
gasRefund: bigint;
};
```
Example:
```typescript theme={null}
// Successful deployment
const result: CreateResult = {
success: true,
address: newContractAddress,
gasUsed: 200000n,
output: runtimeCode,
gasRefund: 0n,
};
```
## Error Types
### EvmError
Execution errors that halt the EVM.
```typescript theme={null}
type EvmError =
| { type: "StackOverflow" }
| { type: "StackUnderflow" }
| { type: "OutOfGas" }
| { type: "OutOfBounds" }
| { type: "InvalidJump" }
| { type: "InvalidOpcode" }
| { type: "RevertExecuted" }
| { type: "CallDepthExceeded" }
| { type: "WriteProtection" }
| { type: "InsufficientBalance" }
| { type: "NotImplemented"; message: string };
```
The `NotImplemented` error is returned by system opcodes (CALL, CREATE, etc.) when the host doesn't provide `call` or `create` methods. This is intentional - these low-level primitives don't include an execution engine. Use guillotine or guillotine-mini for full EVM execution.
Error handling:
```typescript theme={null}
const result = instructionHandler(frame, host);
if (result.type !== "Success") {
// Handle error
switch (result.type) {
case "StackUnderflow":
console.error("Stack underflow - not enough items");
break;
case "OutOfGas":
console.error("Insufficient gas");
break;
case "RevertExecuted":
console.error("Execution reverted");
break;
case "NotImplemented":
console.error("Feature not implemented:", result.message);
break;
// ... handle other errors
}
}
```
## Opcode Metadata
### Info
Opcode metadata (gas cost, stack effect).
```typescript theme={null}
import { Opcode } from "@tevm/voltaire";
type Info = {
gasCost: number; // Base gas cost (may be dynamic)
stackInputs: number; // Items consumed from stack
stackOutputs: number; // Items pushed to stack
name: string; // Opcode name
};
// Get opcode info
const info = Opcode.info(Opcode.ADD);
// {
// gasCost: 3,
// stackInputs: 2,
// stackOutputs: 1,
// name: "ADD"
// }
```
## Type Safety Benefits
### Prevents Type Confusion
```typescript theme={null}
import { Opcode, Address, Bytecode } from "@tevm/voltaire";
// ❌ Cannot pass wrong type
const opcode: Opcode = 0x01; // Type error!
const addr: Address = "0x123..."; // Type error!
// ✅ Must use constructors
const opcode = Opcode.ADD; // Correct
const addr = Address("0x123..."); // Correct
```
### Compile-Time Validation
```typescript theme={null}
// ❌ Type mismatch caught at compile time
function executeOpcode(op: Opcode) { /*...*/ }
executeOpcode(0x60); // Type error!
// ✅ Type-safe
executeOpcode(Opcode.PUSH1); // Correct
```
### IDE Autocomplete
TypeScript provides full IntelliSense:
```typescript theme={null}
import { Opcode } from "@tevm/voltaire";
const op = Opcode.
// ^ Shows all opcode names with documentation
```
### Zero Runtime Overhead
Branded types are compile-time only:
```typescript theme={null}
// TypeScript
const op: OpcodeType = Opcode.ADD;
// Compiles to JavaScript
const op = 0x01; // No wrapper, just the number
```
## Architecture
### Execution Flow
```typescript theme={null}
import type { BrandedFrame, BrandedHost, InstructionHandler } from "@tevm/voltaire/evm";
// 1. Initialize frame
const frame: BrandedFrame = {
stack: [],
memory: new Map(),
memorySize: 0,
pc: 0,
gasRemaining: 1000000n,
bytecode: code,
// ... other fields
};
// 2. Initialize host
const host: BrandedHost = {
getBalance: (addr) => balances.get(addr) || 0n,
setBalance: (addr, bal) => balances.set(addr, bal),
// ... other methods
};
// 3. Execute instructions
while (!frame.stopped && !frame.reverted) {
const opcode = frame.bytecode[frame.pc];
const handler = getHandler(opcode);
const result = handler(frame, host);
if (result.type !== "Success") {
// Handle error
break;
}
}
```
### Pluggable Backend
Host interface allows custom state implementations:
```typescript theme={null}
// In-memory state for testing
class MemoryHost implements BrandedHost {
private balances = new Map();
private storage = new Map();
getBalance(addr: Address) { return this.balances.get(addr) || 0n; }
setBalance(addr: Address, bal: bigint) { this.balances.set(addr, bal); }
// ... implement other methods
}
// Database-backed state for production
class DatabaseHost implements BrandedHost {
async getBalance(addr: Address) { return await db.getBalance(addr); }
// ... implement with DB queries
}
```
## Related Documentation
Opcode type and constants
Bytecode analysis and instruction parsing
All 166 opcode handlers
Address type for account references
## References
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - EVM formal specification
* [evm.codes](https://www.evm.codes/) - Interactive opcode reference
* [guillotine-mini](https://github.com/evmts/guillotine-mini) - Reference architecture
* [Branded Types](/concepts/branded-types) - Type pattern explanation
# Derive Address from Private Key
Source: https://voltaire.tevm.sh/examples/addresses/address-from-private-key
Generate an Ethereum address from a private key using public key derivation
Generate an Ethereum address from a private key using public key derivation
```typescript theme={null}
import * as Address from '@tevm/voltaire/Address';
import * as Hex from '@tevm/voltaire/Hex';
// Example private key (32 bytes)
const privateKey = Hex.toBytes(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
);
// Derive address from private key
const address = Address.fromPrivateKey(privateKey);
// Get checksummed representation (static method)
const checksummed = Address.toChecksummed(address);
// Try another private key
const privateKey2 = Hex.toBytes(
"0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
);
const address2 = Address.fromPrivateKey(privateKey2);
const checksummed2 = Address.toChecksummed(address2);
```
This is a fully executable example. View the complete source with test assertions at [`examples/addresses/address-from-private-key.ts`](https://github.com/evmts/voltaire/blob/main/examples/addresses/address-from-private-key.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# EIP-55 Checksum Address
Source: https://voltaire.tevm.sh/examples/addresses/checksum-address
Convert addresses to EIP-55 checksummed format for safer usage
Convert addresses to EIP-55 checksummed format for safer usage
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
// Lowercase address (no checksum)
const lowercaseAddr = "0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed";
// Convert to checksummed format
const addr = Address(lowercaseAddr);
const checksummed = Address.toChecksummed(addr);
// Verify the checksum is valid
const isValid = Address.isValidChecksum(checksummed);
```
This is a fully executable example. View the complete source with test assertions at [`examples/addresses/checksum-address.ts`](https://github.com/evmts/voltaire/blob/main/examples/addresses/checksum-address.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Compare and Sort Addresses
Source: https://voltaire.tevm.sh/examples/addresses/compare-addresses
Compare Ethereum addresses for equality and sorting
Compare Ethereum addresses for equality and sorting
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
// Create some addresses
const addr1 = Address("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const addr2 = Address("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed");
const addr3 = Address("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"); // Same as addr1
// Check equality (case-insensitive)
const areEqual = Address.equals(addr1, addr3);
const notEqual = Address.equals(addr1, addr2);
// Compare for sorting (lexicographic order)
const comparison = Address.compare(addr1, addr2);
// Sort addresses
const addresses = [addr2, addr1, addr3];
const sorted = addresses.sort(Address.compare);
```
This is a fully executable example. View the complete source with test assertions at [`examples/addresses/compare-addresses.ts`](https://github.com/evmts/voltaire/blob/main/examples/addresses/compare-addresses.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Validate Ethereum Address
Source: https://voltaire.tevm.sh/examples/addresses/validate-address
Check if a string is a valid Ethereum address with EIP-55 checksum validation
Check if a string is a valid Ethereum address with EIP-55 checksum validation
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
// Valid checksummed address
const validAddr = "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3";
const isValid = Address.isValid(validAddr);
// Invalid checksum
const invalidChecksum = "0x742d35cc6634c0532925a3b844bc9e7595f251e3";
const hasValidChecksum = Address.isValidChecksum(invalidChecksum);
// Not an address
const notAddress = "0x123";
```
This is a fully executable example. View the complete source with test assertions at [`examples/addresses/validate-address.ts`](https://github.com/evmts/voltaire/blob/main/examples/addresses/validate-address.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Merkle Proof Verification
Source: https://voltaire.tevm.sh/examples/advanced/merkle-proof
Verify a Merkle proof for allowlists and airdrops
Build and verify Merkle proofs for NFT allowlists and token airdrops.
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
import * as Hash from '@tevm/voltaire/Hash';
// Define airdrop allowlist addresses
const allowlist = [
"0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
"0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
"0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
"0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
"0x90F79bf6EB2c4f870365E785982E1f101E93b906",
"0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
"0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
"0x976EA74026E726554dB657fA54763abd0C3a0aa9"
];
// Create leaf nodes by hashing each address
const leaves = allowlist.map(addr => {
const normalized = Address.from(addr);
return Keccak256(normalized);
});
// Build Merkle tree and get root
const root = Hash.merkleRoot(leaves);
const rootHex = Hex.fromBytes(root);
// Generate proof for a specific address (index 2)
const targetIndex = 2;
const targetAddress = allowlist[targetIndex];
// For a complete Merkle proof, we need sibling hashes at each level
// This is a simplified example - in production use a full Merkle tree library
function generateProof(leaves: Uint8Array[], index: number): Uint8Array[] {
const proof: Uint8Array[] = [];
let currentLevel = [...leaves];
let currentIndex = index;
while (currentLevel.length > 1) {
const siblingIndex = currentIndex % 2 === 0 ? currentIndex + 1 : currentIndex - 1;
if (siblingIndex < currentLevel.length) {
proof.push(currentLevel[siblingIndex]);
}
// Move to next level
const nextLevel: Uint8Array[] = [];
for (let i = 0; i < currentLevel.length; i += 2) {
const left = currentLevel[i];
const right = currentLevel[i + 1] || left;
const combined = new Uint8Array(64);
combined.set(left, 0);
combined.set(right, 32);
nextLevel.push(Keccak256(combined));
}
currentLevel = nextLevel;
currentIndex = Math.floor(currentIndex / 2);
}
return proof;
}
const proof = generateProof(leaves, targetIndex);
// Verify proof by reconstructing root from leaf + proof
function verifyProof(
leaf: Uint8Array,
proof: Uint8Array[],
root: Uint8Array,
index: number
): boolean {
let computed = leaf;
let currentIndex = index;
for (const sibling of proof) {
const combined = new Uint8Array(64);
if (currentIndex % 2 === 0) {
combined.set(computed, 0);
combined.set(sibling, 32);
} else {
combined.set(sibling, 0);
combined.set(computed, 32);
}
computed = Keccak256(combined);
currentIndex = Math.floor(currentIndex / 2);
}
// Compare computed root with expected root
return computed.every((byte, i) => byte === root[i]);
}
const targetLeaf = Keccak256(Address.from(targetAddress));
const isValid = verifyProof(targetLeaf, proof, root, targetIndex);
// Verify an address NOT in the allowlist fails
const invalidAddress = "0x0000000000000000000000000000000000000001";
const invalidLeaf = Keccak256(Address.from(invalidAddress));
const isInvalid = verifyProof(invalidLeaf, proof, root, targetIndex);
```
This pattern is used by NFT projects for allowlist minting and by protocols for token airdrops. The Merkle root is stored on-chain, and users submit proofs to claim their allocation.
## On-chain Verification
Store the root on-chain and verify proofs in Solidity:
```solidity theme={null}
// Solidity contract for on-chain verification
contract MerkleAllowlist {
bytes32 public immutable merkleRoot;
constructor(bytes32 _merkleRoot) {
merkleRoot = _merkleRoot;
}
function verify(bytes32[] calldata proof, address account)
public view returns (bool)
{
bytes32 leaf = keccak256(abi.encodePacked(account));
return MerkleProof.verify(proof, merkleRoot, leaf);
}
}
```
## Related
* [Hash Primitives](/primitives/hash)
* [Keccak256 Cryptography](/crypto/keccak256)
* [More Examples](/examples)
# Batch Requests with Multicall
Source: https://voltaire.tevm.sh/examples/advanced/multicall-batch
Batch multiple contract calls into a single RPC request
Batch multiple contract calls into a single RPC request using Multicall3.
```typescript theme={null}
import { ABI } from '@tevm/voltaire/ABI';
import { Hex } from '@tevm/voltaire/Hex';
import { Address } from '@tevm/voltaire/Address';
import * as Abi from '@tevm/voltaire/Abi';
// ERC20 balanceOf ABI
const erc20Abi = [
{
type: "function",
name: "balanceOf",
stateMutability: "view",
inputs: [{ type: "address", name: "account" }],
outputs: [{ type: "uint256", name: "balance" }]
}
] as const;
// Multicall3 aggregate ABI
const multicall3Abi = [
{
type: "function",
name: "aggregate3",
stateMutability: "payable",
inputs: [{
type: "tuple[]",
name: "calls",
components: [
{ type: "address", name: "target" },
{ type: "bool", name: "allowFailure" },
{ type: "bytes", name: "callData" }
]
}],
outputs: [{
type: "tuple[]",
name: "results",
components: [
{ type: "bool", name: "success" },
{ type: "bytes", name: "returnData" }
]
}]
}
] as const;
// Token addresses to query (example mainnet tokens)
const tokenAddresses = [
"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
"0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
"0x6B175474E89094C44Da98b954EescdeCB5BFF4dC", // DAI
"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
"0x514910771AF9Ca656af840dff83E8264EcF986CA", // LINK
"0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984", // UNI
"0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9", // AAVE
"0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2", // MKR
"0xc00e94Cb662C3520282E6f5717214004A7f26888" // COMP
];
// Account to check balances for
const account = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
// Multicall3 address (same on all chains)
const multicall3Address = "0xcA11bde05977b3631167028862bE2a173976CA11";
// Encode each balanceOf call
const calls = tokenAddresses.map(tokenAddress => {
const callData = Abi.Function.encodeParams(
erc20Abi[0],
[account]
);
return {
target: tokenAddress,
allowFailure: true, // Don't revert if one call fails
callData: Hex.fromBytes(callData)
};
});
// Encode the multicall aggregate3 call
const multicallData = Abi.Function.encodeParams(
multicall3Abi[0],
[calls]
);
// This single call replaces 10 individual RPC calls
const multicallHex = Hex.fromBytes(multicallData);
// Decode results after execution
function decodeMulticallResults(resultData: Uint8Array) {
const results = Abi.Function.decodeResult(multicall3Abi[0], resultData);
const balances = results[0].map((result: { success: boolean; returnData: string }, i: number) => {
if (!result.success) {
return { token: tokenAddresses[i], balance: null, error: true };
}
const decoded = Abi.Function.decodeResult(
erc20Abi[0],
Hex.toBytes(result.returnData)
);
return {
token: tokenAddresses[i],
balance: decoded[0] as bigint,
error: false
};
});
return balances;
}
// Gas savings calculation
const gasPerCall = 21000n + 2600n; // Base + cold SLOAD
const singleCallsGas = gasPerCall * BigInt(tokenAddresses.length);
const multicallOverhead = 21000n + 700n; // Base + multicall logic
const multicallGas = multicallOverhead + (2600n * BigInt(tokenAddresses.length));
const gasSaved = singleCallsGas - multicallGas;
console.log(`Single calls: ${singleCallsGas} gas`);
console.log(`Multicall: ${multicallGas} gas`);
console.log(`Saved: ${gasSaved} gas (${(gasSaved * 100n) / singleCallsGas}%)`);
```
Multicall3 is deployed at the same address on all EVM chains. It's the standard way to batch read operations and reduce RPC calls in dApps.
## Benefits
| Approach | RPC Calls | Latency | Gas (if on-chain) |
| ---------------- | --------- | --------------- | ----------------- |
| Individual calls | 10 | 10x round trips | \~236,000 |
| Multicall batch | 1 | 1 round trip | \~47,000 |
## Common Use Cases
1. **Portfolio dashboards** - Fetch all token balances in one call
2. **DEX interfaces** - Get reserves for multiple pairs
3. **NFT galleries** - Batch tokenURI calls
4. **Governance UIs** - Fetch voting power across protocols
## Related
* [ABI Encoding](/primitives/abi)
* [Hex Utilities](/primitives/hex)
* [Address Primitives](/primitives/address)
* [More Examples](/examples)
# Decode Contract Logs
Source: https://voltaire.tevm.sh/examples/contracts/decode-logs
Parse and decode ERC-20 Transfer and Approval events
Parse and decode ERC-20 Transfer and Approval events from raw log data.
```typescript theme={null}
import { Abi } from '@tevm/voltaire/Abi';
import { Hex } from '@tevm/voltaire/Hex';
import { EventLog } from '@tevm/voltaire/EventLog';
// Define ERC-20 event ABI
const erc20Abi = Abi([
{
type: "event",
name: "Transfer",
inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value", indexed: false }
]
},
{
type: "event",
name: "Approval",
inputs: [
{ type: "address", name: "owner", indexed: true },
{ type: "address", name: "spender", indexed: true },
{ type: "uint256", name: "value", indexed: false }
]
}
]);
// Raw log from eth_getLogs
// Transfer event: 100 tokens from 0x742d... to 0xa1b2...
const rawLog = {
data: "0x0000000000000000000000000000000000000000000000000000000000000064",
topics: [
// topic0: keccak256("Transfer(address,address,uint256)")
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
// topic1: indexed 'from' address (padded to 32 bytes)
"0x000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f251e3",
// topic2: indexed 'to' address (padded to 32 bytes)
"0x000000000000000000000000a1b2c3d4e5f6789012345678901234567890abcd"
]
};
// Decode the log using the ABI
const decoded = Abi.parseLogs(erc20Abi, [rawLog]);
// Result: [{ event: "Transfer", params: { from, to, value: 100n } }]
const { event, params } = decoded[0];
const { from, to, value } = params;
```
## How Event Logs Work
* **topic0**: Event signature hash (keccak256 of event signature)
* **topic1-3**: Indexed parameters (max 3, each 32 bytes)
* **data**: Non-indexed parameters (ABI encoded)
```typescript theme={null}
// Get event selector (topic0)
const transferEvent = erc20Abi.getEvent("Transfer");
const selector = Abi.Event.getSelector(transferEvent);
// 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
// Match logs by comparing topic0
function isTransferLog(log) {
const topic0 = Hex.toBytes(log.topics[0]);
for (let i = 0; i < 32; i++) {
if (topic0[i] !== selector[i]) return false;
}
return true;
}
```
This is a fully executable example. View the complete source with test assertions at [`examples/contracts/decode-logs.ts`](https://github.com/evmts/voltaire/blob/main/examples/contracts/decode-logs.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# ERC-20 Token Transfer
Source: https://voltaire.tevm.sh/examples/contracts/erc20-transfer
Build and send an ERC-20 token transfer transaction
Build and encode an ERC-20 token transfer transaction.
```typescript theme={null}
import { Abi } from '@tevm/voltaire/Abi';
import { Hex } from '@tevm/voltaire/Hex';
import { Address } from '@tevm/voltaire/Address';
// ERC-20 transfer function ABI
const erc20Abi = Abi([
{
type: "function",
name: "transfer",
stateMutability: "nonpayable",
inputs: [
{ type: "address", name: "to" },
{ type: "uint256", name: "amount" }
],
outputs: [{ type: "bool", name: "" }]
}
]);
// Encode transfer(address,uint256) function call
const recipient = "0x742d35cc6634c0532925a3b844bc9e7595f251e3";
const amount = 1000000000000000000n; // 1 token (18 decimals)
const calldata = erc20Abi.encode("transfer", [recipient, amount]);
// Result: 0xa9059cbb... (4-byte selector + ABI-encoded params)
// The calldata can be used in a transaction
const tx = {
to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC contract
data: Hex.fromBytes(calldata),
value: 0n
};
```
## Decode Calldata
Verify the encoded calldata by decoding it back:
```typescript theme={null}
// Decode the calldata to verify
const decoded = erc20Abi.decodeData(calldata);
// decoded.name = "transfer"
// decoded.params = ["0x742d35cc6634c0532925a3b844bc9e7595f251e3", 1000000000000000000n]
```
## Function Selector
The first 4 bytes are the function selector:
```typescript theme={null}
const transferFn = erc20Abi.getFunction("transfer");
const selector = Abi.Function.getSelector(transferFn);
// 0xa9059cbb = keccak256("transfer(address,uint256)")[0:4]
const signature = Abi.Function.getSignature(transferFn);
// "transfer(address,uint256)"
```
## Full Transaction with Signing
```typescript theme={null}
import { Secp256k1 } from '@tevm/voltaire/Secp256k1';
import { Transaction } from '@tevm/voltaire/Transaction';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Build unsigned EIP-1559 transaction
const unsignedTx = Transaction.fromEIP1559({
chainId: 1n,
nonce: 0n,
maxPriorityFeePerGas: 1000000000n,
maxFeePerGas: 50000000000n,
gasLimit: 100000n,
to: Address.from("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
value: 0n,
data: calldata
});
// Sign the transaction
const privateKey = Hex.toBytes("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
const serialized = Transaction.serialize(unsignedTx);
const hash = Keccak256(serialized);
const signature = Secp256k1.sign(hash, privateKey);
// Create signed transaction
const signedTx = Transaction.addSignature(unsignedTx, signature);
const rawTx = Transaction.serialize(signedTx);
// Ready to broadcast via eth_sendRawTransaction
```
This is a fully executable example. View the complete source with test assertions at [`examples/contracts/erc20-transfer.ts`](https://github.com/evmts/voltaire/blob/main/examples/contracts/erc20-transfer.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Read Contract State
Source: https://voltaire.tevm.sh/examples/contracts/read-contract
Call view functions to read contract state
Encode view function calls and decode return values to read contract state.
```typescript theme={null}
import { Abi } from '@tevm/voltaire/Abi';
import { Hex } from '@tevm/voltaire/Hex';
import { Address } from '@tevm/voltaire/Address';
// ERC-20 view functions
const erc20Abi = Abi([
{
type: "function",
name: "balanceOf",
stateMutability: "view",
inputs: [{ type: "address", name: "account" }],
outputs: [{ type: "uint256", name: "" }]
},
{
type: "function",
name: "name",
stateMutability: "view",
inputs: [],
outputs: [{ type: "string", name: "" }]
},
{
type: "function",
name: "symbol",
stateMutability: "view",
inputs: [],
outputs: [{ type: "string", name: "" }]
},
{
type: "function",
name: "decimals",
stateMutability: "view",
inputs: [],
outputs: [{ type: "uint8", name: "" }]
}
]);
// Encode balanceOf(address) call
const account = "0x742d35cc6634c0532925a3b844bc9e7595f251e3";
const calldata = erc20Abi.encode("balanceOf", [account]);
// Make eth_call (pseudo-code for RPC)
// const result = await provider.call({
// to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
// data: Hex.fromBytes(calldata)
// });
// Decode the return value
const returnData = Hex.toBytes(
"0x00000000000000000000000000000000000000000000000000000000000f4240"
);
const [balance] = erc20Abi.decode("balanceOf", returnData);
// balance = 1000000n (1 USDC with 6 decimals)
```
## Read Token Metadata
```typescript theme={null}
// Encode name() call (no arguments)
const nameCalldata = erc20Abi.encode("name", []);
// Decode string return value
const nameReturnData = Hex.toBytes(
"0x0000000000000000000000000000000000000000000000000000000000000020" +
"0000000000000000000000000000000000000000000000000000000000000008" +
"5553442054657468657200000000000000000000000000000000000000000000"
);
const [name] = erc20Abi.decode("name", nameReturnData);
// name = "USD Tether"
// Encode decimals() call
const decimalsCalldata = erc20Abi.encode("decimals", []);
// Decode uint8 return value
const decimalsReturnData = Hex.toBytes(
"0x0000000000000000000000000000000000000000000000000000000000000006"
);
const [decimals] = erc20Abi.decode("decimals", decimalsReturnData);
// decimals = 6n
```
## Low-Level Encoding
Use `Abi.Function` for more control:
```typescript theme={null}
// Get function from ABI
const balanceOfFn = erc20Abi.getFunction("balanceOf");
// Get function selector (first 4 bytes of keccak256 hash)
const selector = Abi.Function.getSelector(balanceOfFn);
// 0x70a08231 = keccak256("balanceOf(address)")[0:4]
// Encode just the parameters (without selector)
const params = Abi.Function.encodeParams(balanceOfFn, [account]);
// Decode return value
const result = Abi.Function.decodeResult(balanceOfFn, returnData);
// [1000000n]
```
## Batch Multiple Calls
Encode multiple view calls for multicall:
```typescript theme={null}
const calls = [
{ fn: "name", args: [] },
{ fn: "symbol", args: [] },
{ fn: "decimals", args: [] },
{ fn: "balanceOf", args: [account] }
];
const encodedCalls = calls.map(({ fn, args }) => ({
target: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
callData: Hex.fromBytes(erc20Abi.encode(fn, args))
}));
// Use with Multicall3 contract for batched reads
```
This is a fully executable example. View the complete source with test assertions at [`examples/contracts/read-contract.ts`](https://github.com/evmts/voltaire/blob/main/examples/contracts/read-contract.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Hello Voltaire
Source: https://voltaire.tevm.sh/examples/getting-started/hello-voltaire
Your first Voltaire example - hashing a simple string with Keccak256
Your first Voltaire example - hashing a simple string with Keccak256
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
import { Hex } from '@tevm/voltaire/Hex';
// Hash a string using Keccak256
const hash = Keccak256("Hello, Voltaire!");
// The hash is returned as a Uint8Array - convert to hex
const hexHash = Hex.fromBytes(hash);
```
This is a fully executable example. View the complete source with test assertions at [`examples/getting-started/hello-voltaire.ts`](https://github.com/evmts/voltaire/blob/main/examples/getting-started/hello-voltaire.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Hash String with Keccak256
Source: https://voltaire.tevm.sh/examples/hashing/keccak256-string
Hash a UTF-8 string using Keccak256 and get the result as hex
Hash a UTF-8 string using Keccak256 and get the result as hex
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
import { Hex } from '@tevm/voltaire/Hex';
// Hash a simple string
const message = "Hello, World!";
const hash = Keccak256(message);
const hexHash = Hex.fromBytes(hash);
// Hash an empty string
const emptyHash = Keccak256("");
const emptyHexHash = Hex.fromBytes(emptyHash);
```
This is a fully executable example. View the complete source with test assertions at [`examples/hashing/keccak256-string.ts`](https://github.com/evmts/voltaire/blob/main/examples/hashing/keccak256-string.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Hash String with SHA-256
Source: https://voltaire.tevm.sh/examples/hashing/sha256-hash
Hash a UTF-8 string using SHA-256 cryptographic hash function
Hash a UTF-8 string using SHA-256 cryptographic hash function
```typescript theme={null}
import { SHA256 } from '@tevm/voltaire/SHA256';
import { Hex } from '@tevm/voltaire/Hex';
// Hash a simple string
const message = "Hello, World!";
const hash = SHA256.hash(new TextEncoder().encode(message));
const hexHash = Hex.fromBytes(hash);
// Hash another string
const hash2 = SHA256.hash(new TextEncoder().encode("Voltaire"));
const hexHash2 = Hex.fromBytes(hash2);
```
This is a fully executable example. View the complete source with test assertions at [`examples/hashing/sha256-hash.ts`](https://github.com/evmts/voltaire/blob/main/examples/hashing/sha256-hash.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Concatenate Hex Strings
Source: https://voltaire.tevm.sh/examples/hex-and-bytes/hex-concatenate
Combine multiple hex strings into a single hex value
Combine multiple hex strings into a single hex value
```typescript theme={null}
import { Bytes } from '@tevm/voltaire/Bytes';
import * as Hex from '@tevm/voltaire/Hex';
// Create some hex strings
const hex1 = Hex.from("0x1234");
const hex2 = Hex.from("0x5678");
const hex3 = Hex.from("0xabcd");
// Concatenate them (variadic arguments)
const combined = Hex.concat(hex1, hex2, hex3);
// Can also concatenate with bytes converted to hex
const bytes = Bytes.from([0x01, 0x02, 0x03]);
const hexFromBytes = Hex.fromBytes(bytes);
const withBytes = Hex.concat(hex1, hexFromBytes);
// Concatenate just two
const twoValues = Hex.concat("0xaa", "0xbb");
```
This is a fully executable example. View the complete source with test assertions at [`examples/hex-and-bytes/hex-concatenate.ts`](https://github.com/evmts/voltaire/blob/main/examples/hex-and-bytes/hex-concatenate.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Hex Encoding and Decoding
Source: https://voltaire.tevm.sh/examples/hex-and-bytes/hex-encode-decode
Convert between hex strings and byte arrays using Voltaire's Hex primitive
Convert between hex strings and byte arrays using Voltaire's Hex primitive
```typescript theme={null}
import { Bytes } from '@tevm/voltaire/Bytes';
import * as Hex from '@tevm/voltaire/Hex';
// Encode bytes to hex string
const bytes = Bytes.from([72, 101, 108, 108, 111]); // "Hello" in bytes
const hexString = Hex.fromBytes(bytes);
// Decode hex string back to bytes
const decoded = Hex.toBytes(hexString);
// Create hex directly from string
const directHex = Hex.from("0x48656c6c6f");
```
This is a fully executable example. View the complete source with test assertions at [`examples/hex-and-bytes/hex-encode-decode.ts`](https://github.com/evmts/voltaire/blob/main/examples/hex-and-bytes/hex-encode-decode.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# BlockStream Indexer
Source: https://voltaire.tevm.sh/examples/indexing/blockstream-indexer
Build a reorg-safe ERC-20 transfer indexer using BlockStream
Build a production-ready ERC-20 transfer indexer that handles chain reorganizations correctly.
## Overview
This example demonstrates building an indexer that:
* Backfills historical Transfer events from a specific block range
* Watches for new blocks in real-time
* Handles chain reorgs by removing re-orged transfers and adding new ones
* Parses ERC-20 Transfer events from transaction receipts
## Full Example
```typescript theme={null}
import { BlockStream } from '@tevm/voltaire/BlockStream';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
import { Hex } from '@tevm/voltaire/Hex';
import { Address } from '@tevm/voltaire/Address';
// ERC-20 Transfer(address indexed from, address indexed to, uint256 value)
const TRANSFER_TOPIC = Hex.fromBytes(Keccak256('Transfer(address,address,uint256)'));
// Simple in-memory database
interface Transfer {
blockNumber: bigint;
blockHash: string;
transactionHash: string;
logIndex: number;
from: string;
to: string;
value: bigint;
tokenAddress: string;
}
const transfersByBlock = new Map();
const allTransfers: Transfer[] = [];
/**
* Parse ERC-20 Transfer events from a block's receipts
*/
function parseTransfers(block: {
header: { number: bigint; hash: Uint8Array };
receipts: readonly {
transactionHash: Uint8Array;
logs: readonly {
address: Uint8Array;
topics: readonly Uint8Array[];
data: Uint8Array;
logIndex?: number;
}[]
}[]
}): Transfer[] {
const transfers: Transfer[] = [];
const blockHash = Hex.fromBytes(block.header.hash);
for (const receipt of block.receipts) {
for (const log of receipt.logs) {
// Check if this is a Transfer event (topic0 matches)
if (log.topics.length < 3) continue;
const topic0 = Hex.fromBytes(log.topics[0]);
if (topic0 !== TRANSFER_TOPIC) continue;
// Parse indexed parameters from topics
// topic1 = from (address, padded to 32 bytes)
// topic2 = to (address, padded to 32 bytes)
const fromBytes = log.topics[1].slice(12); // Remove 12-byte padding
const toBytes = log.topics[2].slice(12);
// Parse value from data (uint256)
const value = Hex.toBigInt(Hex.fromBytes(log.data));
transfers.push({
blockNumber: block.header.number,
blockHash,
transactionHash: Hex.fromBytes(receipt.transactionHash),
logIndex: log.logIndex ?? 0,
from: Address.toChecksummed(Address.fromBytes(fromBytes)),
to: Address.toChecksummed(Address.fromBytes(toBytes)),
value,
tokenAddress: Address.toChecksummed(log.address),
});
}
}
return transfers;
}
/**
* Add transfers to the database
*/
function addTransfers(transfers: Transfer[]) {
for (const transfer of transfers) {
allTransfers.push(transfer);
const existing = transfersByBlock.get(transfer.blockHash) ?? [];
existing.push(transfer);
transfersByBlock.set(transfer.blockHash, existing);
}
}
/**
* Remove transfers from a re-orged block
*/
function removeTransfersByBlockHash(blockHash: string) {
const removed = transfersByBlock.get(blockHash) ?? [];
transfersByBlock.delete(blockHash);
// Remove from allTransfers array
for (const transfer of removed) {
const idx = allTransfers.findIndex(
t => t.blockHash === transfer.blockHash &&
t.transactionHash === transfer.transactionHash &&
t.logIndex === transfer.logIndex
);
if (idx !== -1) {
allTransfers.splice(idx, 1);
}
}
return removed;
}
/**
* Run the indexer
*/
async function runIndexer(provider: any) {
const stream = BlockStream({ provider });
// Configuration
const START_BLOCK = 18000000n;
const BACKFILL_TO = 18001000n; // Backfill first 1000 blocks
console.log(`Starting indexer from block ${START_BLOCK}`);
// Phase 1: Backfill historical blocks
console.log('Phase 1: Backfilling historical blocks...');
for await (const event of stream.backfill({
fromBlock: START_BLOCK,
toBlock: BACKFILL_TO,
include: 'receipts',
})) {
for (const block of event.blocks) {
const transfers = parseTransfers(block);
addTransfers(transfers);
if (transfers.length > 0) {
console.log(
`Block ${block.header.number}: ${transfers.length} transfers`
);
}
}
}
console.log(`Backfill complete. Total transfers: ${allTransfers.length}`);
// Phase 2: Watch for new blocks
console.log('Phase 2: Watching for new blocks...');
const controller = new AbortController();
// Handle graceful shutdown
process.on('SIGINT', () => {
console.log('\nShutting down...');
controller.abort();
});
try {
for await (const event of stream.watch({
signal: controller.signal,
include: 'receipts',
fromBlock: BACKFILL_TO + 1n,
})) {
if (event.type === 'reorg') {
// Handle chain reorganization
console.log(`Reorg detected! ${event.removed.length} blocks removed`);
// Remove transfers from re-orged blocks (newest to oldest)
for (const block of event.removed) {
const blockHash = Hex.fromBytes(block.hash);
const removed = removeTransfersByBlockHash(blockHash);
if (removed.length > 0) {
console.log(
` Removed ${removed.length} transfers from block ${block.number}`
);
}
}
// Add transfers from new chain (oldest to newest)
for (const block of event.added) {
const transfers = parseTransfers(block);
addTransfers(transfers);
if (transfers.length > 0) {
console.log(
` Added ${transfers.length} transfers from block ${block.header.number}`
);
}
}
console.log(`Reorg resolved. Total transfers: ${allTransfers.length}`);
} else {
// Normal new blocks
for (const block of event.blocks) {
const transfers = parseTransfers(block);
addTransfers(transfers);
console.log(
`Block ${block.header.number}: ${transfers.length} transfers ` +
`(total: ${allTransfers.length})`
);
}
}
}
} catch (error) {
if (error instanceof Error && error.name === 'AbortError') {
console.log('Indexer stopped');
} else {
throw error;
}
}
}
// Example usage with a provider
// const provider = { request: async ({ method, params }) => { ... } };
// runIndexer(provider);
```
## Key Patterns
### Computing Event Signatures
Use Keccak256 to compute the event topic hash:
```typescript theme={null}
const TRANSFER_TOPIC = Hex.fromBytes(
Keccak256('Transfer(address,address,uint256)')
);
// 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
```
### Parsing Indexed Parameters
ERC-20 Transfer has two indexed address parameters stored in topics:
```typescript theme={null}
// Topics layout:
// topic[0] = event signature hash
// topic[1] = from address (32 bytes, left-padded)
// topic[2] = to address (32 bytes, left-padded)
const fromBytes = log.topics[1].slice(12); // Remove 12-byte padding
const toBytes = log.topics[2].slice(12);
```
### Handling Reorgs
BlockStream emits a `reorg` event with both removed and added blocks:
```typescript theme={null}
if (event.type === 'reorg') {
// 1. Undo state for removed blocks (newest to oldest)
for (const block of event.removed) {
rollbackBlock(block);
}
// 2. Apply state for added blocks (oldest to newest)
for (const block of event.added) {
processBlock(block);
}
}
```
### Graceful Shutdown
Use `AbortController` to cleanly stop the watch loop:
```typescript theme={null}
const controller = new AbortController();
process.on('SIGINT', () => controller.abort());
for await (const event of stream.watch({ signal: controller.signal })) {
// Process events...
}
```
## Production Considerations
This example uses an in-memory database for simplicity. In production, you should:
* Use a persistent database (PostgreSQL, SQLite, etc.)
* Implement database transactions for atomicity during reorgs
* Add retry logic for RPC failures
* Implement checkpointing to resume from the last processed block
### Database Transactions
Wrap reorg handling in a database transaction:
```typescript theme={null}
if (event.type === 'reorg') {
await db.transaction(async (tx) => {
// Delete re-orged data
for (const block of event.removed) {
await tx.execute('DELETE FROM transfers WHERE block_hash = ?', [
Hex.fromBytes(block.hash)
]);
}
// Insert new data
for (const block of event.added) {
const transfers = parseTransfers(block);
for (const transfer of transfers) {
await tx.execute('INSERT INTO transfers ...', [...]);
}
}
});
}
```
### Checkpointing
Save progress to resume after restarts:
```typescript theme={null}
async function saveCheckpoint(blockNumber: bigint) {
await db.execute(
'UPDATE indexer_state SET last_block = ? WHERE id = 1',
[blockNumber.toString()]
);
}
async function loadCheckpoint(): Promise {
const result = await db.query(
'SELECT last_block FROM indexer_state WHERE id = 1'
);
return BigInt(result.last_block ?? START_BLOCK);
}
```
## Related
* [BlockStream API Reference](/primitives/block-stream/index)
* [EventLog Primitive](/primitives/event-log/index)
* [Keccak256 Hashing](/crypto/keccak256/index)
* [Address Primitive](/primitives/address/index)
* [More Examples](/examples)
# RLP Encode List
Source: https://voltaire.tevm.sh/examples/rlp/rlp-encode-list
Encode a list of values using Recursive Length Prefix (RLP) encoding
Encode a list of values using Recursive Length Prefix (RLP) encoding
```typescript theme={null}
import { Rlp } from '@tevm/voltaire/Rlp';
// Encode a simple list of strings
const list = ["dog", "cat", "bird"];
const encoded = Rlp.encode(list.map((s) => new TextEncoder().encode(s)));
const hexEncoded = Hex.fromBytes(encoded);
// Encode nested lists
const nestedList = [
new TextEncoder().encode("hello"),
[new TextEncoder().encode("world")],
];
const encodedNested = Rlp.encode(nestedList);
const hexNested = Hex.fromBytes(encodedNested);
// Encode empty list
const emptyList = Rlp.encode([]);
const hexEmpty = Hex.fromBytes(emptyList);
```
This is a fully executable example. View the complete source with test assertions at [`examples/rlp/rlp-encode-list.ts`](https://github.com/evmts/voltaire/blob/main/examples/rlp/rlp-encode-list.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# EIP-712 Permit Signature
Source: https://voltaire.tevm.sh/examples/signing/eip712-permit
Sign a Permit2 or ERC-2612 permit using EIP-712 typed data
Sign a Permit2 or ERC-2612 permit using EIP-712 typed data
```typescript theme={null}
import * as Secp256k1 from '@tevm/voltaire/Secp256k1';
import * as Keccak256 from '@tevm/voltaire/Keccak256';
import * as Hex from '@tevm/voltaire/Hex';
import * as Hash from '@tevm/voltaire/Hash';
// Private key (32 bytes)
const privateKey = Hex.toBytes(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
);
// EIP-712 Domain Separator
const domain = {
name: "Uniswap V2",
version: "1",
chainId: 1n,
verifyingContract: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
};
// Permit type hash: keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
const PERMIT_TYPEHASH = Hash.keccak256String(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
);
// EIP-712 domain type hash
const EIP712_DOMAIN_TYPEHASH = Hash.keccak256String(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
// Permit message data
const permit = {
owner: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
spender: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
value: 1000000000000000000n, // 1 token (18 decimals)
nonce: 0n,
deadline: 1893456000n, // Far future timestamp
};
// Helper: ABI encode an address (20 bytes -> 32 bytes, left-padded)
function encodeAddress(addr: string): Uint8Array {
const bytes = Hex.toBytes(addr);
const padded = new Uint8Array(32);
padded.set(bytes, 12); // Left-pad to 32 bytes
return padded;
}
// Helper: ABI encode a uint256
function encodeUint256(value: bigint): Uint8Array {
const bytes = new Uint8Array(32);
let v = value;
for (let i = 31; i >= 0; i--) {
bytes[i] = Number(v & 0xffn);
v >>= 8n;
}
return bytes;
}
// Helper: Concatenate Uint8Arrays
function concat(...arrays: Uint8Array[]): Uint8Array {
const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
const result = new Uint8Array(totalLength);
let offset = 0;
for (const arr of arrays) {
result.set(arr, offset);
offset += arr.length;
}
return result;
}
// Step 1: Hash the domain separator
// domainSeparator = keccak256(abi.encode(
// EIP712_DOMAIN_TYPEHASH,
// keccak256(name),
// keccak256(version),
// chainId,
// verifyingContract
// ))
const domainSeparator = Keccak256.hash(concat(
EIP712_DOMAIN_TYPEHASH,
Hash.keccak256String(domain.name),
Hash.keccak256String(domain.version),
encodeUint256(domain.chainId),
encodeAddress(domain.verifyingContract),
));
// Step 2: Hash the struct data
// structHash = keccak256(abi.encode(
// PERMIT_TYPEHASH, owner, spender, value, nonce, deadline
// ))
const structHash = Keccak256.hash(concat(
PERMIT_TYPEHASH,
encodeAddress(permit.owner),
encodeAddress(permit.spender),
encodeUint256(permit.value),
encodeUint256(permit.nonce),
encodeUint256(permit.deadline),
));
// Step 3: Create EIP-712 signing hash
// digest = keccak256("\x19\x01" + domainSeparator + structHash)
const prefix = new Uint8Array([0x19, 0x01]);
const digest = Keccak256.hash(concat(prefix, domainSeparator, structHash));
// Step 4: Sign the digest
const signature = Secp256k1.signHash(digest, privateKey);
// Step 5: Extract r, s, v components
const r = Hex.fromBytes(signature.r);
const s = Hex.fromBytes(signature.s);
const v = signature.v;
// Ready for permit() call: token.permit(owner, spender, value, deadline, v, r, s)
```
This is a fully executable example. View the complete source with test assertions at [`examples/signing/eip712-permit.ts`](https://github.com/evmts/voltaire/blob/main/examples/signing/eip712-permit.ts).
## EIP-712 Structure
EIP-712 defines a standard for typed structured data hashing and signing:
1. **Domain Separator** - Uniquely identifies the application (contract name, version, chain, address)
2. **Type Hash** - keccak256 of the type string (e.g., `"Permit(address owner,...)"`)
3. **Struct Hash** - keccak256 of the encoded struct data with type hash
4. **Digest** - `keccak256("\x19\x01" || domainSeparator || structHash)`
The `\x19\x01` prefix prevents collision with `eth_sign` messages.
## Related
* [Verify Signature](/examples/signing/verify-signature)
* [Personal Sign](/examples/signing/personal-sign)
* [API Reference](/primitives)
# Personal Sign Message
Source: https://voltaire.tevm.sh/examples/signing/personal-sign
Sign a message using Ethereum personal_sign (EIP-191) format
Sign a message using Ethereum personal\_sign (EIP-191) format
```typescript theme={null}
import { Secp256k1 } from '@tevm/voltaire/Secp256k1';
import { Hex } from '@tevm/voltaire/Hex';
// Create a private key (32 bytes)
const privateKey = Hex.toBytes(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
);
// Message to sign
const message = "Hello, Ethereum!";
// Personal sign format: "\x19Ethereum Signed Message:\n" + len(message) + message
const prefix = "\x19Ethereum Signed Message:\n";
const messageBytes = new TextEncoder().encode(message);
const prefixedMessage = new TextEncoder().encode(
prefix + messageBytes.length + message,
);
// Hash the prefixed message
const messageHash = Keccak256(prefixedMessage);
// Sign the hash
const signature = Secp256k1.sign(messageHash, privateKey);
```
This is a fully executable example. View the complete source with test assertions at [`examples/signing/personal-sign.ts`](https://github.com/evmts/voltaire/blob/main/examples/signing/personal-sign.ts).
## Related
* [API Reference](/primitives)
* [More Examples](/examples)
# Verify Signature
Source: https://voltaire.tevm.sh/examples/signing/verify-signature
Verify a signed message and recover the signer address
Verify a signed message and recover the signer address
```typescript theme={null}
import * as Secp256k1 from '@tevm/voltaire/Secp256k1';
import * as Keccak256 from '@tevm/voltaire/Keccak256';
import * as Hex from '@tevm/voltaire/Hex';
import * as Address from '@tevm/voltaire/Address';
// The original message that was signed
const message = "Hello, Ethereum!";
// Signature components (from a previous signing operation)
const signatureHex = {
r: "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf3305e9bc3b1e9b6a1e3e8e2a",
s: "0x1c9d7a8e7f3b2c1d0e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d",
v: 28,
};
// Expected signer address
const expectedSigner = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
// Step 1: Reconstruct the signed message hash (personal_sign format)
const prefix = "\x19Ethereum Signed Message:\n";
const messageBytes = new TextEncoder().encode(message);
const prefixedMessage = new TextEncoder().encode(
prefix + messageBytes.length + message,
);
const messageHash = Keccak256.hash(prefixedMessage);
// Step 2: Prepare signature for recovery
const signature = {
r: Hex.toBytes(signatureHex.r),
s: Hex.toBytes(signatureHex.s),
v: signatureHex.v,
};
// Step 3: Recover the public key from the signature
const recoveredPublicKey = Secp256k1.recoverPublicKeyFromHash(
signature,
messageHash,
);
// Step 4: Derive address from public key (last 20 bytes of keccak256(pubkey))
const publicKeyHash = Keccak256.hash(recoveredPublicKey);
const recoveredAddress = Address.fromBytes(publicKeyHash.slice(12));
// Step 5: Compare with expected signer
const isValid = Address.equals(
recoveredAddress,
Address.fromHex(expectedSigner),
);
```
This is a fully executable example. View the complete source with test assertions at [`examples/signing/verify-signature.ts`](https://github.com/evmts/voltaire/blob/main/examples/signing/verify-signature.ts).
## Complete Verification Flow
```typescript theme={null}
import * as Secp256k1 from '@tevm/voltaire/Secp256k1';
import * as Keccak256 from '@tevm/voltaire/Keccak256';
import * as Hex from '@tevm/voltaire/Hex';
import * as Address from '@tevm/voltaire/Address';
import * as PrivateKey from '@tevm/voltaire/PrivateKey';
// Sign a message (for demonstration)
const privateKey = PrivateKey.from(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
);
const message = "Verify me!";
// Create personal_sign hash
const prefix = "\x19Ethereum Signed Message:\n";
const messageBytes = new TextEncoder().encode(message);
const prefixedMessage = new TextEncoder().encode(
prefix + messageBytes.length + message,
);
const messageHash = Keccak256.hash(prefixedMessage);
// Sign
const signature = Secp256k1.signHash(messageHash, privateKey);
// Recover and verify
const recoveredPubKey = Secp256k1.recoverPublicKeyFromHash(
signature,
messageHash,
);
const recoveredAddr = Address.fromPublicKey(recoveredPubKey);
const signerAddr = Address.fromPrivateKey(privateKey);
// Verify signer matches
const verified = Address.equals(recoveredAddr, signerAddr);
```
## Verifying Raw Hash Signatures
For signatures over raw 32-byte hashes (not personal\_sign format):
```typescript theme={null}
// If message is already a 32-byte hash
const rawHash = Hex.toBytes("0x4e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd41");
// Recover directly without personal_sign prefix
const recoveredPublicKey = Secp256k1.recoverPublicKeyFromHash(
signature,
rawHash,
);
const recoveredAddress = Address.fromPublicKey(recoveredPublicKey);
```
## Related
* [Personal Sign](/examples/signing/personal-sign)
* [EIP-712 Permit](/examples/signing/eip712-permit)
* [API Reference](/primitives)
# Build EIP-1559 Transaction
Source: https://voltaire.tevm.sh/examples/transactions/build-eip1559-transaction
Create and sign an EIP-1559 transaction with priority fees
Create and sign an EIP-1559 transaction with priority fees
```typescript theme={null}
import { Transaction } from '@tevm/voltaire/Transaction';
import { Secp256k1 } from '@tevm/voltaire/Secp256k1';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Private key (32 bytes) - NEVER use this in production
const privateKey = Hex.toBytes(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
);
// Create unsigned EIP-1559 transaction
const unsignedTx = {
type: Transaction.Type.EIP1559,
chainId: 1n, // Ethereum mainnet
nonce: 0n,
maxPriorityFeePerGas: 2_000_000_000n, // 2 gwei tip
maxFeePerGas: 100_000_000_000n, // 100 gwei max
gasLimit: 21000n,
to: Address.from("0x70997970C51812dc3A010C7d01b50e0d17dc79C8"),
value: 1_000_000_000_000_000_000n, // 1 ETH in wei
data: new Uint8Array(),
accessList: [],
};
// Get signing hash (keccak256 of RLP-encoded transaction)
const signingHash = Transaction.EIP1559.getSigningHash(unsignedTx);
// Sign the hash with private key
const signature = Secp256k1.sign(signingHash, privateKey);
// Combine transaction with signature
const signedTx = Transaction.EIP1559.TransactionEIP1559({
...unsignedTx,
yParity: signature.v - 27, // Convert v (27/28) to yParity (0/1)
r: signature.r,
s: signature.s,
});
// Serialize to RLP for broadcasting
const serialized = Transaction.EIP1559.serialize(signedTx);
const signedTxHex = Hex.fromBytes(serialized);
// Verify we can recover the sender
const sender = Transaction.EIP1559.getSender(signedTx);
const senderHex = Address.toChecksummed(sender);
```
This is a fully executable example. View the complete source with test assertions at [`examples/transactions/build-eip1559-transaction.ts`](https://github.com/evmts/voltaire/blob/main/examples/transactions/build-eip1559-transaction.ts).
## Related
* [Decode Transaction](/examples/transactions/decode-transaction)
* [Estimate Gas](/examples/transactions/estimate-gas)
* [Transaction API Reference](/primitives/transaction)
# Decode Transaction
Source: https://voltaire.tevm.sh/examples/transactions/decode-transaction
Parse and decode a raw signed transaction
Parse and decode a raw signed transaction
```typescript theme={null}
import { Transaction } from '@tevm/voltaire/Transaction';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
// Raw signed EIP-1559 transaction (type 0x02)
const rawTxHex =
"0x02f8730180843b9aca008504a817c80082520894" +
"70997970c51812dc3a010c7d01b50e0d17dc79c8" +
"880de0b6b3a764000080c001a0" +
"8c5d1c1e1d7a3d0b2d9d5c5e5f5a5b5c5d5e5f5a5b5c5d5e5f5a5b5c5d5e5f5a" +
"a0" +
"1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b";
// Convert hex to bytes
const rawTxBytes = Hex.toBytes(rawTxHex);
// Deserialize - automatically detects transaction type
const tx = Transaction.deserialize(rawTxBytes);
// Extract transaction details based on type
if (tx.type === Transaction.Type.EIP1559) {
// Type 2 (EIP-1559) specific fields
const chainId = tx.chainId;
const nonce = tx.nonce;
const maxPriorityFeePerGas = tx.maxPriorityFeePerGas;
const maxFeePerGas = tx.maxFeePerGas;
const gasLimit = tx.gasLimit;
const to = tx.to ? Address.toChecksummed(tx.to) : null;
const value = tx.value;
const data = Hex.fromBytes(tx.data);
// Signature components
const yParity = tx.yParity;
const r = Hex.fromBytes(tx.r);
const s = Hex.fromBytes(tx.s);
// Recover sender from signature
const sender = Transaction.getSender(tx);
const senderAddress = Address.toChecksummed(sender);
}
// Handle legacy transactions (type 0)
if (tx.type === Transaction.Type.Legacy) {
const gasPrice = tx.gasPrice;
const v = tx.v;
const sender = Transaction.getSender(tx);
}
// Handle EIP-2930 transactions (type 1)
if (tx.type === Transaction.Type.EIP2930) {
const accessList = tx.accessList;
const sender = Transaction.getSender(tx);
}
// Compute transaction hash
const txHash = Transaction.hash(tx);
const txHashHex = Hex.fromBytes(txHash);
```
This is a fully executable example. View the complete source with test assertions at [`examples/transactions/decode-transaction.ts`](https://github.com/evmts/voltaire/blob/main/examples/transactions/decode-transaction.ts).
## Related
* [Build EIP-1559 Transaction](/examples/transactions/build-eip1559-transaction)
* [RLP Encode List](/examples/rlp/rlp-encode-list)
* [Transaction API Reference](/primitives/transaction)
# Estimate Gas
Source: https://voltaire.tevm.sh/examples/transactions/estimate-gas
Estimate gas for a transaction before sending
Estimate gas for a transaction before sending
```typescript theme={null}
import { Transaction } from '@tevm/voltaire/Transaction';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
import { Wei, Gwei, Ether } from '@tevm/voltaire/Denomination';
// RPC helper (using native fetch)
async function rpc(url: string, method: string, params: unknown[]) {
const response = await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
});
const json = await response.json();
if (json.error) throw new Error(json.error.message);
return json.result;
}
const RPC_URL = "https://eth.llamarpc.com";
// Create call object for gas estimation
const from = Address.from("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
const to = Address.from("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
const value = Wei.from(1_000_000_000_000_000_000n); // 1 ETH
const callObject = {
from: Hex.fromBytes(from),
to: Hex.fromBytes(to),
value: Hex.fromNumber(Wei.toU256(value)),
data: "0x", // No calldata for simple transfer
};
// Estimate gas using eth_estimateGas
const estimatedGasHex = await rpc(RPC_URL, "eth_estimateGas", [callObject]);
const estimatedGas = BigInt(estimatedGasHex);
// Add 20% buffer for safety
const gasWithBuffer = (estimatedGas * 120n) / 100n;
// Fetch current gas prices using eth_gasPrice and eth_maxPriorityFeePerGas
const [gasPriceHex, feeHistoryResult] = await Promise.all([
rpc(RPC_URL, "eth_gasPrice", []),
rpc(RPC_URL, "eth_feeHistory", [1, "latest", [50]]),
]);
// Parse gas price and base fee
const gasPrice = BigInt(gasPriceHex);
const baseFee = BigInt(feeHistoryResult.baseFeePerGas[0]);
// Calculate priority fee (tip) from fee history
const priorityFee = 2_000_000_000n; // 2 gwei default tip
// Calculate max fee per gas (base fee * 2 + priority fee for safety)
const maxFeePerGas = baseFee * 2n + priorityFee;
const maxPriorityFeePerGas = priorityFee;
// Calculate total cost in wei
const maxCostWei = Wei.from(gasWithBuffer * maxFeePerGas);
const maxCostGwei = Gwei.fromWei(maxCostWei);
const maxCostEther = Ether.fromWei(maxCostWei);
// Effective cost at current base fee
const effectiveCostWei = Wei.from(gasWithBuffer * (baseFee + priorityFee));
// Build the transaction with estimated values
const txParams = {
type: Transaction.Type.EIP1559,
chainId: 1n,
nonce: 0n,
maxPriorityFeePerGas,
maxFeePerGas,
gasLimit: gasWithBuffer,
to,
value: Wei.toU256(value),
data: new Uint8Array(),
accessList: [],
};
console.log("Gas Estimation Results:");
console.log(` Estimated gas: ${estimatedGas}`);
console.log(` Gas with buffer: ${gasWithBuffer}`);
console.log(` Base fee: ${Gwei.fromWei(Wei.from(baseFee))} gwei`);
console.log(` Priority fee: ${Gwei.fromWei(Wei.from(priorityFee))} gwei`);
console.log(` Max fee per gas: ${Gwei.fromWei(Wei.from(maxFeePerGas))} gwei`);
console.log(` Max cost: ${maxCostEther} ETH`);
```
This is a fully executable example. View the complete source with test assertions at [`examples/transactions/estimate-gas.ts`](https://github.com/evmts/voltaire/blob/main/examples/transactions/estimate-gas.ts).
## Related
* [Build EIP-1559 Transaction](/examples/transactions/build-eip1559-transaction)
* [Denomination API Reference](/primitives/denomination)
* [Transaction API Reference](/primitives/transaction)
# Generate Wallet from Mnemonic
Source: https://voltaire.tevm.sh/examples/wallet/generate-wallet
Generate HD wallet addresses from a BIP-39 mnemonic phrase
Generate HD wallet addresses from a BIP-39 mnemonic phrase using BIP-32/BIP-44.
```typescript theme={null}
import { Bip39 } from '@tevm/voltaire/Bip39';
import { HDWallet } from '@tevm/voltaire/HDWallet';
import { Secp256k1 } from '@tevm/voltaire/Secp256k1';
import { Address } from '@tevm/voltaire/Address';
// Generate a new 24-word mnemonic (256 bits of entropy)
const mnemonic = Bip39.generateMnemonic(256);
// Or use existing mnemonic
// const mnemonic = "abandon abandon abandon ... about";
// Validate the mnemonic
const isValid = Bip39.validateMnemonic(mnemonic);
if (!isValid) throw new Error("Invalid mnemonic");
// Derive 512-bit seed from mnemonic (optional passphrase)
const seed = await Bip39.mnemonicToSeed(mnemonic);
// With passphrase: await Bip39.mnemonicToSeed(mnemonic, "my secret passphrase");
// Create HD wallet root from seed
const root = HDWallet.fromSeed(seed);
// Derive multiple Ethereum addresses using BIP-44 path
// m/44'/60'/0'/0/x where x is the address index
const addresses = [];
for (let i = 0; i < 5; i++) {
const hdKey = HDWallet.deriveEthereum(root, 0, i);
const privateKey = HDWallet.getPrivateKey(hdKey);
if (!privateKey) continue;
const publicKey = Secp256k1.derivePublicKey(privateKey);
const address = Address.fromPublicKey(publicKey);
addresses.push({
path: `m/44'/60'/0'/0/${i}`,
address: Address.toChecksummed(address),
privateKey,
});
}
// Alternative: derive with explicit path
const customPath = "m/44'/60'/0'/0/0";
const hdKey = HDWallet.derivePath(root, customPath);
const privateKey = HDWallet.getPrivateKey(hdKey);
```
For 12-word mnemonics, use `Bip39.generateMnemonic(128)` instead of 256.
## Related
* [Import Private Key](/examples/wallet/import-private-key)
* [HDWallet API Reference](/crypto/hdwallet)
* [Bip39 API Reference](/crypto/bip39)
* [More Examples](/examples)
# Import Private Key
Source: https://voltaire.tevm.sh/examples/wallet/import-private-key
Import a private key and derive the public address
Import a hex private key and derive the corresponding Ethereum address.
```typescript theme={null}
import { Secp256k1 } from '@tevm/voltaire/Secp256k1';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
// Parse hex private key to bytes
const privateKeyHex = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
const privateKey = Hex.toBytes(privateKeyHex);
// Validate private key is on secp256k1 curve
if (!Secp256k1.isValidPrivateKey(privateKey)) {
throw new Error("Invalid private key");
}
// Derive uncompressed public key (65 bytes: 04 || x || y)
const publicKey = Secp256k1.derivePublicKey(privateKey);
// Derive Ethereum address from public key
// Address = last 20 bytes of keccak256(publicKey[1:])
const address = Address.fromPublicKey(publicKey);
const checksummed = Address.toChecksummed(address);
// Alternatively, derive directly from private key
const addressDirect = Address.fromPrivateKey(privateKey);
```
Never share or expose private keys. Store them securely.
## Related
* [Generate Wallet from Mnemonic](/examples/wallet/generate-wallet)
* [Derive Address from Private Key](/examples/addresses/address-from-private-key)
* [Secp256k1 API Reference](/crypto/secp256k1)
* [More Examples](/examples)
# GasCosts
Source: https://voltaire.tevm.sh/generated-api/GasCosts
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / GasCosts
# GasCosts
Gas cost constants for EVM operations
Provides comprehensive gas cost constants for:
* EVM opcodes
* Transaction types
* Storage operations
* Block limits
## Variables
### BLOCK\_GAS\_LIMITS
> `const` **BLOCK\_GAS\_LIMITS**: `object`
Defined in: [src/primitives/GasCosts/constants.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasCosts/constants.ts#L113)
Block gas limit constants
#### Type Declaration
##### MAINNET
> `readonly` **MAINNET**: `30000000n` = `30_000_000n`
Typical mainnet block gas limit (30M)
##### MINIMUM
> `readonly` **MINIMUM**: `5000n` = `5000n`
Minimum gas limit per EIP-1559
***
### GAS\_COSTS
> `const` **GAS\_COSTS**: `object`
Defined in: [src/primitives/GasCosts/constants.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasCosts/constants.ts#L9)
Gas cost constants for EVM operations
Based on Yellow Paper Appendix G and various EIPs
#### Type Declaration
##### BALANCE
> `readonly` **BALANCE**: `2600n` = `2600n`
Cold BALANCE access (EIP-2929)
##### BASE
> `readonly` **BASE**: `2n` = `2n`
Base cost for most opcodes
##### BLOCKHASH
> `readonly` **BLOCKHASH**: `20n` = `20n`
BLOCKHASH opcode
##### CALL
> `readonly` **CALL**: `100n` = `100n`
Base gas for message call
##### CALL\_STIPEND
> `readonly` **CALL\_STIPEND**: `2300n` = `2300n`
Gas stipend provided to called contract when value > 0
##### CALL\_VALUE
> `readonly` **CALL\_VALUE**: `9000n` = `9000n`
Additional cost for non-zero value transfer
##### CALLDATA\_NONZERO
> `readonly` **CALLDATA\_NONZERO**: `16n` = `16n`
Non-zero byte in calldata
##### CALLDATA\_ZERO
> `readonly` **CALLDATA\_ZERO**: `4n` = `4n`
Zero byte in calldata (cheaper)
##### COLD\_ACCOUNT\_ACCESS
> `readonly` **COLD\_ACCOUNT\_ACCESS**: `2600n` = `2600n`
Cold account access cost (EIP-2929)
##### COPY
> `readonly` **COPY**: `3n` = `3n`
Memory/storage copy cost per word
##### CREATE
> `readonly` **CREATE**: `32000n` = `32000n`
Contract creation base cost
##### EXP
> `readonly` **EXP**: `10n` = `10n`
EXP base cost
##### EXP\_BYTE
> `readonly` **EXP\_BYTE**: `50n` = `50n`
EXP per byte cost
##### EXTCODECOPY
> `readonly` **EXTCODECOPY**: `2600n` = `2600n`
Cold EXTCODECOPY access (EIP-2929)
##### HIGH
> `readonly` **HIGH**: `10n` = `10n`
High cost operations
##### JUMPDEST
> `readonly` **JUMPDEST**: `1n` = `1n`
JUMPDEST cost
##### LOG
> `readonly` **LOG**: `375n` = `375n`
LOG0 base cost
##### LOG\_DATA
> `readonly` **LOG\_DATA**: `8n` = `8n`
Cost per byte of LOG data
##### LOG\_TOPIC
> `readonly` **LOG\_TOPIC**: `375n` = `375n`
Cost per LOG topic
##### LOW
> `readonly` **LOW**: `5n` = `5n`
Low cost operations (MUL, DIV, etc)
##### MEMORY
> `readonly` **MEMORY**: `3n` = `3n`
Memory expansion cost per word
##### MID
> `readonly` **MID**: `8n` = `8n`
Mid cost operations
##### SELFDESTRUCT
> `readonly` **SELFDESTRUCT**: `5000n` = `5000n`
SELFDESTRUCT cost (no refund post-London)
##### SHA3
> `readonly` **SHA3**: `30n` = `30n`
SHA3/KECCAK256 base cost
##### SHA3\_WORD
> `readonly` **SHA3\_WORD**: `6n` = `6n`
SHA3/KECCAK256 per word cost
##### SLOAD
> `readonly` **SLOAD**: `2100n` = `2100n`
Cold SLOAD cost (EIP-2929)
##### SLOAD\_WARM
> `readonly` **SLOAD\_WARM**: `100n` = `100n`
Cost of SLOAD from warm storage
##### SSTORE\_CLEAR
> `readonly` **SSTORE\_CLEAR**: `15000n` = `15000n`
SSTORE clear refund (pre-London: 15000, post-London: none)
##### SSTORE\_RESET
> `readonly` **SSTORE\_RESET**: `5000n` = `5000n`
SSTORE from non-zero to non-zero
##### SSTORE\_SET
> `readonly` **SSTORE\_SET**: `20000n` = `20000n`
SSTORE from zero to non-zero (most expensive)
##### TRANSACTION
> `readonly` **TRANSACTION**: `21000n` = `21000n`
Base transaction cost (21000 gas)
##### VERY\_LOW
> `readonly` **VERY\_LOW**: `3n` = `3n`
Very low cost operations (ADD, SUB, etc)
##### WARM\_STORAGE\_READ
> `readonly` **WARM\_STORAGE\_READ**: `100n` = `100n`
Warm storage access cost (EIP-2929)
#### See
* [https://ethereum.github.io/yellowpaper/paper.pdf](https://ethereum.github.io/yellowpaper/paper.pdf)
* EIP-2929 (Gas cost increases for state access)
* EIP-3529 (Refund reduction)
***
### TRANSACTION\_COSTS
> `const` **TRANSACTION\_COSTS**: `object`
Defined in: [src/primitives/GasCosts/constants.ts:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasCosts/constants.ts#L124)
Transaction type gas costs
#### Type Declaration
##### CONTRACT\_DEPLOY
> `readonly` **CONTRACT\_DEPLOY**: `32000n` = `32000n`
Contract deployment base
##### ERC20\_TRANSFER
> `readonly` **ERC20\_TRANSFER**: `65000n` = `65000n`
Typical ERC20 transfer cost
##### SIMPLE\_TRANSFER
> `readonly` **SIMPLE\_TRANSFER**: `21000n` = `21000n`
Minimum gas for simple ETH transfer
##### UNISWAP\_SWAP
> `readonly` **UNISWAP\_SWAP**: `150000n` = `150000n`
Typical Uniswap V2 swap cost
# HDWallet
Source: https://voltaire.tevm.sh/generated-api/HDWallet
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / HDWallet
# HDWallet
HD Wallet (BIP-32) - Hierarchical Deterministic Key Derivation
## Type Aliases
### HDWallet
> **HDWallet** = `HDKey` & `object`
Defined in: [src/crypto/HDWallet/ExtendedKeyType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/HDWallet/ExtendedKeyType.ts#L10)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ExtendedKey"`
##### calculateCreate2Address()
> **calculateCreate2Address**(`salt`, `initCode`): `Uint8Array`
###### Parameters
###### salt
`Uint8Array`
###### initCode
`Uint8Array`
###### Returns
`Uint8Array`
##### calculateCreateAddress()
> **calculateCreateAddress**(`nonce`): `Uint8Array`
###### Parameters
###### nonce
`bigint`
###### Returns
`Uint8Array`
##### canDeriveHardened()
> **canDeriveHardened**(`this`): `boolean`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`boolean`
##### deriveChild()
> **deriveChild**(`this`, `index`): [`HDWallet`](#hdwallet)
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### index
`number`
###### Returns
[`HDWallet`](#hdwallet)
##### derivePath()
> **derivePath**(`this`, `path`): [`HDWallet`](#hdwallet)
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### path
`string`
###### Returns
[`HDWallet`](#hdwallet)
##### getChainCode()
> **getChainCode**(`this`): `ChainCode`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`ChainCode`
##### getPrivateKey()
> **getPrivateKey**(`this`): `PrivateKey`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`PrivateKey`
##### getPublicKey()
> **getPublicKey**(`this`): `PublicKey`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`PublicKey`
##### toExtendedPrivateKey()
> **toExtendedPrivateKey**(`this`): `string`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`string`
##### toExtendedPublicKey()
> **toExtendedPublicKey**(`this`): `string`
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
`string`
##### toPublic()
> **toPublic**(`this`): [`HDWallet`](#hdwallet)
###### Parameters
###### this
[`HDWallet`](#hdwallet)
###### Returns
[`HDWallet`](#hdwallet)
## Variables
### HDWallet
> `const` **HDWallet**: `object`
Defined in: [src/crypto/HDWallet/HDWallet.js:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/HDWallet/HDWallet.js#L91)
HDWallet namespace - collection of HD wallet operations
#### Type Declaration
##### BIP44\_PATH
> **BIP44\_PATH**: `Readonly`\<\{ `BTC`: (`account?`, `index?`) => `string`; `ETH`: (`account?`, `index?`) => `string`; }>
Standard BIP-44 path template functions.
Format: m / purpose' / coin\_type' / account' / change / address\_index
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { BIP44_PATH } from './crypto/HDWallet/constants.js';
const ethPath = BIP44_PATH.ETH(0, 0); // "m/44'/60'/0'/0/0"
const btcPath = BIP44_PATH.BTC(0, 1); // "m/44'/0'/0'/0/1"
```
##### canDeriveHardened()
> **canDeriveHardened**: (`key`) => `boolean`
Check if extended key can derive hardened children.
Only keys with private key material can derive hardened paths.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key to check
###### Returns
`boolean`
True if key has private key and can derive hardened children, false if public-only
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
if (HDWallet.canDeriveHardened(key)) {
const hardened = HDWallet.deriveChild(key, HDWallet.HARDENED_OFFSET);
}
```
##### CoinType
> **CoinType**: `Readonly`\<\{ `BTC`: `0`; `BTC_TESTNET`: `1`; `ETC`: `61`; `ETH`: `60`; }>
Standard BIP-44 coin type constants.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { CoinType } from './crypto/HDWallet/constants.js';
console.log(CoinType.ETH); // 60
```
##### deriveBitcoin()
> **deriveBitcoin**: (`key`, `account?`, `index?`) => [`HDWallet`](#hdwallet)
Derive Bitcoin address key using BIP-44 standard path.
Path format: m/44'/0'/account'/0/index
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Root HD key with private key
###### account?
`number` = `0`
BIP-44 account index (default: 0)
###### index?
`number` = `0`
Address index (default: 0)
###### Returns
[`HDWallet`](#hdwallet)
Derived extended key for Bitcoin address
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If derivation path is invalid or derivation fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const root = HDWallet.fromSeed(seed);
const btcKey = HDWallet.deriveBitcoin(root, 0, 0); // m/44'/0'/0'/0/0
```
##### deriveChild()
> **deriveChild**: (`key`, `index`) => [`HDWallet`](#hdwallet)
Derive child key by index using BIP-32.
Supports both normal and hardened derivation.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Parent extended key
###### index
`number`
Child index (add HARDENED\_OFFSET for hardened derivation)
###### Returns
[`HDWallet`](#hdwallet)
Derived child extended key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If derivation fails or index is invalid
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
// Normal derivation
const child = HDWallet.deriveChild(key, 0);
// Hardened derivation
const hardened = HDWallet.deriveChild(key, HDWallet.HARDENED_OFFSET + 0);
```
##### deriveEthereum()
> **deriveEthereum**: (`key`, `account?`, `index?`) => [`HDWallet`](#hdwallet)
Derive Ethereum address key using BIP-44 standard path.
Path format: m/44'/60'/account'/0/index
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Root HD key with private key
###### account?
`number` = `0`
BIP-44 account index (default: 0)
###### index?
`number` = `0`
Address index (default: 0)
###### Returns
[`HDWallet`](#hdwallet)
Derived extended key for Ethereum address
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If derivation path is invalid or derivation fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const root = HDWallet.fromSeed(seed);
const ethKey0 = HDWallet.deriveEthereum(root, 0, 0); // m/44'/60'/0'/0/0
const ethKey1 = HDWallet.deriveEthereum(root, 0, 1); // m/44'/60'/0'/0/1
```
##### derivePath()
> **derivePath**: (`key`, `path`) => [`HDWallet`](#hdwallet)
Derive child key using BIP-32 derivation path.
Supports hierarchical paths with hardened (') and normal derivation.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Parent extended key
###### path
`string`
BIP-32 derivation path (e.g., "m/44'/60'/0'/0/0")
###### Returns
[`HDWallet`](#hdwallet)
Derived child extended key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If path format is invalid or derivation fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const root = HDWallet.fromSeed(seed);
const child = HDWallet.derivePath(root, "m/44'/60'/0'/0/0");
```
##### fromExtendedKey()
> **fromExtendedKey**: (`xprv`) => [`HDWallet`](#hdwallet)
Create HD key from extended private key string.
Deserializes base58-encoded xprv key.
###### Parameters
###### xprv
`string`
Base58-encoded extended private key (xprv...)
###### Returns
[`HDWallet`](#hdwallet)
Extended key with private key material
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If extended key format is invalid or decoding fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const key = HDWallet.fromExtendedKey("xprv9s21ZrQH143K3...");
```
##### fromPublicExtendedKey()
> **fromPublicExtendedKey**: (`xpub`) => [`HDWallet`](#hdwallet)
Create HD key from extended public key string.
Cannot derive hardened children from public-only keys.
###### Parameters
###### xpub
`string`
Base58-encoded extended public key (xpub...)
###### Returns
[`HDWallet`](#hdwallet)
Extended key with public key only (no private key)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If extended public key format is invalid or decoding fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const pubKey = HDWallet.fromPublicExtendedKey("xpub661MyMwAqRbcF...");
// Can only derive normal (non-hardened) children
```
##### fromSeed()
> **fromSeed**: (`seed`) => [`HDWallet`](#hdwallet)
Create root HD key from BIP-39 seed.
Master key for hierarchical deterministic wallet.
###### Parameters
###### seed
`Uint8Array`\<`ArrayBufferLike`>
BIP-39 seed bytes (typically 64 bytes from mnemonic, must be 16-64 bytes)
###### Returns
[`HDWallet`](#hdwallet)
Root extended key for BIP-32 derivation
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is not between 16 and 64 bytes
###### Throws
If master key derivation fails
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const seed = new Uint8Array(64); // From BIP-39 mnemonic
const root = HDWallet.fromSeed(seed);
```
##### generateMnemonic()
> **generateMnemonic**: (`strength?`) => `Promise`\<`string`\[]>
Generate BIP-39 mnemonic from entropy
###### Parameters
###### strength?
Entropy strength in bits
`128` | `256`
###### Returns
`Promise`\<`string`\[]>
Mnemonic words
###### Throws
If strength is invalid or generation fails
##### getChainCode()
> **getChainCode**: (`key`) => `Uint8Array`\<`ArrayBufferLike`> | `null`
Get chain code from extended key.
Chain code is used in BIP-32 child key derivation.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key
###### Returns
`Uint8Array`\<`ArrayBufferLike`> | `null`
32-byte chain code or null if not available
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const chainCode = HDWallet.getChainCode(key);
```
##### getPrivateKey()
> **getPrivateKey**: (`key`) => `Uint8Array`\<`ArrayBufferLike`> | `null`
Get private key bytes from extended key.
Returns null for public-only keys.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key
###### Returns
`Uint8Array`\<`ArrayBufferLike`> | `null`
32-byte secp256k1 private key or null if public-only key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const privKey = HDWallet.getPrivateKey(key);
if (privKey) console.log('Has private key');
```
##### getPublicKey()
> **getPublicKey**: (`key`) => `Uint8Array`\<`ArrayBufferLike`> | `null`
Get public key bytes from extended key.
Returns compressed secp256k1 public key.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key
###### Returns
`Uint8Array`\<`ArrayBufferLike`> | `null`
33-byte compressed secp256k1 public key or null
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const pubKey = HDWallet.getPublicKey(key);
```
##### HARDENED\_OFFSET
> **HARDENED\_OFFSET**: `number`
First hardened child index offset for BIP-32 derivation.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { HARDENED_OFFSET } from './crypto/HDWallet/constants.js';
const hardenedIndex = 0 + HARDENED_OFFSET; // 0x80000000
```
##### isHardenedPath()
> **isHardenedPath**: (`path`) => `boolean`
Check if BIP-32 path contains hardened derivation.
Hardened paths use ' or h suffix (e.g., 44' or 44h).
###### Parameters
###### path
`string`
BIP-32 derivation path
###### Returns
`boolean`
True if path contains hardened derivation indicator (' or h), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
HDWallet.isHardenedPath("m/44'/60'/0'"); // true
HDWallet.isHardenedPath("m/44/60/0"); // false
```
##### isValidPath()
> **isValidPath**: (`path`) => `boolean`
Validate BIP-32 derivation path format.
Checks syntax but not semantic validity.
###### Parameters
###### path
`string`
Derivation path to validate
###### Returns
`boolean`
True if path matches BIP-32 format (m/number'/number/...), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
HDWallet.isValidPath("m/44'/60'/0'/0/0"); // true
HDWallet.isValidPath("invalid"); // false
```
##### mnemonicToSeed()
> **mnemonicToSeed**: (`mnemonic`, `password?`) => `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Convert BIP-39 mnemonic to seed
###### Parameters
###### mnemonic
Mnemonic words (array or space-separated string)
`string` | `string`\[]
###### password?
`string`
Optional passphrase
###### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
512-bit seed
###### Throws
If mnemonic conversion fails
##### parseIndex()
> **parseIndex**: (`indexStr`) => `number`
Parse BIP-32 index string with hardened notation.
Converts "0'" or "0h" to hardened index (adds HARDENED\_OFFSET).
###### Parameters
###### indexStr
`string`
Index string (e.g., "0", "0'", "0h")
###### Returns
`number`
Numeric index (hardened indices have HARDENED\_OFFSET added)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If index format is invalid or not a non-negative integer
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
HDWallet.parseIndex("0"); // 0
HDWallet.parseIndex("0'"); // 2147483648 (0x80000000)
HDWallet.parseIndex("44h"); // 2147483692 (44 + 0x80000000)
```
##### toExtendedPrivateKey()
> **toExtendedPrivateKey**: (`key`) => `string`
Serialize extended key to base58-encoded xprv string.
Requires key with private key material.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key with private key
###### Returns
`string`
Base58-encoded extended private key (xprv...)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key does not have private key material
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const xprv = HDWallet.toExtendedPrivateKey(key);
console.log(xprv); // "xprv9s21ZrQH143K..."
```
##### toExtendedPublicKey()
> **toExtendedPublicKey**: (`key`) => `string`
Serialize extended key to base58-encoded xpub string.
Produces public-only key that cannot derive hardened children.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key
###### Returns
`string`
Base58-encoded extended public key (xpub...)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key does not have public key
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const xpub = HDWallet.toExtendedPublicKey(key);
console.log(xpub); // "xpub661MyMwAqRbcF..."
```
##### toPublic()
> **toPublic**: (`key`) => [`HDWallet`](#hdwallet)
Create public-only version of extended key (neutered key).
Removes private key material, keeping only public key and chain code.
###### Parameters
###### key
[`HDWallet`](#hdwallet)
Extended key with or without private key
###### Returns
[`HDWallet`](#hdwallet)
Public-only extended key (cannot derive hardened children)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key does not have public key
###### Example
```javascript theme={null}
import * as HDWallet from './crypto/HDWallet/index.js';
const pubOnlyKey = HDWallet.toPublic(key);
// Can share publicly without exposing private key
```
##### validateMnemonic()
> **validateMnemonic**: (`mnemonic`) => `Promise`\<`boolean`>
Validate BIP-39 mnemonic checksum
###### Parameters
###### mnemonic
Mnemonic words (array or space-separated string)
`string` | `string`\[]
###### Returns
`Promise`\<`boolean`>
True if valid
# Proxy
Source: https://voltaire.tevm.sh/generated-api/Proxy
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / Proxy
# Proxy
ERC-1967 Proxy Storage Slots and ERC-1167 Minimal Proxy utilities
## See
* [https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967) - Proxy Storage Slots
* [https://eips.ethereum.org/EIPS/eip-1167](https://eips.ethereum.org/EIPS/eip-1167) - Minimal Proxy Contract
* [https://eips.ethereum.org/EIPS/eip-3448](https://eips.ethereum.org/EIPS/eip-3448) - MetaProxy Standard
## Type Aliases
### ProxySlotType
> **ProxySlotType** = `Uint8Array` & `object`
Defined in: [src/primitives/Proxy/ProxyType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/ProxyType.ts#L8)
ERC-1967 Proxy storage slot type
Represents a 32-byte storage slot used in proxy contracts
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ProxySlot"`
#### See
[https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967)
## Variables
### ADMIN\_SLOT
> `const` **ADMIN\_SLOT**: `string` = `"0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103"`
Defined in: [src/primitives/Proxy/constants.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/constants.js#L28)
ERC-1967 Admin Slot
Storage slot for the admin address in proxy contracts
Calculated as: bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
#### See
[https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967)
***
### BEACON\_SLOT
> `const` **BEACON\_SLOT**: `string` = `"0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50"`
Defined in: [src/primitives/Proxy/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/constants.js#L18)
ERC-1967 Beacon Slot
Storage slot for the beacon address in beacon proxy contracts
Calculated as: bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)
#### See
[https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967)
***
### IMPLEMENTATION\_SLOT
> `const` **IMPLEMENTATION\_SLOT**: `string` = `"0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"`
Defined in: [src/primitives/Proxy/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/constants.js#L8)
ERC-1967 Implementation Slot
Storage slot for the implementation address in proxy contracts
Calculated as: bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
#### See
[https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967)
***
### ROLLBACK\_SLOT
> `const` **ROLLBACK\_SLOT**: `string` = `"0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143"`
Defined in: [src/primitives/Proxy/constants.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/constants.js#L38)
ERC-1967 Rollback Test Slot
Storage slot used for rollback tests in upgradeable proxies
Calculated as: bytes32(uint256(keccak256('eip1967.proxy.rollback')) - 1)
#### See
[https://eips.ethereum.org/EIPS/eip-1967](https://eips.ethereum.org/EIPS/eip-1967)
## Functions
### generateErc1167()
> **generateErc1167**(`implementationAddress`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Proxy/generateErc1167.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/generateErc1167.js#L8)
Generate ERC-1167 minimal proxy bytecode
Creates the 55-byte creation code and 45-byte runtime code for a minimal proxy
#### Parameters
##### implementationAddress
`Uint8Array`\<`ArrayBufferLike`>
20-byte implementation address
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
55-byte creation code
#### See
[https://eips.ethereum.org/EIPS/eip-1167](https://eips.ethereum.org/EIPS/eip-1167)
***
### generateErc3448()
> **generateErc3448**(`implementation`, `metadata`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Proxy/generateErc3448.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/generateErc3448.js#L18)
Generate ERC-3448 MetaProxy bytecode with metadata
ERC-3448 extends ERC-1167 minimal proxy by appending metadata to the bytecode.
Structure:
* 10 bytes: creation code (3d602d80600a3d3981f3)
* 45 bytes: runtime code (363d3d373d3d3d363d73\[address]5af43d82803e903d91602b57fd5bf3)
* N bytes: metadata (arbitrary data)
* 32 bytes: metadata length as uint256 (big-endian)
Total: 87 + N bytes
#### Parameters
##### implementation
`Uint8Array`\<`ArrayBufferLike`>
20-byte implementation address
##### metadata
`Uint8Array`\<`ArrayBufferLike`>
Metadata to append (arbitrary length)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Complete MetaProxy bytecode
#### See
[https://eips.ethereum.org/EIPS/eip-3448](https://eips.ethereum.org/EIPS/eip-3448)
***
### isErc1167()
> **isErc1167**(`bytecode`): `boolean`
Defined in: [src/primitives/Proxy/isErc1167.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/isErc1167.js#L7)
Check if bytecode is a valid ERC-1167 minimal proxy
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Bytecode to check
#### Returns
`boolean`
True if valid ERC-1167 proxy
#### See
[https://eips.ethereum.org/EIPS/eip-1167](https://eips.ethereum.org/EIPS/eip-1167)
***
### isErc3448()
> **isErc3448**(`bytecode`): `boolean`
Defined in: [src/primitives/Proxy/isErc3448.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/isErc3448.js#L15)
Check if bytecode is valid ERC-3448 MetaProxy
Validates:
* Minimum length (87 bytes: 55 proxy + 32 length)
* Creation code matches (10 bytes)
* Runtime code prefix matches (first 20 bytes)
* Runtime code suffix matches (last 15 bytes before metadata)
* Metadata length encoding is consistent
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Bytecode to validate
#### Returns
`boolean`
True if valid ERC-3448 MetaProxy
#### See
[https://eips.ethereum.org/EIPS/eip-3448](https://eips.ethereum.org/EIPS/eip-3448)
***
### parseErc1167()
> **parseErc1167**(`bytecode`): `Uint8Array`\<`ArrayBufferLike`> | `null`
Defined in: [src/primitives/Proxy/parseErc1167.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/parseErc1167.js#L8)
Parse implementation address from ERC-1167 minimal proxy bytecode
Extracts the 20-byte implementation address from the proxy bytecode
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Proxy bytecode (45 or 55 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`> | `null`
20-byte implementation address or null if invalid
#### See
[https://eips.ethereum.org/EIPS/eip-1167](https://eips.ethereum.org/EIPS/eip-1167)
***
### parseErc3448()
> **parseErc3448**(`bytecode`): \{ `implementation`: `Uint8Array`; `metadata`: `Uint8Array`; } | `null`
Defined in: [src/primitives/Proxy/parseErc3448.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proxy/parseErc3448.js#L13)
Parse ERC-3448 MetaProxy bytecode
Extracts implementation address and metadata from ERC-3448 MetaProxy bytecode.
Reads last 32 bytes as metadata length, then extracts:
* Implementation address from bytes 20-39 (within creation code)
* Metadata from bytes 55 to (length - 32)
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
MetaProxy bytecode
#### Returns
\{ `implementation`: `Uint8Array`; `metadata`: `Uint8Array`; } | `null`
Parsed components or null if invalid
#### See
[https://eips.ethereum.org/EIPS/eip-3448](https://eips.ethereum.org/EIPS/eip-3448)
# Ssz
Source: https://voltaire.tevm.sh/generated-api/Ssz
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / Ssz
# Ssz
SSZ (Simple Serialize) - Ethereum consensus layer serialization
## Example
```typescript theme={null}
import * as Ssz from './primitives/Ssz/index.js';
// Encode basic types
const encoded = Ssz.encodeBasic(42, 'uint32');
// Decode basic types
const decoded = Ssz.decodeBasic(encoded, 'uint32');
// Compute hash tree root
const root = await Ssz.hashTreeRoot(data);
```
## Type Aliases
### SszType
> **SszType** = `Uint8Array` & `object`
Defined in: [src/primitives/Ssz/SszType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ssz/SszType.ts#L13)
SSZ encoded data
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"Ssz"`
## Functions
### decodeBasic()
> **decodeBasic**(`bytes`, `type`): `number` | `bigint` | `boolean`
Defined in: [src/primitives/Ssz/encodeBasic.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ssz/encodeBasic.js#L57)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
SSZ encoded bytes
##### type
`string`
Type: 'uint8', 'uint16', 'uint32', 'uint64', 'uint256', 'bool'
#### Returns
`number` | `bigint` | `boolean`
Decoded value
#### Description
Decodes basic types from SSZ serialization
***
### encodeBasic()
> **encodeBasic**(`value`, `type`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Ssz/encodeBasic.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ssz/encodeBasic.js#L7)
#### Parameters
##### value
Value to encode
`number` | `bigint` | `boolean`
##### type
`string`
Type: 'uint8', 'uint16', 'uint32', 'uint64', 'uint256', 'bool'
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
SSZ encoded bytes
#### Description
Encodes basic types using SSZ serialization
***
### hashTreeRoot()
> **hashTreeRoot**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/primitives/Ssz/hashTreeRoot.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ssz/hashTreeRoot.js#L6)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Data to merkleize
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
32-byte hash tree root
#### Description
Computes the hash tree root of data for Merkle proofs
# Storage
Source: https://voltaire.tevm.sh/generated-api/Storage
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / Storage
# Storage
Storage Layout Utilities
## See
* [https://eips.ethereum.org/EIPS/eip-7201](https://eips.ethereum.org/EIPS/eip-7201) - Namespaced Storage Layout
* [https://eips.ethereum.org/EIPS/eip-8042](https://eips.ethereum.org/EIPS/eip-8042) - Diamond Storage
## Type Aliases
### StorageSlotType
> **StorageSlotType** = `Uint8Array` & `object`
Defined in: [src/primitives/Storage/StorageType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Storage/StorageType.ts#L7)
Storage slot type (32 bytes)
Represents a storage location in Ethereum contract storage
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"StorageSlot"`
## Functions
### calculateErc7201()
> **calculateErc7201**(`keccak256`, `id`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Storage/calculateErc7201.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Storage/calculateErc7201.js#L10)
Calculate ERC-7201 namespaced storage slot
Formula: keccak256(keccak256(id) - 1) & \~0xff
The result has the last byte cleared (set to 0x00)
#### Parameters
##### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
##### id
`string`
Namespace identifier string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte storage slot
#### See
[https://eips.ethereum.org/EIPS/eip-7201](https://eips.ethereum.org/EIPS/eip-7201)
***
### calculateErc8042()
> **calculateErc8042**(`keccak256`, `id`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Storage/calculateErc8042.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Storage/calculateErc8042.js#L10)
Calculate ERC-8042 (Diamond Storage) storage slot
Formula: keccak256(id)
Simpler than ERC-7201, just the direct hash of the identifier
#### Parameters
##### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
##### id
`string`
Storage namespace identifier string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte storage slot
#### See
[https://eips.ethereum.org/EIPS/eip-8042](https://eips.ethereum.org/EIPS/eip-8042)
# TransactionUrl
Source: https://voltaire.tevm.sh/generated-api/TransactionUrl
ERC-681 defines a standard URL format for representing Ethereum transactions.
This enables QR codes, deep links, and wallet integrations.
Format:
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / TransactionUrl
# TransactionUrl
ERC-681 Transaction URL Format
## See
[https://eips.ethereum.org/EIPS/eip-681](https://eips.ethereum.org/EIPS/eip-681)
## Example
```typescript theme={null}
import * as TransactionUrl from './primitives/TransactionUrl/index.js';
// Parse URL
const parsed = TransactionUrl.parse('ethereum:0x1234@1?value=1000000000000000000');
// { target: AddressType, chainId: 1n, value: 1000000000000000000n }
// Format URL
const url = TransactionUrl.format({
target: addressValue,
chainId: 1n,
value: 1000000000000000000n,
});
// 'ethereum:0x1234...@1?value=1000000000000000000'
// Create branded URL
const brandedUrl = TransactionUrl.from('ethereum:0x1234@1');
```
## Classes
### InvalidTransactionUrlError
Defined in: [src/primitives/TransactionUrl/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/errors.js#L4)
Error thrown when a transaction URL is invalid or malformed
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTransactionUrlError**(`message`, `details?`): [`InvalidTransactionUrlError`](#invalidtransactionurlerror)
Defined in: [src/primitives/TransactionUrl/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/errors.js#L9)
###### Parameters
###### message
`string`
Error message
###### details?
`Record`\<`string`, `unknown`>
Additional error details
###### Returns
[`InvalidTransactionUrlError`](#invalidtransactionurlerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `Record`\<`string`, `unknown`> | `undefined`
Defined in: [src/primitives/TransactionUrl/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/TransactionUrl/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### ParsedTransactionUrl
> **ParsedTransactionUrl** = `object`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L16)
Parsed ERC-681 transaction URL components
#### Properties
##### chainId?
> `readonly` `optional` **chainId**: `bigint`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L18)
##### data?
> `readonly` `optional` **data**: [`BytesType`](primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L22)
##### functionName?
> `readonly` `optional` **functionName**: `string`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L23)
##### functionParams?
> `readonly` `optional` **functionParams**: `Record`\<`string`, `string`>
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L24)
##### gas?
> `readonly` `optional` **gas**: `bigint`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L20)
##### gasPrice?
> `readonly` `optional` **gasPrice**: `bigint`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L21)
##### target
> `readonly` **target**: [`AddressType`](primitives/Address.mdx#addresstype)
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L17)
##### value?
> `readonly` `optional` **value**: `bigint`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L19)
***
### TransactionUrl
> **TransactionUrl** = `string` & `object`
Defined in: [src/primitives/TransactionUrl/TransactionUrlType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/TransactionUrlType.ts#L11)
ERC-681 compliant transaction URL
Format: `ethereum:[@][/][?]`
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TransactionUrl"`
#### See
[https://eips.ethereum.org/EIPS/eip-681](https://eips.ethereum.org/EIPS/eip-681)
## Functions
### format()
> **format**(`request`): [`TransactionUrl`](#transactionurl)
Defined in: [src/primitives/TransactionUrl/format.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/format.js#L23)
Format transaction request as ERC-681 URL
#### Parameters
##### request
[`ParsedTransactionUrl`](#parsedtransactionurl)
Transaction parameters
#### Returns
[`TransactionUrl`](#transactionurl)
* ERC-681 formatted URL
#### See
[https://eips.ethereum.org/EIPS/eip-681](https://eips.ethereum.org/EIPS/eip-681)
#### Example
```javascript theme={null}
import { format } from './primitives/TransactionUrl/format.js';
const url = format({
target: addressValue,
chainId: 1n,
value: 1000000000000000000n,
});
// 'ethereum:0x1234...@1?value=1000000000000000000'
```
***
### from()
> **from**(`url`): [`TransactionUrl`](#transactionurl)
Defined in: [src/primitives/TransactionUrl/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/from.js#L17)
Create TransactionUrl from string (alias for parse)
#### Parameters
##### url
`string`
ERC-681 URL string
#### Returns
[`TransactionUrl`](#transactionurl)
#### Throws
if URL is malformed
#### Example
```javascript theme={null}
import * as TransactionUrl from './primitives/TransactionUrl/index.js';
const url = TransactionUrl.from('ethereum:0x1234...@1?value=1000000000000000000');
```
***
### parse()
> **parse**(`url`): [`ParsedTransactionUrl`](#parsedtransactionurl)
Defined in: [src/primitives/TransactionUrl/parse.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionUrl/parse.js#L37)
Parse ERC-681 transaction URL
Format: `ethereum:[@][/][?]`
Examples:
* ethereum:0x1234...
* ethereum:0x1234\@1
* ethereum:0x1234\@1?value=1000000000000000000
* ethereum:0x1234/transfer?address=0x5678\&uint256=100
Query parameters:
* value: wei amount (decimal or hex with 0x)
* gas: gas limit
* gasPrice: gas price in wei
* data: hex-encoded calldata (0x...)
#### Parameters
##### url
`string`
ERC-681 URL
#### Returns
[`ParsedTransactionUrl`](#parsedtransactionurl)
#### See
[https://eips.ethereum.org/EIPS/eip-681](https://eips.ethereum.org/EIPS/eip-681)
#### Throws
if URL is malformed
#### Example
```javascript theme={null}
import { parse } from './primitives/TransactionUrl/parse.js';
const parsed = parse('ethereum:0x1234...@1?value=1000000000000000000');
// { target: AddressType, chainId: 1n, value: 1000000000000000000n }
```
# crypto
Source: https://voltaire.tevm.sh/generated-api/crypto
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / crypto
# crypto
## References
### AesGcm
Re-exports [AesGcm](crypto/AesGcm.mdx#aesgcm)
***
### Bip39
Re-exports [Bip39](crypto/Bip39.mdx#bip39)
***
### Blake2
Re-exports [Blake2](crypto/Blake2.mdx#blake2)
***
### Blake2Hash
Re-exports [Blake2Hash](index/index.mdx#blake2hash)
***
### Blake2HashType
Renames and re-exports [Blake2Hash](index/index.mdx#blake2hash)
***
### Bls12381
Re-exports [Bls12381](crypto/Bls12381/index.mdx#bls12381)
***
### Bls12381Fp2Type
Re-exports [Bls12381Fp2Type](index/index.mdx#bls12381fp2type)
***
### Bls12381G1PointType
Re-exports [Bls12381G1PointType](index/index.mdx#bls12381g1pointtype)
***
### Bls12381G2PointType
Re-exports [Bls12381G2PointType](index/index.mdx#bls12381g2pointtype)
***
### BN254
Re-exports [BN254](index/index.mdx#bn254)
***
### ChaCha20Poly1305
Re-exports [ChaCha20Poly1305](crypto/ChaCha20Poly1305.mdx#chacha20poly1305)
***
### Ed25519
Re-exports [Ed25519](crypto/Ed25519.mdx#ed25519)
***
### EIP712
Re-exports [EIP712](crypto/EIP712.mdx#eip712)
***
### HDWallet
Re-exports [HDWallet](HDWallet.mdx)
***
### Keccak256
Re-exports [Keccak256](crypto/Keccak256.mdx#keccak256)
***
### Keccak256Hash
Re-exports [Keccak256Hash](index/index.mdx#keccak256hash)
***
### Keccak256HashType
Renames and re-exports [Keccak256Hash](index/index.mdx#keccak256hash)
***
### Keystore
Renames and re-exports [crypto/Keystore](crypto/Keystore.mdx)
***
### KZG
Re-exports [KZG](index/index.mdx#kzg)
***
### KzgBlobType
Renames and re-exports [BlobType](crypto/KZG.mdx#blobtype)
***
### KzgCommitmentType
Re-exports [KzgCommitmentType](crypto/KZG.mdx#kzgcommitmenttype)
***
### KzgProofType
Re-exports [KzgProofType](crypto/KZG.mdx#kzgprooftype)
***
### ModExp
Re-exports [ModExp](crypto/ModExp.mdx#modexp)
***
### P256
Re-exports [P256](crypto/P256.mdx#p256)
***
### Ripemd160
Re-exports [Ripemd160](crypto/Ripemd160.mdx#ripemd160)
***
### Ripemd160Hash
Re-exports [Ripemd160Hash](index/index.mdx#ripemd160hash)
***
### Ripemd160HashType
Renames and re-exports [Ripemd160Hash](index/index.mdx#ripemd160hash)
***
### Secp256k1
Re-exports [Secp256k1](crypto/Secp256k1.mdx#secp256k1)
***
### SHA256
Re-exports [SHA256](crypto/SHA256.mdx#sha256)
***
### SHA256Hash
Re-exports [SHA256Hash](index/index.mdx#sha256hash)
***
### SHA256HashType
Renames and re-exports [SHA256Hash](index/index.mdx#sha256hash)
***
### X25519
Re-exports [X25519](crypto/X25519.mdx#x25519)
# crypto/AesGcm
Source: https://voltaire.tevm.sh/generated-api/crypto/AesGcm
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/AesGcm
# crypto/AesGcm
## Classes
### AesGcmError
Defined in: [src/crypto/AesGcm/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L21)
Base error for AES-GCM operations
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { AesGcmError } from './crypto/AesGcm/index.js';
throw new AesGcmError('Operation failed', {
code: 'AES_GCM_ERROR',
context: { operation: 'encrypt' },
docsPath: '/crypto/aes-gcm#error-handling',
cause: originalError
});
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`InvalidKeyError`](#invalidkeyerror)
* [`InvalidNonceError`](#invalidnonceerror)
* [`DecryptionError`](#decryptionerror)
#### Constructors
##### Constructor
> **new AesGcmError**(`message`, `options?`): [`AesGcmError`](#aesgcmerror)
Defined in: [src/crypto/AesGcm/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L26)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`AesGcmError`](#aesgcmerror)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/AesGcm/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L33)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### DecryptionError
Defined in: [src/crypto/AesGcm/errors.js:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L118)
Decryption failure error
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { DecryptionError } from './crypto/AesGcm/index.js';
throw new DecryptionError('Authentication failed', {
code: 'AES_GCM_DECRYPTION_FAILED',
context: { operation: 'decrypt' },
docsPath: '/crypto/aes-gcm/decrypt#error-handling',
cause: originalError
});
```
#### Extends
* [`AesGcmError`](#aesgcmerror)
#### Constructors
##### Constructor
> **new DecryptionError**(`message`, `options?`): [`DecryptionError`](#decryptionerror)
Defined in: [src/crypto/AesGcm/errors.js:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L123)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`DecryptionError`](#decryptionerror)
###### Overrides
[`AesGcmError`](#aesgcmerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/AesGcm/errors.js:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L130)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`toJSON`](#tojson)
***
### InvalidKeyError
Defined in: [src/crypto/AesGcm/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L53)
Invalid key error
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidKeyError } from './crypto/AesGcm/index.js';
throw new InvalidKeyError('Invalid key size', {
code: 'AES_GCM_INVALID_KEY_SIZE',
context: { size: 16, expected: '16, 24, or 32 bytes' },
docsPath: '/crypto/aes-gcm/import-key#error-handling'
});
```
#### Extends
* [`AesGcmError`](#aesgcmerror)
#### Constructors
##### Constructor
> **new InvalidKeyError**(`message`, `options?`): [`InvalidKeyError`](#invalidkeyerror)
Defined in: [src/crypto/AesGcm/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L58)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidKeyError`](#invalidkeyerror)
###### Overrides
[`AesGcmError`](#aesgcmerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/AesGcm/errors.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L65)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`toJSON`](#tojson)
***
### InvalidNonceError
Defined in: [src/crypto/AesGcm/errors.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L85)
Invalid nonce error
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidNonceError } from './crypto/AesGcm/index.js';
throw new InvalidNonceError('Nonce must be 12 bytes', {
code: 'AES_GCM_INVALID_NONCE_LENGTH',
context: { length: 8, expected: 12 },
docsPath: '/crypto/aes-gcm/encrypt#error-handling'
});
```
#### Extends
* [`AesGcmError`](#aesgcmerror)
#### Constructors
##### Constructor
> **new InvalidNonceError**(`message`, `options?`): [`InvalidNonceError`](#invalidnonceerror)
Defined in: [src/crypto/AesGcm/errors.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L90)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidNonceError`](#invalidnonceerror)
###### Overrides
[`AesGcmError`](#aesgcmerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/AesGcm/errors.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/errors.js#L97)
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`AesGcmError`](#aesgcmerror).[`toJSON`](#tojson)
## Type Aliases
### Key
> **Key** = `CryptoKey`
Defined in: [src/crypto/AesGcm/KeyTypes.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/KeyTypes.ts#L13)
AES-GCM CryptoKey type
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import type { Key } from './crypto/AesGcm/KeyTypes.js';
const key: Key = await crypto.subtle.generateKey(...);
```
***
### KeyMaterial
> **KeyMaterial** = `Uint8Array`
Defined in: [src/crypto/AesGcm/KeyTypes.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/KeyTypes.ts#L27)
Raw key material (bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import type { KeyMaterial } from './crypto/AesGcm/KeyTypes.js';
const material: KeyMaterial = new Uint8Array(32);
```
## Variables
### AES128\_KEY\_SIZE
> `const` **AES128\_KEY\_SIZE**: `16` = `16`
Defined in: [src/crypto/AesGcm/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/constants.js#L13)
AES-128 key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = new Uint8Array(AesGcm.AES128_KEY_SIZE);
```
***
### AES256\_KEY\_SIZE
> `const` **AES256\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/AesGcm/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/constants.js#L27)
AES-256 key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = new Uint8Array(AesGcm.AES256_KEY_SIZE);
```
***
### AesGcm
> `const` **AesGcm**: `object`
Defined in: [src/crypto/AesGcm/AesGcm.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/AesGcm.js#L54)
AES-GCM (Galois/Counter Mode) Authenticated Encryption
Provides authenticated encryption using AES in GCM mode.
Uses native WebCrypto API for optimal performance and security.
Supports both AES-128-GCM and AES-256-GCM.
#### Type Declaration
##### AES128\_KEY\_SIZE
> **AES128\_KEY\_SIZE**: `number`
AES-128 key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = new Uint8Array(AesGcm.AES128_KEY_SIZE);
```
##### AES256\_KEY\_SIZE
> **AES256\_KEY\_SIZE**: `number`
AES-256 key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = new Uint8Array(AesGcm.AES256_KEY_SIZE);
```
##### decrypt()
> **decrypt**: (`ciphertext`, `key`, `nonce`, `additionalData?`) => `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Decrypt data with AES-GCM
###### Parameters
###### ciphertext
`Uint8Array`\<`ArrayBufferLike`>
Encrypted data with authentication tag
###### key
`CryptoKey`
AES key (128 or 256 bit)
###### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (IV) used during encryption
###### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
###### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Decrypted plaintext
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If authentication fails or decryption error
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key = await AesGcm.generateKey(256);
const nonce = AesGcm.generateNonce();
const decrypted = await AesGcm.decrypt(ciphertext, key, nonce);
const message = new TextDecoder().decode(decrypted);
```
##### deriveKey()
> **deriveKey**: (`password`, `salt`, `iterations`, `bits`) => `Promise`\<`CryptoKey`>
Derive key from password using PBKDF2
###### Parameters
###### password
Password string or bytes
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### salt
`Uint8Array`\<`ArrayBufferLike`>
Salt for key derivation (at least 16 bytes recommended)
###### iterations
`number`
Number of iterations (at least 100000 recommended)
###### bits
Key size in bits (128 or 256)
`128` | `256`
###### Returns
`Promise`\<`CryptoKey`>
Derived CryptoKey
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key derivation fails
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const salt = crypto.getRandomValues(new Uint8Array(16));
const key = await AesGcm.deriveKey('mypassword', salt, 100000, 256);
```
##### encrypt()
> **encrypt**: (`plaintext`, `key`, `nonce`, `additionalData?`) => `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Encrypt data with AES-GCM
###### Parameters
###### plaintext
`Uint8Array`\<`ArrayBufferLike`>
Data to encrypt
###### key
`CryptoKey`
AES key (128 or 256 bit)
###### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (IV)
###### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
###### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Ciphertext with authentication tag appended
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If encryption fails
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const plaintext = new TextEncoder().encode('Secret message');
const key = await AesGcm.generateKey(256);
const nonce = AesGcm.generateNonce();
const ciphertext = await AesGcm.encrypt(plaintext, key, nonce);
```
##### exportKey()
> **exportKey**: (`key`) => `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Export CryptoKey to raw bytes
###### Parameters
###### key
`CryptoKey`
CryptoKey to export
###### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Raw key bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key export fails
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key = await AesGcm.generateKey(256);
const keyBytes = await AesGcm.exportKey(key);
```
##### generateKey()
> **generateKey**: (`bits`) => `Promise`\<`CryptoKey`>
Generate AES-GCM key
###### Parameters
###### bits
Key size in bits (128 or 256)
`128` | `256`
###### Returns
`Promise`\<`CryptoKey`>
CryptoKey for use with WebCrypto API
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key generation fails
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key128 = await AesGcm.generateKey(128);
const key256 = await AesGcm.generateKey(256);
```
##### generateNonce()
> **generateNonce**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate random nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
12-byte random nonce
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const nonce = AesGcm.generateNonce();
```
##### importKey()
> **importKey**: (`keyMaterial`) => `Promise`\<`CryptoKey`>
Import raw key material as CryptoKey
###### Parameters
###### keyMaterial
`Uint8Array`\<`ArrayBufferLike`>
16-byte (128-bit) or 32-byte (256-bit) key
###### Returns
`Promise`\<`CryptoKey`>
CryptoKey for use with WebCrypto API
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If key import fails or key size is invalid
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = crypto.getRandomValues(new Uint8Array(32));
const key = await AesGcm.importKey(keyBytes);
```
##### NONCE\_SIZE
> **NONCE\_SIZE**: `number`
Nonce/IV size in bytes (standard for GCM)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const nonce = new Uint8Array(AesGcm.NONCE_SIZE);
```
##### TAG\_SIZE
> **TAG\_SIZE**: `number`
Authentication tag size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
console.log('Tag size:', AesGcm.TAG_SIZE);
```
#### Example
```typescript theme={null}
import { AesGcm } from './AesGcm.js';
// Generate key
const key = await AesGcm.generateKey(256);
// Encrypt data
const plaintext = new TextEncoder().encode('Hello, world!');
const nonce = AesGcm.generateNonce();
const ciphertext = await AesGcm.encrypt(plaintext, key, nonce);
// Decrypt data
const decrypted = await AesGcm.decrypt(ciphertext, key, nonce);
```
***
### NONCE\_SIZE
> `const` **NONCE\_SIZE**: `12` = `12`
Defined in: [src/crypto/AesGcm/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/constants.js#L41)
Nonce/IV size in bytes (standard for GCM)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const nonce = new Uint8Array(AesGcm.NONCE_SIZE);
```
***
### TAG\_SIZE
> `const` **TAG\_SIZE**: `16` = `16`
Defined in: [src/crypto/AesGcm/constants.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/constants.js#L55)
Authentication tag size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
console.log('Tag size:', AesGcm.TAG_SIZE);
```
## Functions
### decrypt()
> **decrypt**(`ciphertext`, `key`, `nonce`, `additionalData?`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/crypto/AesGcm/decrypt.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/decrypt.js#L24)
Decrypt data with AES-GCM
#### Parameters
##### ciphertext
`Uint8Array`\<`ArrayBufferLike`>
Encrypted data with authentication tag
##### key
`CryptoKey`
AES key (128 or 256 bit)
##### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (IV) used during encryption
##### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Decrypted plaintext
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If authentication fails or decryption error
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key = await AesGcm.generateKey(256);
const nonce = AesGcm.generateNonce();
const decrypted = await AesGcm.decrypt(ciphertext, key, nonce);
const message = new TextDecoder().decode(decrypted);
```
***
### deriveKey()
> **deriveKey**(`password`, `salt`, `iterations`, `bits`): `Promise`\<`CryptoKey`>
Defined in: [src/crypto/AesGcm/deriveKey.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/deriveKey.js#L21)
Derive key from password using PBKDF2
#### Parameters
##### password
Password string or bytes
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### salt
`Uint8Array`\<`ArrayBufferLike`>
Salt for key derivation (at least 16 bytes recommended)
##### iterations
`number`
Number of iterations (at least 100000 recommended)
##### bits
Key size in bits (128 or 256)
`128` | `256`
#### Returns
`Promise`\<`CryptoKey`>
Derived CryptoKey
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If key derivation fails
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const salt = crypto.getRandomValues(new Uint8Array(16));
const key = await AesGcm.deriveKey('mypassword', salt, 100000, 256);
```
***
### encrypt()
> **encrypt**(`plaintext`, `key`, `nonce`, `additionalData?`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/crypto/AesGcm/encrypt.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/encrypt.js#L24)
Encrypt data with AES-GCM
#### Parameters
##### plaintext
`Uint8Array`\<`ArrayBufferLike`>
Data to encrypt
##### key
`CryptoKey`
AES key (128 or 256 bit)
##### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (IV)
##### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Ciphertext with authentication tag appended
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If encryption fails
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const plaintext = new TextEncoder().encode('Secret message');
const key = await AesGcm.generateKey(256);
const nonce = AesGcm.generateNonce();
const ciphertext = await AesGcm.encrypt(plaintext, key, nonce);
```
***
### exportKey()
> **exportKey**(`key`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/crypto/AesGcm/exportKey.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/exportKey.js#L18)
Export CryptoKey to raw bytes
#### Parameters
##### key
`CryptoKey`
CryptoKey to export
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Raw key bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If key export fails
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key = await AesGcm.generateKey(256);
const keyBytes = await AesGcm.exportKey(key);
```
***
### generateKey()
> **generateKey**(`bits`): `Promise`\<`CryptoKey`>
Defined in: [src/crypto/AesGcm/generateKey.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/generateKey.js#L18)
Generate AES-GCM key
#### Parameters
##### bits
Key size in bits (128 or 256)
`128` | `256`
#### Returns
`Promise`\<`CryptoKey`>
CryptoKey for use with WebCrypto API
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If key generation fails
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const key128 = await AesGcm.generateKey(128);
const key256 = await AesGcm.generateKey(256);
```
***
### generateNonce()
> **generateNonce**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/AesGcm/generateNonce.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/generateNonce.js#L16)
Generate random nonce
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
12-byte random nonce
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const nonce = AesGcm.generateNonce();
```
***
### importKey()
> **importKey**(`keyMaterial`): `Promise`\<`CryptoKey`>
Defined in: [src/crypto/AesGcm/importKey.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/AesGcm/importKey.js#L19)
Import raw key material as CryptoKey
#### Parameters
##### keyMaterial
`Uint8Array`\<`ArrayBufferLike`>
16-byte (128-bit) or 32-byte (256-bit) key
#### Returns
`Promise`\<`CryptoKey`>
CryptoKey for use with WebCrypto API
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If key import fails or key size is invalid
#### Example
```javascript theme={null}
import * as AesGcm from './crypto/AesGcm/index.js';
const keyBytes = crypto.getRandomValues(new Uint8Array(32));
const key = await AesGcm.importKey(keyBytes);
```
# crypto/Bip39
Source: https://voltaire.tevm.sh/generated-api/crypto/Bip39
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Bip39
# crypto/Bip39
## Classes
### Bip39Error
Defined in: [src/crypto/Bip39/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L21)
Base error for BIP-39 operations
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Bip39Error } from './crypto/Bip39/index.js';
throw new Bip39Error('BIP-39 operation failed', {
code: 'BIP39_ERROR',
context: { operation: 'generate' },
docsPath: '/crypto/bip39#error-handling',
cause: originalError
});
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`InvalidEntropyError`](#invalidentropyerror)
#### Constructors
##### Constructor
> **new Bip39Error**(`message?`, `options?`): [`Bip39Error`](#bip39error)
Defined in: [src/crypto/Bip39/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L26)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Bip39Error`](#bip39error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/Bip39/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L33)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### InvalidEntropyError
Defined in: [src/crypto/Bip39/errors.js:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L87)
Error thrown when entropy is invalid
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidEntropyError } from './crypto/Bip39/index.js';
throw new InvalidEntropyError('Invalid entropy size', {
code: 'BIP39_INVALID_ENTROPY_SIZE',
context: { size: 15, expected: '16, 20, 24, 28, or 32 bytes' },
docsPath: '/crypto/bip39/entropy-to-mnemonic#error-handling'
});
```
#### Extends
* [`Bip39Error`](#bip39error)
#### Constructors
##### Constructor
> **new InvalidEntropyError**(`message?`, `options?`): [`InvalidEntropyError`](#invalidentropyerror)
Defined in: [src/crypto/Bip39/errors.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L92)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidEntropyError`](#invalidentropyerror)
###### Overrides
[`Bip39Error`](#bip39error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`Bip39Error`](#bip39error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`Bip39Error`](#bip39error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`Bip39Error`](#bip39error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`Bip39Error`](#bip39error).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/Bip39/errors.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L99)
###### Inherited from
[`Bip39Error`](#bip39error).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`Bip39Error`](#bip39error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`Bip39Error`](#bip39error).[`toJSON`](#tojson)
***
### InvalidMnemonicError
Defined in: [src/crypto/Bip39/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L53)
Error thrown when mnemonic is invalid
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidMnemonicError } from './crypto/Bip39/index.js';
throw new InvalidMnemonicError('Invalid BIP-39 mnemonic phrase', {
code: 'BIP39_INVALID_MNEMONIC',
context: { wordCount: 11 },
docsPath: '/crypto/bip39/validate-mnemonic#error-handling'
});
```
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidMnemonicError**(`message?`, `options?`): [`InvalidMnemonicError`](#invalidmnemonicerror)
Defined in: [src/crypto/Bip39/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L58)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidMnemonicError`](#invalidmnemonicerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/crypto/Bip39/errors.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/errors.js#L67)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
## Type Aliases
### Entropy
> **Entropy** = `Uint8Array`
Defined in: [src/crypto/Bip39/EntropyType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/EntropyType.ts#L13)
Entropy bytes for BIP-39 mnemonic generation
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import type { Entropy } from './crypto/Bip39/EntropyType.js';
const entropy: Entropy = crypto.getRandomValues(new Uint8Array(32));
```
***
### Mnemonic
> **Mnemonic** = `string`
Defined in: [src/crypto/Bip39/MnemonicType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/MnemonicType.ts#L13)
BIP-39 mnemonic phrase (12-24 words)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import type { Mnemonic } from './crypto/Bip39/MnemonicType.js';
const mnemonic: Mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
```
***
### Seed
> **Seed** = `Uint8Array`
Defined in: [src/crypto/Bip39/SeedType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/SeedType.ts#L13)
BIP-39 seed (64 bytes / 512 bits)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import type { Seed } from './crypto/Bip39/SeedType.js';
const seed: Seed = new Uint8Array(64);
```
## Variables
### Bip39
> `const` **Bip39**: `object`
Defined in: [src/crypto/Bip39/Bip39.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/Bip39.js#L59)
BIP-39 Mnemonic Implementation
Provides mnemonic generation, validation, and seed derivation
following the BIP-39 standard for deterministic key generation.
#### Type Declaration
##### assertValidMnemonic()
> **assertValidMnemonic**: (`mnemonic`, `wl?`) => `void`
Validate mnemonic or throw error
###### Parameters
###### mnemonic
`string`
Mnemonic phrase to validate
###### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If mnemonic is invalid
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
try {
Bip39.assertValidMnemonic(mnemonic);
} catch (e) {
console.error("Invalid mnemonic:", e.message);
}
```
##### ENTROPY\_128
> **ENTROPY\_128**: `number`
128 bits entropy = 12 words
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_128);
```
##### ENTROPY\_160
> **ENTROPY\_160**: `number`
160 bits entropy = 15 words
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_160);
```
##### ENTROPY\_192
> **ENTROPY\_192**: `number`
192 bits entropy = 18 words
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_192);
```
##### ENTROPY\_224
> **ENTROPY\_224**: `number`
224 bits entropy = 21 words
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_224);
```
##### ENTROPY\_256
> **ENTROPY\_256**: `number`
256 bits entropy = 24 words
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_256);
```
##### entropyToMnemonic()
> **entropyToMnemonic**: (`entropy`, `wl?`) => `string`
Generate mnemonic from custom entropy
###### Parameters
###### entropy
[`Entropy`](#entropy)
Entropy bytes (16, 20, 24, 28, or 32 bytes)
###### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
###### Returns
`string`
Mnemonic phrase
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If entropy size is invalid
###### Throws
If conversion fails
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const entropy = crypto.getRandomValues(new Uint8Array(32));
const mnemonic = Bip39.entropyToMnemonic(entropy);
```
##### generateMnemonic()
> **generateMnemonic**: (`strength?`, `wl?`) => `string`
Generate a BIP-39 mnemonic phrase
###### Parameters
###### strength?
Entropy strength in bits (128=12 words, 256=24 words)
`128` | `160` | `192` | `224` | `256`
###### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
###### Returns
`string`
Mnemonic phrase
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If mnemonic generation fails
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
// Generate 12-word mnemonic (128 bits)
const mnemonic12 = Bip39.generateMnemonic(128);
// Generate 24-word mnemonic (256 bits)
const mnemonic24 = Bip39.generateMnemonic(256);
```
##### getEntropyBits()
> **getEntropyBits**: (`wordCount`) => `number`
Get entropy bits from word count
###### Parameters
###### wordCount
`number`
Number of words
###### Returns
`number`
Entropy in bits
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If word count is invalid
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
Bip39.getEntropyBits(12); // 128
Bip39.getEntropyBits(24); // 256
```
##### getWordCount()
> **getWordCount**: (`entropyBits`) => `number`
Get word count from entropy bits
###### Parameters
###### entropyBits
`number`
Entropy in bits
###### Returns
`number`
Number of words in mnemonic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If entropy bits value is invalid
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
Bip39.getWordCount(128); // 12
Bip39.getWordCount(256); // 24
```
##### mnemonicToSeed()
> **mnemonicToSeed**: (`mnemonic`, `passphrase?`) => `Promise`\<[`Seed`](#seed)>
Convert mnemonic to seed (async)
###### Parameters
###### mnemonic
`string`
BIP-39 mnemonic phrase
###### passphrase?
`string` = `""`
Optional passphrase for additional security
###### Returns
`Promise`\<[`Seed`](#seed)>
64-byte seed
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If mnemonic is invalid
###### Throws
If seed derivation fails
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = await Bip39.mnemonicToSeed(mnemonic, "my passphrase");
```
##### mnemonicToSeedSync()
> **mnemonicToSeedSync**: (`mnemonic`, `passphrase?`) => [`Seed`](#seed)
Convert mnemonic to seed (sync)
###### Parameters
###### mnemonic
`string`
BIP-39 mnemonic phrase
###### passphrase?
`string` = `""`
Optional passphrase for additional security
###### Returns
[`Seed`](#seed)
64-byte seed
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If mnemonic is invalid
###### Throws
If seed derivation fails
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = Bip39.mnemonicToSeedSync(mnemonic);
```
##### SEED\_LENGTH
> **SEED\_LENGTH**: `number`
BIP-39 seed length (512 bits / 64 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = await Bip39.mnemonicToSeed(mnemonic);
console.log(seed.length === Bip39.SEED_LENGTH);
```
##### validateMnemonic()
> **validateMnemonic**: (`mnemonic`, `wl?`) => `boolean`
Validate a BIP-39 mnemonic phrase
###### Parameters
###### mnemonic
`string`
Mnemonic phrase to validate
###### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
if (Bip39.validateMnemonic(mnemonic)) {
console.log("Valid mnemonic");
}
```
#### Example
```typescript theme={null}
import { Bip39 } from './Bip39.js';
// Generate 12-word mnemonic
const mnemonic = Bip39.generateMnemonic(128);
console.log(mnemonic); // "abandon abandon abandon..."
// Validate mnemonic
const isValid = Bip39.validateMnemonic(mnemonic);
// Derive seed
const seed = await Bip39.mnemonicToSeed(mnemonic, "optional passphrase");
```
***
### ENTROPY\_128
> `const` **ENTROPY\_128**: `128` = `128`
Defined in: [src/crypto/Bip39/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L13)
128 bits entropy = 12 words
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_128);
```
***
### ENTROPY\_160
> `const` **ENTROPY\_160**: `160` = `160`
Defined in: [src/crypto/Bip39/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L27)
160 bits entropy = 15 words
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_160);
```
***
### ENTROPY\_192
> `const` **ENTROPY\_192**: `192` = `192`
Defined in: [src/crypto/Bip39/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L41)
192 bits entropy = 18 words
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_192);
```
***
### ENTROPY\_224
> `const` **ENTROPY\_224**: `224` = `224`
Defined in: [src/crypto/Bip39/constants.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L55)
224 bits entropy = 21 words
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_224);
```
***
### ENTROPY\_256
> `const` **ENTROPY\_256**: `256` = `256`
Defined in: [src/crypto/Bip39/constants.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L69)
256 bits entropy = 24 words
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = Bip39.generateMnemonic(Bip39.ENTROPY_256);
```
***
### SEED\_LENGTH
> `const` **SEED\_LENGTH**: `64` = `64`
Defined in: [src/crypto/Bip39/constants.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/constants.js#L84)
BIP-39 seed length (512 bits / 64 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = await Bip39.mnemonicToSeed(mnemonic);
console.log(seed.length === Bip39.SEED_LENGTH);
```
## Functions
### assertValidMnemonic()
> **assertValidMnemonic**(`mnemonic`, `wl?`): `void`
Defined in: [src/crypto/Bip39/assertValidMnemonic.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/assertValidMnemonic.js#L24)
Validate mnemonic or throw error
#### Parameters
##### mnemonic
`string`
Mnemonic phrase to validate
##### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If mnemonic is invalid
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
try {
Bip39.assertValidMnemonic(mnemonic);
} catch (e) {
console.error("Invalid mnemonic:", e.message);
}
```
***
### entropyToMnemonic()
> **entropyToMnemonic**(`entropy`, `wl?`): `string`
Defined in: [src/crypto/Bip39/entropyToMnemonic.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/entropyToMnemonic.js#L22)
Generate mnemonic from custom entropy
#### Parameters
##### entropy
[`Entropy`](#entropy)
Entropy bytes (16, 20, 24, 28, or 32 bytes)
##### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
#### Returns
`string`
Mnemonic phrase
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If entropy size is invalid
#### Throws
If conversion fails
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const entropy = crypto.getRandomValues(new Uint8Array(32));
const mnemonic = Bip39.entropyToMnemonic(entropy);
```
***
### generateMnemonic()
> **generateMnemonic**(`strength?`, `wl?`): `string`
Defined in: [src/crypto/Bip39/generateMnemonic.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/generateMnemonic.js#L23)
Generate a BIP-39 mnemonic phrase
#### Parameters
##### strength?
Entropy strength in bits (128=12 words, 256=24 words)
`128` | `160` | `192` | `224` | `256`
##### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
#### Returns
`string`
Mnemonic phrase
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If mnemonic generation fails
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
// Generate 12-word mnemonic (128 bits)
const mnemonic12 = Bip39.generateMnemonic(128);
// Generate 24-word mnemonic (256 bits)
const mnemonic24 = Bip39.generateMnemonic(256);
```
***
### getEntropyBits()
> **getEntropyBits**(`wordCount`): `number`
Defined in: [src/crypto/Bip39/getEntropyBits.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/getEntropyBits.js#L18)
Get entropy bits from word count
#### Parameters
##### wordCount
`number`
Number of words
#### Returns
`number`
Entropy in bits
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If word count is invalid
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
Bip39.getEntropyBits(12); // 128
Bip39.getEntropyBits(24); // 256
```
***
### getWordCount()
> **getWordCount**(`entropyBits`): `number`
Defined in: [src/crypto/Bip39/getWordCount.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/getWordCount.js#L18)
Get word count from entropy bits
#### Parameters
##### entropyBits
`number`
Entropy in bits
#### Returns
`number`
Number of words in mnemonic
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If entropy bits value is invalid
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
Bip39.getWordCount(128); // 12
Bip39.getWordCount(256); // 24
```
***
### mnemonicToSeed()
> **mnemonicToSeed**(`mnemonic`, `passphrase?`): `Promise`\<[`Seed`](#seed)>
Defined in: [src/crypto/Bip39/mnemonicToSeed.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/mnemonicToSeed.js#L21)
Convert mnemonic to seed (async)
#### Parameters
##### mnemonic
`string`
BIP-39 mnemonic phrase
##### passphrase?
`string` = `""`
Optional passphrase for additional security
#### Returns
`Promise`\<[`Seed`](#seed)>
64-byte seed
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If mnemonic is invalid
#### Throws
If seed derivation fails
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = await Bip39.mnemonicToSeed(mnemonic, "my passphrase");
```
***
### mnemonicToSeedSync()
> **mnemonicToSeedSync**(`mnemonic`, `passphrase?`): [`Seed`](#seed)
Defined in: [src/crypto/Bip39/mnemonicToSeedSync.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/mnemonicToSeedSync.js#L21)
Convert mnemonic to seed (sync)
#### Parameters
##### mnemonic
`string`
BIP-39 mnemonic phrase
##### passphrase?
`string` = `""`
Optional passphrase for additional security
#### Returns
[`Seed`](#seed)
64-byte seed
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If mnemonic is invalid
#### Throws
If seed derivation fails
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const seed = Bip39.mnemonicToSeedSync(mnemonic);
```
***
### validateMnemonic()
> **validateMnemonic**(`mnemonic`, `wl?`): `boolean`
Defined in: [src/crypto/Bip39/validateMnemonic.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bip39/validateMnemonic.js#L22)
Validate a BIP-39 mnemonic phrase
#### Parameters
##### mnemonic
`string`
Mnemonic phrase to validate
##### wl?
`string`\[] = `wordlist`
Optional wordlist (defaults to English)
#### Returns
`boolean`
True if valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Bip39 from './crypto/Bip39/index.js';
const mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
if (Bip39.validateMnemonic(mnemonic)) {
console.log("Valid mnemonic");
}
```
# crypto/Blake2
Source: https://voltaire.tevm.sh/generated-api/crypto/Blake2
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Blake2
# crypto/Blake2
## Variables
### ~~Blake2~~
> `const` **Blake2**: (`input`, `outputLength?`) => [`Blake2Hash`](../index/index.mdx#blake2hash) & `object` = `Blake2Hash`
Defined in: [src/crypto/Blake2/Blake2.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/Blake2.js#L51)
#### Type Declaration
##### ~~from()~~
> **from**: (`input`, `outputLength?`) => [`Blake2Hash`](../index/index.mdx#blake2hash)
Hash input with BLAKE2b (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto/blake2](https://voltaire.tevm.sh/crypto/blake2) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import { Blake2Hash } from './crypto/Blake2/index.js';
const hash1 = Blake2Hash.from("hello"); // String, 64 bytes
const hash2 = Blake2Hash.from("hello", 32); // String, 32 bytes
const hash3 = Blake2Hash.from(uint8array); // Bytes, 64 bytes
const hash4 = Blake2Hash.from(uint8array, 48); // Bytes, 48 bytes
```
##### ~~fromString()~~
> **fromString**: (`str`, `outputLength?`) => [`Blake2Hash`](../index/index.mdx#blake2hash) = `hashString`
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
##### ~~hash()~~
> **hash**: (`data`, `outputLength?`) => [`Blake2Hash`](../index/index.mdx#blake2hash)
Hash data with BLAKE2b
###### Parameters
###### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2.hash("hello", 32);
```
##### ~~hashString()~~
> **hashString**: (`str`, `outputLength?`) => [`Blake2Hash`](../index/index.mdx#blake2hash)
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
##### ~~SIZE~~
> **SIZE**: `number`
#### Deprecated
Use Blake2Hash instead
Blake2 alias maintained for backward compatibility
***
### SIZE
> `const` **SIZE**: `64` = `64`
Defined in: [src/crypto/Blake2/Blake2HashType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/Blake2HashType.ts#L23)
## Functions
### compress()
> **compress**(`input`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Blake2/compress.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/compress.js#L41)
BLAKE2b F compression function (EIP-152 format)
#### Parameters
##### input
`Uint8Array`\<`ArrayBufferLike`>
213-byte input in EIP-152 format
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte output (updated state)
#### Throws
If input length is not 213 bytes
#### Example
```javascript theme={null}
import { compress } from './crypto/Blake2/compress.js';
const input = new Uint8Array(213);
// ... fill input with rounds, h, m, t, f
const output = compress(input);
```
***
### from()
> **from**(`input`, `outputLength?`): [`Blake2Hash`](../index/index.mdx#blake2hash)
Defined in: [src/crypto/Blake2/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/from.js#L27)
Hash input with BLAKE2b (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
#### Parameters
##### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
#### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
#### See
[https://voltaire.tevm.sh/crypto/blake2](https://voltaire.tevm.sh/crypto/blake2) for crypto documentation
#### Since
0.0.0
#### Throws
If outputLength is invalid
#### Example
```javascript theme={null}
import { Blake2Hash } from './crypto/Blake2/index.js';
const hash1 = Blake2Hash.from("hello"); // String, 64 bytes
const hash2 = Blake2Hash.from("hello", 32); // String, 32 bytes
const hash3 = Blake2Hash.from(uint8array); // Bytes, 64 bytes
const hash4 = Blake2Hash.from(uint8array, 48); // Bytes, 48 bytes
```
***
### hash()
> **hash**(`data`, `outputLength?`): [`Blake2Hash`](../index/index.mdx#blake2hash)
Defined in: [src/crypto/Blake2/hash.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/hash.js#L19)
Hash data with BLAKE2b
#### Parameters
##### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
#### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If outputLength is invalid
#### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2.hash("hello", 32);
```
***
### hashString()
> **hashString**(`str`, `outputLength?`): [`Blake2Hash`](../index/index.mdx#blake2hash)
Defined in: [src/crypto/Blake2/hashString.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/hashString.js#L19)
Hash string with BLAKE2b (convenience function)
#### Parameters
##### str
`string`
Input string to hash
##### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
#### Returns
[`Blake2Hash`](../index/index.mdx#blake2hash)
BLAKE2b hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If outputLength is invalid
#### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
## References
### Blake2Hash
Re-exports [Blake2Hash](../index/index.mdx#blake2hash)
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / crypto/Bls12381
# crypto/Bls12381
## Namespaces
* [Fp](namespaces/Fp.mdx)
* [Fp2](namespaces/Fp2.mdx)
* [Fr](namespaces/Fr.mdx)
* [G1](namespaces/G1.mdx)
* [G2](namespaces/G2.mdx)
* [Pairing](namespaces/Pairing.mdx)
## Classes
### Bls12381Error
Defined in: [src/crypto/Bls12381/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L12)
Base error class for BLS12-381 operations
#### Extends
* `Error`
#### Extended by
* [`InvalidPointError`](#invalidpointerror)
* [`InvalidSubgroupError`](#invalidsubgrouperror)
* [`InvalidScalarError`](#invalidscalarerror)
* [`InvalidFieldElementError`](#invalidfieldelementerror)
* [`PairingError`](#pairingerror)
* [`SignatureError`](#signatureerror)
#### Constructors
##### Constructor
> **new Bls12381Error**(`message`): [`Bls12381Error`](#bls12381error)
Defined in: [src/crypto/Bls12381/errors.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L16)
###### Parameters
###### message
`string`
###### Returns
[`Bls12381Error`](#bls12381error)
###### Overrides
`Error.constructor`
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L18)
###### Inherited from
`Error.name`
***
### InvalidFieldElementError
Defined in: [src/crypto/Bls12381/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L58)
Error thrown when field element is invalid
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new InvalidFieldElementError**(`reason?`): [`InvalidFieldElementError`](#invalidfieldelementerror)
Defined in: [src/crypto/Bls12381/errors.js:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L62)
###### Parameters
###### reason?
`string`
###### Returns
[`InvalidFieldElementError`](#invalidfieldelementerror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L64)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
***
### InvalidPointError
Defined in: [src/crypto/Bls12381/errors.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L25)
Error thrown when a point is not on the curve
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new InvalidPointError**(): [`InvalidPointError`](#invalidpointerror)
Defined in: [src/crypto/Bls12381/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L26)
###### Returns
[`InvalidPointError`](#invalidpointerror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L28)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
***
### InvalidScalarError
Defined in: [src/crypto/Bls12381/errors.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L45)
Error thrown when a scalar is invalid
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new InvalidScalarError**(`reason?`): [`InvalidScalarError`](#invalidscalarerror)
Defined in: [src/crypto/Bls12381/errors.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L49)
###### Parameters
###### reason?
`string`
###### Returns
[`InvalidScalarError`](#invalidscalarerror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L51)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
***
### InvalidSubgroupError
Defined in: [src/crypto/Bls12381/errors.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L35)
Error thrown when a point is not in the correct subgroup
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new InvalidSubgroupError**(): [`InvalidSubgroupError`](#invalidsubgrouperror)
Defined in: [src/crypto/Bls12381/errors.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L36)
###### Returns
[`InvalidSubgroupError`](#invalidsubgrouperror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L38)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
***
### PairingError
Defined in: [src/crypto/Bls12381/errors.js:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L71)
Error thrown when pairing check fails
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new PairingError**(`reason?`): [`PairingError`](#pairingerror)
Defined in: [src/crypto/Bls12381/errors.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L75)
###### Parameters
###### reason?
`string`
###### Returns
[`PairingError`](#pairingerror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L77)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
***
### SignatureError
Defined in: [src/crypto/Bls12381/errors.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L84)
Error thrown when signature operation fails
#### Extends
* [`Bls12381Error`](#bls12381error)
#### Constructors
##### Constructor
> **new SignatureError**(`reason?`): [`SignatureError`](#signatureerror)
Defined in: [src/crypto/Bls12381/errors.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L88)
###### Parameters
###### reason?
`string`
###### Returns
[`SignatureError`](#signatureerror)
###### Overrides
[`Bls12381Error`](#bls12381error).[`constructor`](#constructor)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Bls12381/errors.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/errors.js#L90)
###### Inherited from
[`Bls12381Error`](#bls12381error).[`name`](#name)
## Variables
### B\_G1
> `const` **B\_G1**: `bigint` = `4n`
Defined in: [src/crypto/Bls12381/constants.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L33)
G1 curve coefficient b = 4
y^2 = x^3 + 4 over Fp
***
### B\_G2
> `const` **B\_G2**: `object`
Defined in: [src/crypto/Bls12381/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L41)
G2 curve coefficient b = 4(1+i)
y^2 = x^3 + 4(1+i) over Fp2
Represented as \[4, 4] for the Fp2 element
#### Type Declaration
##### c0
> **c0**: `bigint`
##### c1
> **c1**: `bigint`
***
### BLS\_X
> `const` **BLS\_X**: `bigint` = `0xd201000000010000n`
Defined in: [src/crypto/Bls12381/constants.js:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L93)
BLS parameter x (used in Miller loop)
x = -0xd201000000010000 (negative)
***
### BLS\_X\_IS\_NEGATIVE
> `const` **BLS\_X\_IS\_NEGATIVE**: `boolean` = `true`
Defined in: [src/crypto/Bls12381/constants.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L99)
BLS parameter x is negative
***
### Bls12381
> `const` **Bls12381**: `object`
Defined in: [src/crypto/Bls12381/Bls12381.js:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Bls12381.js#L104)
Bls12381 main export
#### Type Declaration
##### aggregate()
> **aggregate**: (`signatures`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple BLS signatures into one
The aggregated signature can be verified against an aggregated public key
(when all signers signed the same message) or via batch verification
(when signers signed different messages).
###### Parameters
###### signatures
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G1 signatures (48 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (48 bytes compressed G1)
###### Throws
If aggregation fails or no signatures provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Vote for proposal');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
```
##### aggregatePublicKeys()
> **aggregatePublicKeys**: (`publicKeys`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple public keys into one
Used when multiple signers sign the same message and you want
to verify against a single aggregated public key.
###### Parameters
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G2 public keys (96 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated public key (96 bytes compressed G2)
###### Throws
If aggregation fails or no public keys provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const aggPubKey = Bls12381.aggregatePublicKeys([pubKey1, pubKey2]);
```
##### aggregateVerify()
> **aggregateVerify**: (`aggregatedSignature`, `message`, `publicKeys`) => `boolean`
Verify an aggregated signature where all signers signed the same message
This is the most common case in Ethereum consensus - multiple validators
sign the same block/attestation.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed by all parties
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys of all signers (48 bytes each)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Block attestation');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.aggregateVerify(aggSig, message, [pubKey1, pubKey2]);
console.log(isValid); // true
```
##### batchVerify()
> **batchVerify**: (`aggregatedSignature`, `messages`, `publicKeys`) => `boolean`
Verify an aggregated signature where each signer signed a different message
Uses multi-pairing verification: product of e(pk\_i, H(msg\_i)) == e(G1, aggSig)
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### messages
`Uint8Array`\<`ArrayBufferLike`>\[]
Messages that were signed (one per signer)
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys (one per signer, same order as messages)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Throws
If messages and publicKeys have different lengths
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const msg1 = new TextEncoder().encode('Message 1');
const msg2 = new TextEncoder().encode('Message 2');
const sig1 = Bls12381.sign(msg1, pk1);
const sig2 = Bls12381.sign(msg2, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.batchVerify(aggSig, [msg1, msg2], [pubKey1, pubKey2]);
console.log(isValid); // true
```
##### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Derive a BLS12-381 public key from a private key
Public key = privateKey \* G2\_generator
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
console.log(publicKey.length); // 96
```
##### derivePublicKeyPoint()
> **derivePublicKeyPoint**: (`privateKey`) => [`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Derive a BLS12-381 public key as a G1 point (uncompressed)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
[`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Throws
If private key is invalid
##### fastAggregateVerify()
> **fastAggregateVerify**: (`aggregatedSignature`, `message`, `aggregatedPublicKey`) => `boolean`
Fast aggregate verify (same message case)
Optimized for the common case where all signers signed the same message.
This is faster than aggregateVerify when you already have the aggregated public key.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed
###### aggregatedPublicKey
`Uint8Array`\<`ArrayBufferLike`>
Pre-computed aggregated public key (48 bytes)
###### Returns
`boolean`
True if valid
##### Fp
> **Fp**: [`Fp`](namespaces/Fp.mdx)
##### Fp2
> **Fp2**: [`Fp2`](namespaces/Fp2.mdx)
##### Fr
> **Fr**: [`Fr`](namespaces/Fr.mdx)
##### G1
> **G1**: [`G1`](namespaces/G1.mdx)
##### G2
> **G2**: [`G2`](namespaces/G2.mdx)
##### isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Check if a private key is valid
A valid private key must be:
* 32 bytes
* Non-zero
* Less than the curve order (Fr modulus)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key to validate
###### Returns
`boolean`
True if valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk = Bls12381.randomPrivateKey();
console.log(Bls12381.isValidPrivateKey(pk)); // true
const invalid = new Uint8Array(32); // all zeros
console.log(Bls12381.isValidPrivateKey(invalid)); // false
```
##### Pairing
> **Pairing**: [`Pairing`](namespaces/Pairing.mdx)
BLS12-381 Pairing Operations
Optimal Ate pairing implementation for BLS12-381.
e: G1 x G2 -> GT
NOTE: Full pairing implementation requires Fp6, Fp12 tower extensions
and Miller loop computation. For production use, the native blst
library should be used via the Zig FFI bindings.
This module provides the interface and simplified implementations
for testing and educational purposes.
###### See
[https://hackmd.io/@benjaminion/bls12-381](https://hackmd.io/@benjaminion/bls12-381) for pairing details
###### Since
0.0.0
##### randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a random BLS12-381 private key
Uses cryptographically secure random number generation.
The key is guaranteed to be valid (non-zero and less than curve order).
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
```
##### sign()
> **sign**: (`message`, `privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Sign a message using BLS12-381
Uses the Ethereum consensus "short signatures" scheme:
* Signature = privateKey \* H(message) where H maps to G1
* Signatures are 48 bytes (compressed G1 point)
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message to sign
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Signature as compressed G1 point (48 bytes)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const message = new TextEncoder().encode('Hello, Ethereum!');
const signature = Bls12381.sign(message, privateKey);
```
##### signPoint()
> **signPoint**: (`messagePoint`, `privateKey`) => [`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Sign a pre-hashed message (G2 point) using BLS12-381
For advanced use when you have already hashed the message to G2.
###### Parameters
###### messagePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Message as G2 point
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Signature as G2 point (projective)
###### Throws
If private key is invalid
###### Throws
If signing fails
##### verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify a BLS12-381 signature
Uses pairing check for verification.
###### Parameters
###### signature
`Uint8Array`\<`ArrayBufferLike`>
Compressed G1 signature (48 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message that was signed
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Returns
`boolean`
True if signature is valid
###### Throws
If verification fails due to invalid inputs
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
const message = new TextEncoder().encode('Hello!');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
console.log(isValid); // true
```
##### verifyPoint()
> **verifyPoint**: (`signaturePoint`, `messagePoint`, `publicKeyPoint`) => `boolean`
Verify a BLS signature with pre-computed points (advanced)
For use when you have already deserialized the points.
###### Parameters
###### signaturePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Signature as G2 point
###### messagePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Message hash as G2 point
###### publicKeyPoint
[`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Returns
`boolean`
True if signature is valid
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
// Generate keypair
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
// Sign and verify
const message = new TextEncoder().encode('Hello');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
```
***
### EMBEDDING\_DEGREE
> `const` **EMBEDDING\_DEGREE**: `number` = `12`
Defined in: [src/crypto/Bls12381/constants.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L86)
Embedding degree k = 12
***
### FP\_MOD
> `const` **FP\_MOD**: `bigint` = `0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn`
Defined in: [src/crypto/Bls12381/constants.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L17)
Base field modulus p (381 bits)
p = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
***
### FR\_MOD
> `const` **FR\_MOD**: `bigint` = `0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n`
Defined in: [src/crypto/Bls12381/constants.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L25)
Scalar field modulus r (curve order, 255 bits)
r = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001
***
### G1\_GENERATOR\_X
> `const` **G1\_GENERATOR\_X**: `bigint` = `0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bbn`
Defined in: [src/crypto/Bls12381/constants.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L47)
G1 generator x-coordinate
***
### G1\_GENERATOR\_Y
> `const` **G1\_GENERATOR\_Y**: `bigint` = `0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1n`
Defined in: [src/crypto/Bls12381/constants.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L54)
G1 generator y-coordinate
***
### G2\_COFACTOR
> `const` **G2\_COFACTOR**: `bigint` = `0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5n`
Defined in: [src/crypto/Bls12381/constants.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L79)
G2 cofactor h2 (large value)
***
### G2\_GENERATOR\_X
> `const` **G2\_GENERATOR\_X**: `object`
Defined in: [src/crypto/Bls12381/constants.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L61)
G2 generator x-coordinate (Fp2 element)
#### Type Declaration
##### c0
> **c0**: `bigint`
##### c1
> **c1**: `bigint`
***
### G2\_GENERATOR\_Y
> `const` **G2\_GENERATOR\_Y**: `object`
Defined in: [src/crypto/Bls12381/constants.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/constants.js#L70)
G2 generator y-coordinate (Fp2 element)
#### Type Declaration
##### c0
> **c0**: `bigint`
##### c1
> **c1**: `bigint`
## Functions
### aggregate()
> **aggregate**(`signatures`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Bls12381/aggregate.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/aggregate.js#L43)
Aggregate multiple BLS signatures into one
The aggregated signature can be verified against an aggregated public key
(when all signers signed the same message) or via batch verification
(when signers signed different messages).
#### Parameters
##### signatures
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G1 signatures (48 bytes each)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (48 bytes compressed G1)
#### Throws
If aggregation fails or no signatures provided
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Vote for proposal');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
```
***
### aggregatePublicKeys()
> **aggregatePublicKeys**(`publicKeys`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Bls12381/aggregate.js:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/aggregate.js#L89)
Aggregate multiple public keys into one
Used when multiple signers sign the same message and you want
to verify against a single aggregated public key.
#### Parameters
##### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G2 public keys (96 bytes each)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated public key (96 bytes compressed G2)
#### Throws
If aggregation fails or no public keys provided
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const aggPubKey = Bls12381.aggregatePublicKeys([pubKey1, pubKey2]);
```
***
### aggregateVerify()
> **aggregateVerify**(`aggregatedSignature`, `message`, `publicKeys`): `boolean`
Defined in: [src/crypto/Bls12381/aggregateVerify.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/aggregateVerify.js#L47)
Verify an aggregated signature where all signers signed the same message
This is the most common case in Ethereum consensus - multiple validators
sign the same block/attestation.
#### Parameters
##### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
##### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed by all parties
##### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys of all signers (48 bytes each)
#### Returns
`boolean`
True if the aggregated signature is valid
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Block attestation');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.aggregateVerify(aggSig, message, [pubKey1, pubKey2]);
console.log(isValid); // true
```
***
### batchVerify()
> **batchVerify**(`aggregatedSignature`, `messages`, `publicKeys`): `boolean`
Defined in: [src/crypto/Bls12381/aggregateVerify.js:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/aggregateVerify.js#L105)
Verify an aggregated signature where each signer signed a different message
Uses multi-pairing verification: product of e(pk\_i, H(msg\_i)) == e(G1, aggSig)
#### Parameters
##### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
##### messages
`Uint8Array`\<`ArrayBufferLike`>\[]
Messages that were signed (one per signer)
##### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys (one per signer, same order as messages)
#### Returns
`boolean`
True if the aggregated signature is valid
#### Throws
If messages and publicKeys have different lengths
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const msg1 = new TextEncoder().encode('Message 1');
const msg2 = new TextEncoder().encode('Message 2');
const sig1 = Bls12381.sign(msg1, pk1);
const sig2 = Bls12381.sign(msg2, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.batchVerify(aggSig, [msg1, msg2], [pubKey1, pubKey2]);
console.log(isValid); // true
```
***
### derivePublicKey()
> **derivePublicKey**(`privateKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Bls12381/derivePublicKey.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/derivePublicKey.js#L38)
Derive a BLS12-381 public key from a private key
Public key = privateKey \* G2\_generator
#### Parameters
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
#### Throws
If private key is invalid
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
console.log(publicKey.length); // 96
```
***
### derivePublicKeyPoint()
> **derivePublicKeyPoint**(`privateKey`): [`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/derivePublicKey.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/derivePublicKey.js#L80)
Derive a BLS12-381 public key as a G1 point (uncompressed)
#### Parameters
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
#### Returns
[`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Public key as G1 point
#### Throws
If private key is invalid
***
### fastAggregateVerify()
> **fastAggregateVerify**(`aggregatedSignature`, `message`, `aggregatedPublicKey`): `boolean`
Defined in: [src/crypto/Bls12381/aggregateVerify.js:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/aggregateVerify.js#L148)
Fast aggregate verify (same message case)
Optimized for the common case where all signers signed the same message.
This is faster than aggregateVerify when you already have the aggregated public key.
#### Parameters
##### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
##### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed
##### aggregatedPublicKey
`Uint8Array`\<`ArrayBufferLike`>
Pre-computed aggregated public key (48 bytes)
#### Returns
`boolean`
True if valid
***
### isValidPrivateKey()
> **isValidPrivateKey**(`privateKey`): `boolean`
Defined in: [src/crypto/Bls12381/randomPrivateKey.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/randomPrivateKey.js#L55)
Check if a private key is valid
A valid private key must be:
* 32 bytes
* Non-zero
* Less than the curve order (Fr modulus)
#### Parameters
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key to validate
#### Returns
`boolean`
True if valid
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk = Bls12381.randomPrivateKey();
console.log(Bls12381.isValidPrivateKey(pk)); // true
const invalid = new Uint8Array(32); // all zeros
console.log(Bls12381.isValidPrivateKey(invalid)); // false
```
***
### randomPrivateKey()
> **randomPrivateKey**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Bls12381/randomPrivateKey.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/randomPrivateKey.js#L29)
Generate a random BLS12-381 private key
Uses cryptographically secure random number generation.
The key is guaranteed to be valid (non-zero and less than curve order).
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
```
***
### sign()
> **sign**(`message`, `privateKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Bls12381/sign.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/sign.js#L44)
Sign a message using BLS12-381
Uses the Ethereum consensus "short signatures" scheme:
* Signature = privateKey \* H(message) where H maps to G1
* Signatures are 48 bytes (compressed G1 point)
#### Parameters
##### message
`Uint8Array`\<`ArrayBufferLike`>
Message to sign
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Signature as compressed G1 point (48 bytes)
#### Throws
If private key is invalid
#### Throws
If signing fails
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const message = new TextEncoder().encode('Hello, Ethereum!');
const signature = Bls12381.sign(message, privateKey);
```
***
### signPoint()
> **signPoint**(`messagePoint`, `privateKey`): [`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/sign.js:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/sign.js#L91)
Sign a pre-hashed message (G2 point) using BLS12-381
For advanced use when you have already hashed the message to G2.
#### Parameters
##### messagePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Message as G2 point
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
#### Returns
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Signature as G2 point (projective)
#### Throws
If private key is invalid
#### Throws
If signing fails
***
### verify()
> **verify**(`signature`, `message`, `publicKey`): `boolean`
Defined in: [src/crypto/Bls12381/verify.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/verify.js#L41)
Verify a BLS12-381 signature
Uses pairing check for verification.
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
Compressed G1 signature (48 bytes)
##### message
`Uint8Array`\<`ArrayBufferLike`>
Original message that was signed
##### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
#### Returns
`boolean`
True if signature is valid
#### Throws
If verification fails due to invalid inputs
#### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
const message = new TextEncoder().encode('Hello!');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
console.log(isValid); // true
```
***
### verifyPoint()
> **verifyPoint**(`signaturePoint`, `messagePoint`, `publicKeyPoint`): `boolean`
Defined in: [src/crypto/Bls12381/verify.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/verify.js#L78)
Verify a BLS signature with pre-computed points (advanced)
For use when you have already deserialized the points.
#### Parameters
##### signaturePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Signature as G2 point
##### messagePoint
[`Bls12381G2PointType`](../../index/index.mdx#bls12381g2pointtype)
Message hash as G2 point
##### publicKeyPoint
[`Bls12381G1PointType`](../../index/index.mdx#bls12381g1pointtype)
Public key as G1 point
#### Returns
`boolean`
True if signature is valid
## References
### Fp2Type
Renames and re-exports [Bls12381Fp2Type](../../index/index.mdx#bls12381fp2type)
***
### G1PointType
Renames and re-exports [Bls12381G1PointType](../../index/index.mdx#bls12381g1pointtype)
***
### G2PointType
Renames and re-exports [Bls12381G2PointType](../../index/index.mdx#bls12381g2pointtype)
# Fp
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/Fp
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / Fp
# Fp
## Functions
### add()
> **add**(`a`, `b`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/add.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/add.js#L10)
Add two field elements
#### Parameters
##### a
`bigint`
First operand
##### b
`bigint`
Second operand
#### Returns
`bigint`
(a + b) mod p
***
### inv()
> **inv**(`a`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/inv.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/inv.js#L12)
Compute modular inverse using Fermat's little theorem
a^(-1) = a^(p-2) mod p
#### Parameters
##### a
`bigint`
Value to invert
#### Returns
`bigint`
a^(-1) mod p
#### Throws
If a is zero
***
### mod()
> **mod**(`a`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/mod.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/mod.js#L9)
Reduce a bigint modulo the field prime p
#### Parameters
##### a
`bigint`
Value to reduce
#### Returns
`bigint`
Value reduced to \[0, p-1]
***
### mul()
> **mul**(`a`, `b`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/mul.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/mul.js#L10)
Multiply two field elements
#### Parameters
##### a
`bigint`
First operand
##### b
`bigint`
Second operand
#### Returns
`bigint`
(a \* b) mod p
***
### neg()
> **neg**(`a`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/neg.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/neg.js#L9)
Negate a field element
#### Parameters
##### a
`bigint`
Value to negate
#### Returns
`bigint`
-a mod p
***
### pow()
> **pow**(`base`, `exp`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/pow.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/pow.js#L10)
Modular exponentiation using square-and-multiply
#### Parameters
##### base
`bigint`
Base value
##### exp
`bigint`
Exponent
#### Returns
`bigint`
base^exp mod p
***
### sqrt()
> **sqrt**(`a`): `bigint` | `null`
Defined in: [src/crypto/Bls12381/Fp/sqrt.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/sqrt.js#L19)
Compute square root in Fp (if it exists)
For BLS12-381, p = 3 mod 4, so we use Tonelli-Shanks simplification:
sqrt(a) = a^((p+1)/4) mod p
#### Parameters
##### a
`bigint`
Value to take square root of
#### Returns
`bigint` | `null`
Square root if it exists, null otherwise
***
### sub()
> **sub**(`a`, `b`): `bigint`
Defined in: [src/crypto/Bls12381/Fp/sub.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp/sub.js#L10)
Subtract two field elements
#### Parameters
##### a
`bigint`
First operand
##### b
`bigint`
Second operand
#### Returns
`bigint`
(a - b) mod p
# Fp2
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/Fp2
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / Fp2
# Fp2
## Functions
### add()
> **add**(`a`, `b`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/add.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/add.js#L11)
Add two Fp2 elements
(a0 + a1*i) + (b0 + b1*i) = (a0+b0) + (a1+b1)\*i
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
First operand
##### b
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Second operand
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### conjugate()
> **conjugate**(`a`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/conjugate.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/conjugate.js#L10)
Compute conjugate of Fp2 element
conj(a0 + a1*i) = a0 - a1*i
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Value to conjugate
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### create()
> **create**(`c0`, `c1`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/create.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/create.js#L10)
Create an Fp2 element from two Fp elements
#### Parameters
##### c0
`bigint`
Real component
##### c1
`bigint`
Imaginary component
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### equal()
> **equal**(`a`, `b`): `boolean`
Defined in: [src/crypto/Bls12381/Fp2/equal.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/equal.js#L8)
Check if two Fp2 elements are equal
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
First operand
##### b
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Second operand
#### Returns
`boolean`
***
### inv()
> **inv**(`a`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/inv.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/inv.js#L11)
Invert an Fp2 element
1/(a0 + a1*i) = (a0 - a1*i) / (a0^2 + a1^2)
The denominator is in Fp since (a0 + a1*i)(a0 - a1*i) = a0^2 + a1^2
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Value to invert
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### isZero()
> **isZero**(`a`): `boolean`
Defined in: [src/crypto/Bls12381/Fp2/isZero.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/isZero.js#L7)
Check if an Fp2 element is zero
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Value to check
#### Returns
`boolean`
***
### mul()
> **mul**(`a`, `b`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/mul.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/mul.js#L12)
Multiply two Fp2 elements
(a0 + a1*i) \* (b0 + b1*i) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)\*i
Using Karatsuba: 3 multiplications instead of 4
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
First operand
##### b
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Second operand
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### mulScalar()
> **mulScalar**(`a`, `scalar`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/mulScalar.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/mulScalar.js#L10)
Multiply Fp2 element by Fp scalar
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Fp2 element
##### scalar
`bigint`
Fp scalar
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### neg()
> **neg**(`a`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/neg.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/neg.js#L10)
Negate an Fp2 element
-(a0 + a1\*i) = -a0 + (-a1)\*i
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Value to negate
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### square()
> **square**(`a`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/square.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/square.js#L11)
Square an Fp2 element
(a0 + a1*i)^2 = (a0^2 - a1^2) + 2*a0*a1*i
Optimized: uses 2 muls instead of 3
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Value to square
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
***
### sub()
> **sub**(`a`, `b`): [`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Defined in: [src/crypto/Bls12381/Fp2/sub.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2/sub.js#L11)
Subtract two Fp2 elements
(a0 + a1*i) - (b0 + b1*i) = (a0-b0) + (a1-b1)\*i
#### Parameters
##### a
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
First operand
##### b
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
Second operand
#### Returns
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
# Fr
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/Fr
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / Fr
# Fr
## Functions
### isValid()
> **isValid**(`scalar`): `boolean`
Defined in: [src/crypto/Bls12381/Fr/isValid.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fr/isValid.js#L9)
Check if a scalar is valid (in the range \[0, r-1])
#### Parameters
##### scalar
`bigint`
Scalar to check
#### Returns
`boolean`
True if valid
***
### mod()
> **mod**(`a`): `bigint`
Defined in: [src/crypto/Bls12381/Fr/mod.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fr/mod.js#L9)
Reduce a bigint modulo the scalar field order r
#### Parameters
##### a
`bigint`
Value to reduce
#### Returns
`bigint`
Value reduced to \[0, r-1]
# G1
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/G1
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / G1
# G1
## Functions
### add()
> **add**(`p1`, `p2`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/add.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/add.js#L14)
Add two G1 points using Jacobian coordinates
Algorithm: [https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-add-2007-bl](https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-add-2007-bl)
#### Parameters
##### p1
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
First point
##### p2
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Second point
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### double()
> **double**(`point`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/double.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/double.js#L12)
Double a G1 point using Jacobian coordinates
Algorithm: [https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl](https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl)
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to double
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### equal()
> **equal**(`p1`, `p2`): `boolean`
Defined in: [src/crypto/Bls12381/G1/equal.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/equal.js#L12)
Check if two G1 points are equal
In Jacobian coordinates: P1 = P2 iff X1*Z2^2 = X2*Z1^2 and Y1*Z2^3 = Y2*Z1^3
#### Parameters
##### p1
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
First point
##### p2
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Second point
#### Returns
`boolean`
***
### fromAffine()
> **fromAffine**(`x`, `y`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/fromAffine.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/fromAffine.js#L10)
Create G1 point from affine coordinates
#### Parameters
##### x
`bigint`
x-coordinate
##### y
`bigint`
y-coordinate
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### generator()
> **generator**(): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/generator.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/generator.js#L8)
Return the generator point for G1
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### infinity()
> **infinity**(): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/infinity.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/infinity.js#L6)
Return the point at infinity (identity element) for G1
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### isOnCurve()
> **isOnCurve**(`point`): `boolean`
Defined in: [src/crypto/Bls12381/G1/isOnCurve.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/isOnCurve.js#L13)
Check if a G1 point is on the curve y^2 = x^3 + 4
In Jacobian projective coordinates where (X, Y, Z) represents (X/Z^2, Y/Z^3):
Y^2 = X^3 + b\*Z^6
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to check
#### Returns
`boolean`
***
### isZero()
> **isZero**(`point`): `boolean`
Defined in: [src/crypto/Bls12381/G1/isZero.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/isZero.js#L7)
Check if a G1 point is the point at infinity
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to check
#### Returns
`boolean`
***
### mul()
> **mul**(`point`, `scalar`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/mul.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/mul.js#L14)
Scalar multiplication of G1 point using double-and-add
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to multiply
##### scalar
`bigint`
Scalar multiplier
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### negate()
> **negate**(`point`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/negate.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/negate.js#L10)
Negate a G1 point (reflect over x-axis)
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to negate
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
***
### toAffine()
> **toAffine**(`point`): [`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Defined in: [src/crypto/Bls12381/G1/toAffine.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1/toAffine.js#L12)
Convert G1 point from projective to affine coordinates
Affine: (x/z^2, y/z^3, 1)
#### Parameters
##### point
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Point to convert
#### Returns
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
# G2
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/G2
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / G2
# G2
## Functions
### add()
> **add**(`p1`, `p2`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/add.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/add.js#L14)
Add two G2 points using Jacobian coordinates
Algorithm: [https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-add-2007-bl](https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#addition-add-2007-bl)
#### Parameters
##### p1
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
First point
##### p2
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Second point
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### double()
> **double**(`point`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/double.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/double.js#L12)
Double a G2 point using Jacobian coordinates
Algorithm: [https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl](https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html#doubling-dbl-2007-bl)
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to double
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### equal()
> **equal**(`p1`, `p2`): `boolean`
Defined in: [src/crypto/Bls12381/G2/equal.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/equal.js#L12)
Check if two G2 points are equal
In Jacobian coordinates: P1 = P2 iff X1*Z2^2 = X2*Z1^2 and Y1*Z2^3 = Y2*Z1^3
#### Parameters
##### p1
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
First point
##### p2
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Second point
#### Returns
`boolean`
***
### fromAffine()
> **fromAffine**(`x`, `y`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/fromAffine.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/fromAffine.js#L10)
Create G2 point from affine coordinates
#### Parameters
##### x
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
x-coordinate (Fp2)
##### y
[`Bls12381Fp2Type`](../../../index/index.mdx#bls12381fp2type)
y-coordinate (Fp2)
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### generator()
> **generator**(): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/generator.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/generator.js#L8)
Return the generator point for G2
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### infinity()
> **infinity**(): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/infinity.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/infinity.js#L6)
Return the point at infinity (identity element) for G2
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### isOnCurve()
> **isOnCurve**(`point`): `boolean`
Defined in: [src/crypto/Bls12381/G2/isOnCurve.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/isOnCurve.js#L13)
Check if a G2 point is on the curve y^2 = x^3 + 4(1+i)
In Jacobian projective coordinates where (X, Y, Z) represents (X/Z^2, Y/Z^3):
Y^2 = X^3 + b\*Z^6
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to check
#### Returns
`boolean`
***
### isZero()
> **isZero**(`point`): `boolean`
Defined in: [src/crypto/Bls12381/G2/isZero.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/isZero.js#L9)
Check if a G2 point is the point at infinity
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to check
#### Returns
`boolean`
***
### mul()
> **mul**(`point`, `scalar`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/mul.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/mul.js#L14)
Scalar multiplication of G2 point using double-and-add
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to multiply
##### scalar
`bigint`
Scalar multiplier
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### negate()
> **negate**(`point`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/negate.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/negate.js#L10)
Negate a G2 point (reflect over x-axis)
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to negate
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
***
### toAffine()
> **toAffine**(`point`): [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Defined in: [src/crypto/Bls12381/G2/toAffine.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2/toAffine.js#L12)
Convert G2 point from projective to affine coordinates
Affine: (x/z^2, y/z^3, 1)
#### Parameters
##### point
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Point to convert
#### Returns
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
# Pairing
Source: https://voltaire.tevm.sh/generated-api/crypto/Bls12381/namespaces/Pairing
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [crypto/Bls12381](../index.mdx) / Pairing
# Pairing
## Functions
### batchVerify()
> **batchVerify**(`items`): `boolean`
Defined in: [src/crypto/Bls12381/Pairing/index.js:136](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Pairing/index.js#L136)
Batch verify multiple BLS signatures on different messages
#### Parameters
##### items
`object`\[]
Array of signature verification items
#### Returns
`boolean`
True if all signatures are valid
#### Throws
***
### pair()
> **pair**(`p`, `q`): `never`
Defined in: [src/crypto/Bls12381/Pairing/index.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Pairing/index.js#L69)
Compute single pairing e(P, Q)
#### Parameters
##### p
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
G1 point
##### q
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
G2 point
#### Returns
`never`
Throws - not implemented in pure JS
#### Throws
***
### pairingCheck()
> **pairingCheck**(`pairs`): `boolean`
Defined in: [src/crypto/Bls12381/Pairing/index.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Pairing/index.js#L32)
Pairing check: verify that product of pairings equals identity
e(P1, Q1) \* e(P2, Q2) \* ... \* e(Pn, Qn) = 1
This is the core operation used in BLS signature verification.
#### Parameters
##### pairs
\[[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype), [`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)]\[]
Array of (G1, G2) point pairs
#### Returns
`boolean`
True if pairing product equals identity
#### Throws
If any point is invalid
***
### verifyAggregateSignature()
> **verifyAggregateSignature**(`aggregatedSignature`, `aggregatedPublicKey`, `messagePoint`): `boolean`
Defined in: [src/crypto/Bls12381/Pairing/index.js:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Pairing/index.js#L117)
Verify aggregate BLS signature (same message)
All signers signed the same message.
#### Parameters
##### aggregatedSignature
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Aggregated signature (G1 point)
##### aggregatedPublicKey
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Aggregated public key (G2 point)
##### messagePoint
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Hashed message (G1 point)
#### Returns
`boolean`
True if aggregate signature is valid
#### Throws
***
### verifySignature()
> **verifySignature**(`signature`, `publicKey`, `messagePoint`): `boolean`
Defined in: [src/crypto/Bls12381/Pairing/index.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Pairing/index.js#L97)
Verify BLS signature using pairing check
Verifies: e(signature, G2\_generator) = e(H(message), publicKey)
Equivalent to: e(signature, G2\_gen) \* e(-H(msg), pubKey) = 1
#### Parameters
##### signature
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Signature (G1 point)
##### publicKey
[`Bls12381G2PointType`](../../../index/index.mdx#bls12381g2pointtype)
Public key (G2 point)
##### messagePoint
[`Bls12381G1PointType`](../../../index/index.mdx#bls12381g1pointtype)
Hashed message (G1 point)
#### Returns
`boolean`
True if signature is valid
#### Throws
# crypto/ChaCha20Poly1305
Source: https://voltaire.tevm.sh/generated-api/crypto/ChaCha20Poly1305
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/ChaCha20Poly1305
# crypto/ChaCha20Poly1305
## Classes
### ChaCha20Poly1305Error
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L21)
Base error for ChaCha20-Poly1305 operations
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { ChaCha20Poly1305Error } from './crypto/ChaCha20Poly1305/index.js';
throw new ChaCha20Poly1305Error('Operation failed', {
code: 'CHACHA20_POLY1305_ERROR',
context: { operation: 'encrypt' },
docsPath: '/crypto/chacha20poly1305#error-handling',
cause: originalError
});
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`InvalidKeyError`](#invalidkeyerror)
* [`InvalidNonceError`](#invalidnonceerror)
* [`DecryptionError`](#decryptionerror)
#### Constructors
##### Constructor
> **new ChaCha20Poly1305Error**(`message`, `options?`): [`ChaCha20Poly1305Error`](#chacha20poly1305error)
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L26)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`ChaCha20Poly1305Error`](#chacha20poly1305error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L33)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### DecryptionError
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L118)
Decryption failure error
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { DecryptionError } from './crypto/ChaCha20Poly1305/index.js';
throw new DecryptionError('Authentication failed', {
code: 'CHACHA20_POLY1305_DECRYPTION_FAILED',
context: { operation: 'decrypt' },
docsPath: '/crypto/chacha20poly1305#error-handling',
cause: originalError
});
```
#### Extends
* [`ChaCha20Poly1305Error`](#chacha20poly1305error)
#### Constructors
##### Constructor
> **new DecryptionError**(`message`, `options?`): [`DecryptionError`](#decryptionerror)
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L123)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`DecryptionError`](#decryptionerror)
###### Overrides
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L130)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`toJSON`](#tojson)
***
### InvalidKeyError
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L53)
Invalid key error
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidKeyError } from './crypto/ChaCha20Poly1305/index.js';
throw new InvalidKeyError('Invalid key size', {
code: 'CHACHA20_POLY1305_INVALID_KEY_SIZE',
context: { size: 16, expected: 32 },
docsPath: '/crypto/chacha20poly1305#error-handling'
});
```
#### Extends
* [`ChaCha20Poly1305Error`](#chacha20poly1305error)
#### Constructors
##### Constructor
> **new InvalidKeyError**(`message`, `options?`): [`InvalidKeyError`](#invalidkeyerror)
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L58)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidKeyError`](#invalidkeyerror)
###### Overrides
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L65)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`toJSON`](#tojson)
***
### InvalidNonceError
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L85)
Invalid nonce error
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidNonceError } from './crypto/ChaCha20Poly1305/index.js';
throw new InvalidNonceError('Nonce must be 12 bytes', {
code: 'CHACHA20_POLY1305_INVALID_NONCE_LENGTH',
context: { length: 8, expected: 12 },
docsPath: '/crypto/chacha20poly1305#error-handling'
});
```
#### Extends
* [`ChaCha20Poly1305Error`](#chacha20poly1305error)
#### Constructors
##### Constructor
> **new InvalidNonceError**(`message`, `options?`): [`InvalidNonceError`](#invalidnonceerror)
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L90)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidNonceError`](#invalidnonceerror)
###### Overrides
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/ChaCha20Poly1305/errors.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/errors.js#L97)
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ChaCha20Poly1305Error`](#chacha20poly1305error).[`toJSON`](#tojson)
## Variables
### ChaCha20Poly1305
> `const` **ChaCha20Poly1305**: `object`
Defined in: [src/crypto/ChaCha20Poly1305/ChaCha20Poly1305.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/ChaCha20Poly1305.js#L39)
ChaCha20-Poly1305 Authenticated Encryption (RFC 8439)
Provides authenticated encryption using ChaCha20 stream cipher
with Poly1305 MAC. Optimized for software implementations.
Uses @noble/ciphers for cryptographic operations.
#### Type Declaration
##### decrypt()
> **decrypt**: (`ciphertext`, `key`, `nonce`, `additionalData?`) => `Uint8Array`\<`ArrayBufferLike`>
Decrypt data with ChaCha20-Poly1305
###### Parameters
###### ciphertext
`Uint8Array`\<`ArrayBufferLike`>
Encrypted data with authentication tag
###### key
`Uint8Array`\<`ArrayBufferLike`>
32-byte key (256 bits)
###### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (96 bits) used during encryption
###### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decrypted plaintext
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
If key is not 32 bytes
###### Throws
If nonce is not 12 bytes
###### Throws
If authentication fails or decryption error
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const key = ChaCha20Poly1305.generateKey();
const nonce = ChaCha20Poly1305.generateNonce();
const decrypted = ChaCha20Poly1305.decrypt(ciphertext, key, nonce);
const message = new TextDecoder().decode(decrypted);
```
##### encrypt()
> **encrypt**: (`plaintext`, `key`, `nonce`, `additionalData?`) => `Uint8Array`\<`ArrayBufferLike`>
Encrypt data with ChaCha20-Poly1305
###### Parameters
###### plaintext
`Uint8Array`\<`ArrayBufferLike`>
Data to encrypt
###### key
`Uint8Array`\<`ArrayBufferLike`>
32-byte key (256 bits)
###### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (96 bits)
###### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Ciphertext with authentication tag appended (16 bytes)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
If key is not 32 bytes
###### Throws
If nonce is not 12 bytes
###### Throws
If encryption fails
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const plaintext = new TextEncoder().encode('Secret message');
const key = ChaCha20Poly1305.generateKey();
const nonce = ChaCha20Poly1305.generateNonce();
const ciphertext = ChaCha20Poly1305.encrypt(plaintext, key, nonce);
```
##### generateKey()
> **generateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate random ChaCha20-Poly1305 key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte random key (256 bits)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const key = ChaCha20Poly1305.generateKey();
console.log(key.length); // 32
```
##### generateNonce()
> **generateNonce**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate random nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
12-byte random nonce (96 bits)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const nonce = ChaCha20Poly1305.generateNonce();
console.log(nonce.length); // 12
```
##### KEY\_SIZE
> **KEY\_SIZE**: `number`
ChaCha20-Poly1305 key size in bytes (256 bits)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const keyBytes = new Uint8Array(ChaCha20Poly1305.KEY_SIZE);
```
##### NONCE\_SIZE
> **NONCE\_SIZE**: `number`
Nonce/IV size in bytes (96 bits)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const nonce = new Uint8Array(ChaCha20Poly1305.NONCE_SIZE);
```
##### TAG\_SIZE
> **TAG\_SIZE**: `number`
Authentication tag size in bytes (128 bits)
###### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
console.log('Tag size:', ChaCha20Poly1305.TAG_SIZE);
```
#### Example
```typescript theme={null}
import { ChaCha20Poly1305 } from './ChaCha20Poly1305.js';
// Generate key
const key = ChaCha20Poly1305.generateKey();
// Encrypt data
const plaintext = new TextEncoder().encode('Hello, world!');
const nonce = ChaCha20Poly1305.generateNonce();
const ciphertext = ChaCha20Poly1305.encrypt(plaintext, key, nonce);
// Decrypt data
const decrypted = ChaCha20Poly1305.decrypt(ciphertext, key, nonce);
```
***
### KEY\_SIZE
> `const` **KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/ChaCha20Poly1305/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/constants.js#L13)
ChaCha20-Poly1305 key size in bytes (256 bits)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const keyBytes = new Uint8Array(ChaCha20Poly1305.KEY_SIZE);
```
***
### NONCE\_SIZE
> `const` **NONCE\_SIZE**: `12` = `12`
Defined in: [src/crypto/ChaCha20Poly1305/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/constants.js#L27)
Nonce/IV size in bytes (96 bits)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const nonce = new Uint8Array(ChaCha20Poly1305.NONCE_SIZE);
```
***
### TAG\_SIZE
> `const` **TAG\_SIZE**: `16` = `16`
Defined in: [src/crypto/ChaCha20Poly1305/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/constants.js#L41)
Authentication tag size in bytes (128 bits)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
console.log('Tag size:', ChaCha20Poly1305.TAG_SIZE);
```
## Functions
### decrypt()
> **decrypt**(`ciphertext`, `key`, `nonce`, `additionalData?`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/ChaCha20Poly1305/decrypt.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/decrypt.js#L31)
Decrypt data with ChaCha20-Poly1305
#### Parameters
##### ciphertext
`Uint8Array`\<`ArrayBufferLike`>
Encrypted data with authentication tag
##### key
`Uint8Array`\<`ArrayBufferLike`>
32-byte key (256 bits)
##### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (96 bits) used during encryption
##### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decrypted plaintext
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
If key is not 32 bytes
#### Throws
If nonce is not 12 bytes
#### Throws
If authentication fails or decryption error
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const key = ChaCha20Poly1305.generateKey();
const nonce = ChaCha20Poly1305.generateNonce();
const decrypted = ChaCha20Poly1305.decrypt(ciphertext, key, nonce);
const message = new TextDecoder().decode(decrypted);
```
***
### encrypt()
> **encrypt**(`plaintext`, `key`, `nonce`, `additionalData?`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/ChaCha20Poly1305/encrypt.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/encrypt.js#L31)
Encrypt data with ChaCha20-Poly1305
#### Parameters
##### plaintext
`Uint8Array`\<`ArrayBufferLike`>
Data to encrypt
##### key
`Uint8Array`\<`ArrayBufferLike`>
32-byte key (256 bits)
##### nonce
`Uint8Array`\<`ArrayBufferLike`>
12-byte nonce (96 bits)
##### additionalData?
`Uint8Array`\<`ArrayBufferLike`>
Optional additional authenticated data
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Ciphertext with authentication tag appended (16 bytes)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
If key is not 32 bytes
#### Throws
If nonce is not 12 bytes
#### Throws
If encryption fails
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const plaintext = new TextEncoder().encode('Secret message');
const key = ChaCha20Poly1305.generateKey();
const nonce = ChaCha20Poly1305.generateNonce();
const ciphertext = ChaCha20Poly1305.encrypt(plaintext, key, nonce);
```
***
### generateKey()
> **generateKey**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/ChaCha20Poly1305/generateKey.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/generateKey.js#L17)
Generate random ChaCha20-Poly1305 key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte random key (256 bits)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const key = ChaCha20Poly1305.generateKey();
console.log(key.length); // 32
```
***
### generateNonce()
> **generateNonce**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/ChaCha20Poly1305/generateNonce.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ChaCha20Poly1305/generateNonce.js#L17)
Generate random nonce
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
12-byte random nonce (96 bits)
#### See
[https://voltaire.tevm.sh/crypto/chacha20poly1305](https://voltaire.tevm.sh/crypto/chacha20poly1305) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ChaCha20Poly1305 from './crypto/ChaCha20Poly1305/index.js';
const nonce = ChaCha20Poly1305.generateNonce();
console.log(nonce.length); // 12
```
# crypto/EIP712
Source: https://voltaire.tevm.sh/generated-api/crypto/EIP712
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/EIP712
# crypto/EIP712
## Classes
### Eip712EncodingError
Defined in: [src/crypto/EIP712/errors.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L45)
EIP-712 encoding error
#### Example
```javascript theme={null}
throw new Eip712EncodingError('Failed to encode value', {
code: 'EIP712_ENCODING_ERROR',
context: { type: 'address', value: '0x...' },
docsPath: '/crypto/eip712/encode-value#error-handling',
cause: originalError
})
```
#### Extends
* [`Eip712Error`](#eip712error)
#### Constructors
##### Constructor
> **new Eip712EncodingError**(`message`, `options?`): [`Eip712EncodingError`](#eip712encodingerror)
Defined in: [src/crypto/EIP712/errors.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L50)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Eip712EncodingError`](#eip712encodingerror)
###### Overrides
[`Eip712Error`](#eip712error).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`Eip712Error`](#eip712error).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`Eip712Error`](#eip712error).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`docsPath`](#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/EIP712/errors.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L57)
###### Inherited from
[`Eip712Error`](#eip712error).[`name`](#name-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`Eip712Error`](#eip712error).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`Eip712Error`](#eip712error).[`toJSON`](#tojson-2)
***
### Eip712Error
Defined in: [src/crypto/EIP712/errors.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L16)
Base EIP-712 error
#### Example
```javascript theme={null}
throw new Eip712Error('EIP-712 operation failed', {
code: 'EIP712_ERROR',
context: { operation: 'sign' },
docsPath: '/crypto/eip712#error-handling',
cause: originalError
})
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`Eip712EncodingError`](#eip712encodingerror)
* [`Eip712TypeNotFoundError`](#eip712typenotfounderror)
* [`Eip712InvalidMessageError`](#eip712invalidmessageerror)
#### Constructors
##### Constructor
> **new Eip712Error**(`message`, `options?`): [`Eip712Error`](#eip712error)
Defined in: [src/crypto/EIP712/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L21)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Eip712Error`](#eip712error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/EIP712/errors.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L28)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### Eip712InvalidMessageError
Defined in: [src/crypto/EIP712/errors.js:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L103)
EIP-712 invalid message error
#### Example
```javascript theme={null}
throw new Eip712InvalidMessageError('Missing required field', {
code: 'EIP712_INVALID_MESSAGE',
context: { field: 'name' },
docsPath: '/crypto/eip712/encode-data#error-handling',
cause: originalError
})
```
#### Extends
* [`Eip712Error`](#eip712error)
#### Constructors
##### Constructor
> **new Eip712InvalidMessageError**(`message`, `options?`): [`Eip712InvalidMessageError`](#eip712invalidmessageerror)
Defined in: [src/crypto/EIP712/errors.js:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L108)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Eip712InvalidMessageError`](#eip712invalidmessageerror)
###### Overrides
[`Eip712Error`](#eip712error).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`Eip712Error`](#eip712error).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`Eip712Error`](#eip712error).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`docsPath`](#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/EIP712/errors.js:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L115)
###### Inherited from
[`Eip712Error`](#eip712error).[`name`](#name-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`Eip712Error`](#eip712error).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`Eip712Error`](#eip712error).[`toJSON`](#tojson-2)
***
### Eip712TypeNotFoundError
Defined in: [src/crypto/EIP712/errors.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L74)
EIP-712 type not found error
#### Example
```javascript theme={null}
throw new Eip712TypeNotFoundError('Type Person not found', {
code: 'EIP712_TYPE_NOT_FOUND',
context: { type: 'Person' },
docsPath: '/crypto/eip712/encode-type#error-handling',
cause: originalError
})
```
#### Extends
* [`Eip712Error`](#eip712error)
#### Constructors
##### Constructor
> **new Eip712TypeNotFoundError**(`message`, `options?`): [`Eip712TypeNotFoundError`](#eip712typenotfounderror)
Defined in: [src/crypto/EIP712/errors.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L79)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Eip712TypeNotFoundError`](#eip712typenotfounderror)
###### Overrides
[`Eip712Error`](#eip712error).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`Eip712Error`](#eip712error).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`Eip712Error`](#eip712error).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`Eip712Error`](#eip712error).[`docsPath`](#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/EIP712/errors.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/errors.js#L86)
###### Inherited from
[`Eip712Error`](#eip712error).[`name`](#name-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`Eip712Error`](#eip712error).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`Eip712Error`](#eip712error).[`toJSON`](#tojson-2)
## Type Aliases
### BrandedEIP712
> **BrandedEIP712** = [`TypedData`](#typeddata) & `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L73)
Branded EIP-712 TypedData type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EIP712"`
***
### Domain
> **Domain** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L8)
EIP-712 Domain separator fields
#### Properties
##### chainId?
> `optional` **chainId**: `bigint`
Defined in: [src/crypto/EIP712/EIP712Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L11)
##### name?
> `optional` **name**: `string`
Defined in: [src/crypto/EIP712/EIP712Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L9)
##### salt?
> `optional` **salt**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/EIP712Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L13)
##### verifyingContract?
> `optional` **verifyingContract**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/crypto/EIP712/EIP712Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L12)
##### version?
> `optional` **version**: `string`
Defined in: [src/crypto/EIP712/EIP712Type.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L10)
***
### Message
> **Message** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L47)
Message data (object with arbitrary structure matching types)
#### Index Signature
\[`key`: `string`]: [`MessageValue`](#messagevalue)
***
### MessageValue
> **MessageValue** = `string` | `bigint` | `number` | `boolean` | [`AddressType`](../primitives/Address.mdx#addresstype) | `Uint8Array` | [`MessageValue`](#messagevalue)\[] | \{\[`key`: `string`]: [`MessageValue`](#messagevalue); }
Defined in: [src/crypto/EIP712/EIP712Type.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L34)
Message value (can be primitive or nested object)
***
### Signature
> **Signature** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L64)
ECDSA Signature
#### Properties
##### r
> **r**: `Uint8Array`
Defined in: [src/crypto/EIP712/EIP712Type.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L65)
##### s
> **s**: `Uint8Array`
Defined in: [src/crypto/EIP712/EIP712Type.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L66)
##### v
> **v**: `number`
Defined in: [src/crypto/EIP712/EIP712Type.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L67)
***
### TypedData
> **TypedData** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L54)
Complete EIP-712 typed data structure
#### Properties
##### domain
> **domain**: [`Domain`](#domain)
Defined in: [src/crypto/EIP712/EIP712Type.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L55)
##### message
> **message**: [`Message`](#message)
Defined in: [src/crypto/EIP712/EIP712Type.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L58)
##### primaryType
> **primaryType**: `string`
Defined in: [src/crypto/EIP712/EIP712Type.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L57)
##### types
> **types**: [`TypeDefinitions`](#typedefinitions)
Defined in: [src/crypto/EIP712/EIP712Type.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L56)
***
### TypeDefinitions
> **TypeDefinitions** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L27)
Type definitions mapping type names to their properties
#### Index Signature
\[`typeName`: `string`]: readonly [`TypeProperty`](#typeproperty)\[]
***
### TypeProperty
> **TypeProperty** = `object`
Defined in: [src/crypto/EIP712/EIP712Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L19)
Type property definition
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/EIP712/EIP712Type.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L20)
##### type
> **type**: `string`
Defined in: [src/crypto/EIP712/EIP712Type.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712Type.ts#L21)
## Variables
### \_signTypedData()
> `const` **\_signTypedData**: (`typedData`, `privateKey`) => [`Signature`](#signature)
Defined in: [src/crypto/EIP712/EIP712.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L76)
#### Parameters
##### typedData
[`TypedData`](#typeddata)
##### privateKey
`Uint8Array`
#### Returns
[`Signature`](#signature)
***
### EIP712
> `const` **EIP712**: `object`
Defined in: [src/crypto/EIP712/EIP712.js:157](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L157)
EIP-712 Typed Data Signing
Complete implementation of EIP-712 typed structured data hashing and signing.
#### Type Declaration
##### Domain
> **Domain**: `object`
###### Domain.hash()
> **hash**: (`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype) = `hashDomain`
###### Parameters
###### domain
[`Domain`](#domain)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### encodeData()
> **encodeData**: (`primaryType`, `data`, `types`) => `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
`Uint8Array`
##### EncodeData()
> **EncodeData**: (`deps`) => (`primaryType`, `data`, `types`) => `Uint8Array`
Factory: Encode struct data according to EIP-712.
###### Parameters
###### deps
Crypto dependencies
###### encodeValue
(`type`, `value`, `types`) => `Uint8Array`
Encode value function
###### hashType
(`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash type function
###### Returns
Function that encodes data
> (`primaryType`, `data`, `types`): `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType is not found in types
###### Throws
If required field is missing from data
###### Example
```javascript theme={null}
import { EncodeData } from './crypto/EIP712/encodeData.js';
import { HashType } from './hashType.js';
import { EncodeValue } from './encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encodeData = EncodeData({ hashType, encodeValue });
const types = { Person: [{ name: 'name', type: 'string' }, { name: 'wallet', type: 'address' }] };
const encoded = encodeData('Person', { name: 'Alice', wallet: '0x...' }, types);
```
##### encodeType()
> **encodeType**: (`primaryType`, `types`) => `string`
Encode type string for EIP-712 hashing.
Produces type encoding like "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
###### Parameters
###### primaryType
`string`
Primary type name to encode
###### types
[`TypeDefinitions`](#typedefinitions)
Type definitions mapping
###### Returns
`string`
Encoded type string with primary type followed by referenced types in alphabetical order
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType or any referenced type is not found
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const types = { Mail: [{ name: 'from', type: 'Person' }], Person: [{ name: 'name', type: 'string' }] };
const typeString = EIP712.encodeType('Mail', types);
// Returns: "Mail(Person from)Person(string name)"
```
##### encodeValue()
> **encodeValue**: (`type`, `value`, `types`) => `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](#messagevalue)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
`Uint8Array`
##### EncodeValue()
> **EncodeValue**: (`deps`) => (`type`, `value`, `types`) => `Uint8Array`
Factory: Encode single value to 32 bytes according to EIP-712.
Handles primitive types, arrays, strings, bytes, and custom structs.
Addresses must be pre-validated BrandedAddress types.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`type`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that encodes value
> (`type`, `value`, `types`): `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](#messagevalue)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is unsupported or value format is invalid
###### Example
```javascript theme={null}
import { EncodeValue } from './crypto/EIP712/encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { HashStruct } from './hashStruct.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encoded = encodeValue('uint256', 42n, types);
```
##### format()
> **format**: (`typedData`) => `string`
Format typed data for human-readable display.
###### Parameters
###### typedData
[`TypedData`](#typeddata)
Typed data to format
###### Returns
`string`
Human-readable multi-line string representation
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const formatted = EIP712.format(typedData);
console.log(formatted);
```
##### HashDomain()
> **HashDomain**: (`deps`) => (`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Factory: Hash EIP-712 domain separator.
Only includes fields that are defined in the domain object.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### Returns
Function that hashes domain
> (`domain`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### domain
[`Domain`](#domain)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If domain type encoding fails
###### Example
```javascript theme={null}
import { Hash as HashDomain } from './crypto/EIP712/Domain/hash.js';
import { HashStruct } from '../hashStruct.js';
import { hash as keccak256 } from '../../Keccak256/hash.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const hashDomain = HashDomain({ hashStruct });
const domain = { name: 'MyApp', version: '1', chainId: 1n };
const domainHash = hashDomain(domain);
```
##### hashStruct()
> **hashStruct**: (`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### HashStruct()
> **HashStruct**: (`deps`) => (`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Factory: Hash struct according to EIP-712 specification.
Computes keccak256 of the encoded struct data.
###### Parameters
###### deps
Crypto dependencies
###### encodeData
(`primaryType`, `data`, `types`) => `Uint8Array`
Encode data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes struct
> (`primaryType`, `data`, `types`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashStruct } from './crypto/EIP712/hashStruct.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { EncodeData } from './encodeData.js';
const encodeData = EncodeData({ hashType, encodeValue });
const hashStruct = HashStruct({ keccak256, encodeData });
const types = { Person: [{ name: 'name', type: 'string' }] };
const hash = hashStruct('Person', { name: 'Alice' }, types);
```
##### hashType()
> **hashType**: (`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### HashType()
> **HashType**: (`deps`) => (`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Factory: Hash type string according to EIP-712.
Computes keccak256 of the encoded type string.
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes type string
> (`primaryType`, `types`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](#typedefinitions)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Example
```javascript theme={null}
import { HashType } from './crypto/EIP712/hashType.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const types = { Mail: [{ name: 'contents', type: 'string' }] };
const typeHash = hashType('Mail', types);
```
##### hashTypedData()
> **hashTypedData**: (`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](#typeddata)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### HashTypedData()
> **HashTypedData**: (`deps`) => (`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Factory: Hash typed data according to EIP-712 specification.
Computes: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))
###### Parameters
###### deps
Crypto dependencies
###### hashDomain
(`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash domain function
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes typed data
> (`typedData`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](#typeddata)
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If types are not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashTypedData } from './crypto/EIP712/hashTypedData.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { Hash as HashDomain } from './Domain/hash.js';
import { HashStruct } from './hashStruct.js';
const hashDomain = HashDomain({ hashStruct });
const hashStruct = HashStruct({ keccak256, encodeData });
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const hash = hashTypedData(typedData);
```
##### recoverAddress()
> **recoverAddress**: (`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
###### Returns
[`AddressType`](../primitives/Address.mdx#addresstype)
##### RecoverAddress()
> **RecoverAddress**: (`deps`) => (`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
Factory: Recover Ethereum address from EIP-712 typed data signature.
Uses ECDSA public key recovery to determine the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `hash`, `recoveryBit`) => `Uint8Array`
Secp256k1 public key recovery function
###### Returns
Function that recovers address
> (`signature`, `typedData`): [`AddressType`](../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
###### Returns
[`AddressType`](../primitives/Address.mdx#addresstype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature recovery fails or public key format is invalid
###### Example
```javascript theme={null}
import { RecoverAddress } from './crypto/EIP712/recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
import { HashTypedData } from './hashTypedData.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const address = recoverAddress(signature, typedData);
```
##### signTypedData()
> **signTypedData**: (`typedData`, `privateKey`) => [`Signature`](#signature)
###### Parameters
###### typedData
`any`
###### privateKey
`any`
###### Returns
[`Signature`](#signature)
##### SignTypedData()
> **SignTypedData**: (`deps`) => (`typedData`, `privateKey`) => [`Signature`](#signature)
Factory: Sign EIP-712 typed data with ECDSA private key.
Produces a signature that can be verified against the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### sign
(`hash`, `privateKey`) => [`Signature`](#signature)
Secp256k1 sign function
###### Returns
Function that signs typed data
> (`typedData`, `privateKey`): [`Signature`](#signature)
###### Parameters
###### typedData
[`TypedData`](#typeddata)
###### privateKey
`Uint8Array`
###### Returns
[`Signature`](#signature)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key length is invalid or signing fails
###### Example
```javascript theme={null}
import { SignTypedData } from './crypto/EIP712/signTypedData.js';
import { HashTypedData } from './hashTypedData.js';
import { sign } from '../Secp256k1/sign.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const signTypedData = SignTypedData({ hashTypedData, sign });
const privateKey = new Uint8Array(32);
const signature = signTypedData(typedData, privateKey);
```
##### validate()
> **validate**: (`typedData`) => `void`
Validate typed data structure against EIP-712 specification.
Checks domain, types, primaryType, and message structure.
###### Parameters
###### typedData
[`TypedData`](#typeddata)
Typed data to validate
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If structure is invalid or missing required fields
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
EIP712.validate(typedData); // Throws if invalid
```
##### verifyTypedData()
> **verifyTypedData**: (`signature`, `typedData`, `address`) => `boolean`
###### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
##### VerifyTypedData()
> **VerifyTypedData**: (`deps`) => (`signature`, `typedData`, `address`) => `boolean`
Factory: Verify EIP-712 typed data signature against expected signer address.
Uses constant-time comparison to prevent timing attacks.
###### Parameters
###### deps
Crypto dependencies
###### recoverAddress
(`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
Recover address function
###### Returns
Function that verifies signature
> (`signature`, `typedData`, `address`): `boolean`
###### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { VerifyTypedData } from './crypto/EIP712/verifyTypedData.js';
import { RecoverAddress } from './recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const verifyTypedData = VerifyTypedData({ recoverAddress });
const valid = verifyTypedData(signature, typedData, signerAddress);
```
#### Example
```typescript theme={null}
import { EIP712 } from './EIP712.js';
// Define typed data
const typedData = {
domain: {
name: 'MyApp',
version: '1',
chainId: 1n,
verifyingContract: contractAddress,
},
types: {
Person: [
{ name: 'name', type: 'string' },
{ name: 'wallet', type: 'address' },
],
Mail: [
{ name: 'from', type: 'Person' },
{ name: 'to', type: 'Person' },
{ name: 'contents', type: 'string' },
],
},
primaryType: 'Mail',
message: {
from: { name: 'Alice', wallet: '0x...' },
to: { name: 'Bob', wallet: '0x...' },
contents: 'Hello!',
},
};
// Hash typed data
const hash = EIP712.hashTypedData(typedData);
// Sign typed data
const signature = EIP712.signTypedData(typedData, privateKey);
// Verify signature
const valid = EIP712.verifyTypedData(signature, typedData, address);
```
***
### encodeData()
> `const` **encodeData**: (`primaryType`, `data`, `types`) => `Uint8Array`
Defined in: [src/crypto/EIP712/EIP712.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L54)
#### Parameters
##### primaryType
`string`
##### data
[`Message`](#message)
##### types
[`TypeDefinitions`](#typedefinitions)
#### Returns
`Uint8Array`
***
### encodeValue()
> `const` **encodeValue**: (`type`, `value`, `types`) => `Uint8Array`
Defined in: [src/crypto/EIP712/EIP712.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L49)
#### Parameters
##### type
`string`
##### value
[`MessageValue`](#messagevalue)
##### types
[`TypeDefinitions`](#typedefinitions)
#### Returns
`Uint8Array`
***
### hashDomain()
> `const` **hashDomain**: (`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/EIP712.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L57)
#### Parameters
##### domain
[`Domain`](#domain)
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### hashStruct
> **hashStruct**: `any`
Defined in: [src/crypto/EIP712/EIP712.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L48)
***
### hashType()
> `const` **hashType**: (`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/EIP712.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L43)
#### Parameters
##### primaryType
`string`
##### types
[`TypeDefinitions`](#typedefinitions)
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### hashTypedData()
> `const` **hashTypedData**: (`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/EIP712.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L58)
#### Parameters
##### typedData
[`TypedData`](#typeddata)
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### recoverAddress()
> `const` **recoverAddress**: (`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/crypto/EIP712/EIP712.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L70)
#### Parameters
##### signature
[`Signature`](#signature)
##### typedData
[`TypedData`](#typeddata)
#### Returns
[`AddressType`](../primitives/Address.mdx#addresstype)
***
### verifyTypedData()
> `const` **verifyTypedData**: (`signature`, `typedData`, `address`) => `boolean`
Defined in: [src/crypto/EIP712/EIP712.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L77)
#### Parameters
##### signature
[`Signature`](#signature)
##### typedData
[`TypedData`](#typeddata)
##### address
[`AddressType`](../primitives/Address.mdx#addresstype)
#### Returns
`boolean`
## Functions
### EncodeData()
> **EncodeData**(`deps`): (`primaryType`, `data`, `types`) => `Uint8Array`
Defined in: [src/crypto/EIP712/encodeData.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/encodeData.js#L30)
Factory: Encode struct data according to EIP-712.
#### Parameters
##### deps
Crypto dependencies
###### encodeValue
(`type`, `value`, `types`) => `Uint8Array`
Encode value function
###### hashType
(`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash type function
#### Returns
Function that encodes data
> (`primaryType`, `data`, `types`): `Uint8Array`
##### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If primaryType is not found in types
#### Throws
If required field is missing from data
#### Example
```javascript theme={null}
import { EncodeData } from './crypto/EIP712/encodeData.js';
import { HashType } from './hashType.js';
import { EncodeValue } from './encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encodeData = EncodeData({ hashType, encodeValue });
const types = { Person: [{ name: 'name', type: 'string' }, { name: 'wallet', type: 'address' }] };
const encoded = encodeData('Person', { name: 'Alice', wallet: '0x...' }, types);
```
***
### encodeType()
> **encodeType**(`primaryType`, `types`): `string`
Defined in: [src/crypto/EIP712/encodeType.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/encodeType.js#L22)
Encode type string for EIP-712 hashing.
Produces type encoding like "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
#### Parameters
##### primaryType
`string`
Primary type name to encode
##### types
[`TypeDefinitions`](#typedefinitions)
Type definitions mapping
#### Returns
`string`
Encoded type string with primary type followed by referenced types in alphabetical order
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If primaryType or any referenced type is not found
#### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const types = { Mail: [{ name: 'from', type: 'Person' }], Person: [{ name: 'name', type: 'string' }] };
const typeString = EIP712.encodeType('Mail', types);
// Returns: "Mail(Person from)Person(string name)"
```
***
### EncodeValue()
> **EncodeValue**(`deps`): (`type`, `value`, `types`) => `Uint8Array`
Defined in: [src/crypto/EIP712/encodeValue.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/encodeValue.js#L26)
Factory: Encode single value to 32 bytes according to EIP-712.
Handles primitive types, arrays, strings, bytes, and custom structs.
Addresses must be pre-validated BrandedAddress types.
#### Parameters
##### deps
Crypto dependencies
###### hashStruct
(`type`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that encodes value
> (`type`, `value`, `types`): `Uint8Array`
##### Parameters
###### type
`string`
###### value
[`MessageValue`](#messagevalue)
###### types
[`TypeDefinitions`](#typedefinitions)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If type is unsupported or value format is invalid
#### Example
```javascript theme={null}
import { EncodeValue } from './crypto/EIP712/encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { HashStruct } from './hashStruct.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encoded = encodeValue('uint256', 42n, types);
```
***
### format()
> **format**(`typedData`): `string`
Defined in: [src/crypto/EIP712/format.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/format.js#L16)
Format typed data for human-readable display.
#### Parameters
##### typedData
[`TypedData`](#typeddata)
Typed data to format
#### Returns
`string`
Human-readable multi-line string representation
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const formatted = EIP712.format(typedData);
console.log(formatted);
```
***
### HashDomain()
> **HashDomain**(`deps`): (`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/Domain/hash.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/Domain/hash.js#L35)
Factory: Hash EIP-712 domain separator.
Only includes fields that are defined in the domain object.
#### Parameters
##### deps
Crypto dependencies
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
#### Returns
Function that hashes domain
> (`domain`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### domain
[`Domain`](#domain)
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If domain type encoding fails
#### Example
```javascript theme={null}
import { Hash as HashDomain } from './crypto/EIP712/Domain/hash.js';
import { HashStruct } from '../hashStruct.js';
import { hash as keccak256 } from '../../Keccak256/hash.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const hashDomain = HashDomain({ hashStruct });
const domain = { name: 'MyApp', version: '1', chainId: 1n };
const domainHash = hashDomain(domain);
```
***
### HashStruct()
> **HashStruct**(`deps`): (`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/hashStruct.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/hashStruct.js#L25)
Factory: Hash struct according to EIP-712 specification.
Computes keccak256 of the encoded struct data.
#### Parameters
##### deps
Crypto dependencies
###### encodeData
(`primaryType`, `data`, `types`) => `Uint8Array`
Encode data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes struct
> (`primaryType`, `data`, `types`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### primaryType
`string`
###### data
[`Message`](#message)
###### types
[`TypeDefinitions`](#typedefinitions)
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If type is not found
#### Throws
If message data is invalid
#### Example
```javascript theme={null}
import { HashStruct } from './crypto/EIP712/hashStruct.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { EncodeData } from './encodeData.js';
const encodeData = EncodeData({ hashType, encodeValue });
const hashStruct = HashStruct({ keccak256, encodeData });
const types = { Person: [{ name: 'name', type: 'string' }] };
const hash = hashStruct('Person', { name: 'Alice' }, types);
```
***
### HashType()
> **HashType**(`deps`): (`primaryType`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/hashType.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/hashType.js#L23)
Factory: Hash type string according to EIP-712.
Computes keccak256 of the encoded type string.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes type string
> (`primaryType`, `types`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](#typedefinitions)
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If type is not found
#### Example
```javascript theme={null}
import { HashType } from './crypto/EIP712/hashType.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const types = { Mail: [{ name: 'contents', type: 'string' }] };
const typeHash = hashType('Mail', types);
```
***
### HashTypedData()
> **HashTypedData**(`deps`): (`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/EIP712/hashTypedData.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/hashTypedData.js#L27)
Factory: Hash typed data according to EIP-712 specification.
Computes: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))
#### Parameters
##### deps
Crypto dependencies
###### hashDomain
(`domain`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash domain function
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes typed data
> (`typedData`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### typedData
[`TypedData`](#typeddata)
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If types are not found
#### Throws
If message data is invalid
#### Example
```javascript theme={null}
import { HashTypedData } from './crypto/EIP712/hashTypedData.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { Hash as HashDomain } from './Domain/hash.js';
import { HashStruct } from './hashStruct.js';
const hashDomain = HashDomain({ hashStruct });
const hashStruct = HashStruct({ keccak256, encodeData });
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const hash = hashTypedData(typedData);
```
***
### RecoverAddress()
> **RecoverAddress**(`deps`): (`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/crypto/EIP712/recoverAddress.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/recoverAddress.js#L27)
Factory: Recover Ethereum address from EIP-712 typed data signature.
Uses ECDSA public key recovery to determine the signer's address.
#### Parameters
##### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `hash`, `recoveryBit`) => `Uint8Array`
Secp256k1 public key recovery function
#### Returns
Function that recovers address
> (`signature`, `typedData`): [`AddressType`](../primitives/Address.mdx#addresstype)
##### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
##### Returns
[`AddressType`](../primitives/Address.mdx#addresstype)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If signature recovery fails or public key format is invalid
#### Example
```javascript theme={null}
import { RecoverAddress } from './crypto/EIP712/recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
import { HashTypedData } from './hashTypedData.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const address = recoverAddress(signature, typedData);
```
***
### signTypedData()
> **signTypedData**(`typedData`, `privateKey`): [`Signature`](#signature)
Defined in: [src/crypto/EIP712/EIP712.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/EIP712.js#L80)
#### Parameters
##### typedData
`any`
##### privateKey
`any`
#### Returns
[`Signature`](#signature)
***
### SignTypedData()
> **SignTypedData**(`deps`): (`typedData`, `privateKey`) => [`Signature`](#signature)
Defined in: [src/crypto/EIP712/signTypedData.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/signTypedData.js#L25)
Factory: Sign EIP-712 typed data with ECDSA private key.
Produces a signature that can be verified against the signer's address.
#### Parameters
##### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### sign
(`hash`, `privateKey`) => [`Signature`](#signature)
Secp256k1 sign function
#### Returns
Function that signs typed data
> (`typedData`, `privateKey`): [`Signature`](#signature)
##### Parameters
###### typedData
[`TypedData`](#typeddata)
###### privateKey
`Uint8Array`
##### Returns
[`Signature`](#signature)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key length is invalid or signing fails
#### Example
```javascript theme={null}
import { SignTypedData } from './crypto/EIP712/signTypedData.js';
import { HashTypedData } from './hashTypedData.js';
import { sign } from '../Secp256k1/sign.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const signTypedData = SignTypedData({ hashTypedData, sign });
const privateKey = new Uint8Array(32);
const signature = signTypedData(typedData, privateKey);
```
***
### validate()
> **validate**(`typedData`): `void`
Defined in: [src/crypto/EIP712/validate.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/validate.js#L19)
Validate typed data structure against EIP-712 specification.
Checks domain, types, primaryType, and message structure.
#### Parameters
##### typedData
[`TypedData`](#typeddata)
Typed data to validate
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If structure is invalid or missing required fields
#### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
EIP712.validate(typedData); // Throws if invalid
```
***
### VerifyTypedData()
> **VerifyTypedData**(`deps`): (`signature`, `typedData`, `address`) => `boolean`
Defined in: [src/crypto/EIP712/verifyTypedData.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/EIP712/verifyTypedData.js#L23)
Factory: Verify EIP-712 typed data signature against expected signer address.
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### deps
Crypto dependencies
###### recoverAddress
(`signature`, `typedData`) => [`AddressType`](../primitives/Address.mdx#addresstype)
Recover address function
#### Returns
Function that verifies signature
> (`signature`, `typedData`, `address`): `boolean`
##### Parameters
###### signature
[`Signature`](#signature)
###### typedData
[`TypedData`](#typeddata)
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { VerifyTypedData } from './crypto/EIP712/verifyTypedData.js';
import { RecoverAddress } from './recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const verifyTypedData = VerifyTypedData({ recoverAddress });
const valid = verifyTypedData(signature, typedData, signerAddress);
```
# crypto/Ed25519
Source: https://voltaire.tevm.sh/generated-api/crypto/Ed25519
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Ed25519
# crypto/Ed25519
## Classes
### Ed25519Error
Defined in: [src/crypto/Ed25519/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L21)
Base error class for Ed25519 operations
#### Example
```javascript theme={null}
throw new Ed25519Error('Ed25519 operation failed', {
code: 'ED25519_ERROR',
context: { operation: 'sign' },
docsPath: '/crypto/ed25519#error-handling',
cause: originalError
})
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`InvalidSeedError`](#invalidseederror)
#### Constructors
##### Constructor
> **new Ed25519Error**(`message`, `options?`): [`Ed25519Error`](#ed25519error)
Defined in: [src/crypto/Ed25519/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L26)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`Ed25519Error`](#ed25519error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/Ed25519/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L33)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### InvalidPublicKeyError
Defined in: [src/crypto/Ed25519/errors.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L77)
Error thrown when public key is invalid
#### Example
```javascript theme={null}
throw new InvalidPublicKeyError('Ed25519 public key must be 32 bytes', {
code: 'ED25519_INVALID_PUBLIC_KEY_LENGTH',
context: { length: 64, expected: 32 },
docsPath: '/crypto/ed25519/verify#error-handling'
})
```
#### Extends
* [`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`, `options?`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/Ed25519/errors.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L82)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`constructor`](../index/index.mdx#constructor-10)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`cause`](../index/index.mdx#cause-10)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`code`](../index/index.mdx#code-10)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`context`](../index/index.mdx#context-10)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`docsPath`](../index/index.mdx#docspath-10)
##### name
> **name**: `string`
Defined in: [src/crypto/Ed25519/errors.js:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L89)
###### Inherited from
`BaseInvalidPublicKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-20)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`toJSON`](../index/index.mdx#tojson-20)
***
### InvalidSecretKeyError
Defined in: [src/crypto/Ed25519/errors.js:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L105)
Error thrown when secret key is invalid
#### Example
```javascript theme={null}
throw new InvalidSecretKeyError('Ed25519 secret key must be 32 bytes', {
code: 'ED25519_INVALID_SECRET_KEY_LENGTH',
context: { length: 64, expected: 32 },
docsPath: '/crypto/ed25519/sign#error-handling'
})
```
#### Extends
* [`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror)
#### Constructors
##### Constructor
> **new InvalidSecretKeyError**(`message`, `options?`): [`InvalidSecretKeyError`](#invalidsecretkeyerror)
Defined in: [src/crypto/Ed25519/errors.js:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L110)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSecretKeyError`](#invalidsecretkeyerror)
###### Overrides
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`constructor`](../index/index.mdx#constructor-9)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`cause`](../index/index.mdx#cause-9)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`code`](../index/index.mdx#code-9)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`context`](../index/index.mdx#context-9)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`docsPath`](../index/index.mdx#docspath-9)
##### name
> **name**: `string`
Defined in: [src/crypto/Ed25519/errors.js:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L117)
###### Inherited from
`InvalidPrivateKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-18)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`toJSON`](../index/index.mdx#tojson-18)
***
### InvalidSeedError
Defined in: [src/crypto/Ed25519/errors.js:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L133)
Error thrown when seed is invalid
#### Example
```javascript theme={null}
throw new InvalidSeedError('Ed25519 seed must be 32 bytes', {
code: 'ED25519_INVALID_SEED_LENGTH',
context: { length: 16, expected: 32 },
docsPath: '/crypto/ed25519/keypair-from-seed#error-handling'
})
```
#### Extends
* [`Ed25519Error`](#ed25519error)
#### Constructors
##### Constructor
> **new InvalidSeedError**(`message`, `options?`): [`InvalidSeedError`](#invalidseederror)
Defined in: [src/crypto/Ed25519/errors.js:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L138)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSeedError`](#invalidseederror)
###### Overrides
[`Ed25519Error`](#ed25519error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`Ed25519Error`](#ed25519error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`Ed25519Error`](#ed25519error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`Ed25519Error`](#ed25519error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`Ed25519Error`](#ed25519error).[`docsPath`](#docspath)
##### name
> **name**: `string`
Defined in: [src/crypto/Ed25519/errors.js:145](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L145)
###### Inherited from
[`Ed25519Error`](#ed25519error).[`name`](#name)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`Ed25519Error`](#ed25519error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`Ed25519Error`](#ed25519error).[`toJSON`](#tojson)
***
### InvalidSignatureError
Defined in: [src/crypto/Ed25519/errors.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L49)
Error thrown when signature is invalid
#### Example
```javascript theme={null}
throw new InvalidSignatureError('Ed25519 signature must be 64 bytes', {
code: 'ED25519_INVALID_SIGNATURE_LENGTH',
context: { length: 32, expected: 64 },
docsPath: '/crypto/ed25519/verify#error-handling'
})
```
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`, `options?`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/crypto/Ed25519/errors.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L54)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/crypto/Ed25519/errors.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/errors.js#L61)
###### Inherited from
`BaseInvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
## Variables
### Ed25519
> `const` **Ed25519**: `object`
Defined in: [src/crypto/Ed25519/Ed25519.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/Ed25519.js#L54)
Ed25519 Digital Signature Algorithm
Edwards-curve Digital Signature Algorithm (EdDSA) using Curve25519.
Fast, secure, and deterministic signatures without requiring a hash function.
Used in many modern protocols including SSH, TLS 1.3, and cryptocurrency.
#### Type Declaration
##### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => `PublicKey`
Derive Ed25519 public key from secret key.
###### Parameters
###### secretKey
`SecretKey`
32-byte Ed25519 secret key (seed)
###### Returns
`PublicKey`
32-byte Ed25519 public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is invalid or derivation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const secretKey = new Uint8Array(32); // Your secret key
const publicKey = Ed25519.derivePublicKey(secretKey);
```
##### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate Ed25519 keypair from seed deterministically.
###### Parameters
###### seed
`Seed`
32-byte seed for deterministic keypair generation
###### Returns
`object`
Object containing 32-byte secretKey and 32-byte publicKey
###### publicKey
> **publicKey**: `PublicKey`
###### secretKey
> **secretKey**: `SecretKey`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is not 32 bytes
###### Throws
If keypair generation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = Ed25519.keypairFromSeed(seed);
console.log(keypair.publicKey); // Uint8Array(32)
```
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Ed25519 public key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Ed25519/constants.js';
const publicKey = new Uint8Array(PUBLIC_KEY_SIZE);
```
##### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Ed25519 secret key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/Ed25519/constants.js';
const secretKey = new Uint8Array(SECRET_KEY_SIZE);
```
##### SEED\_SIZE
> **SEED\_SIZE**: `32`
Ed25519 seed size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SEED_SIZE } from './crypto/Ed25519/constants.js';
const seed = crypto.getRandomValues(new Uint8Array(SEED_SIZE));
```
##### sign()
> **sign**: (`message`, `secretKey`) => `Signature`
Sign message with Ed25519 secret key.
Produces deterministic signatures using EdDSA.
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message bytes to sign (any length)
###### secretKey
`SecretKey`
32-byte Ed25519 secret key
###### Returns
`Signature`
64-byte Ed25519 signature
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is not 32 bytes
###### Throws
If signing operation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, secretKey);
```
##### SIGNATURE\_SIZE
> **SIGNATURE\_SIZE**: `64`
Ed25519 signature size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIGNATURE_SIZE } from './crypto/Ed25519/constants.js';
const signature = new Uint8Array(SIGNATURE_SIZE);
```
##### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate Ed25519 public key format and curve membership.
###### Parameters
###### publicKey
`PublicKey`
Ed25519 public key to validate
###### Returns
`boolean`
True if public key is valid and on curve, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validatePublicKey(publicKey);
if (!isValid) console.log('Invalid public key');
```
##### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate Ed25519 secret key format.
Checks length and attempts public key derivation.
###### Parameters
###### secretKey
`SecretKey`
Ed25519 secret key to validate
###### Returns
`boolean`
True if secret key is valid (32 bytes and can derive public key), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validateSecretKey(secretKey);
if (!isValid) console.log('Invalid secret key');
```
##### validateSeed()
> **validateSeed**: (`seed`) => `boolean`
Validate Ed25519 seed format.
Checks if seed has correct 32-byte length.
###### Parameters
###### seed
`Seed`
Ed25519 seed to validate
###### Returns
`boolean`
True if seed is exactly 32 bytes, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const isValid = Ed25519.validateSeed(seed); // true
```
##### verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify Ed25519 signature.
Returns false on verification failure instead of throwing.
###### Parameters
###### signature
`Signature`
64-byte Ed25519 signature to verify
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message bytes that were signed
###### publicKey
`PublicKey`
32-byte Ed25519 public key
###### Returns
`boolean`
True if signature is cryptographically valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If public key length is not 32 bytes
###### Throws
If signature length is not 64 bytes
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const valid = Ed25519.verify(signature, message, publicKey);
if (valid) console.log('Signature verified');
```
#### Example
```typescript theme={null}
import { Ed25519 } from './Ed25519/index.js';
// Generate keypair from seed
const seed = new Uint8Array(32); // Random seed
const keypair = Ed25519.keypairFromSeed(seed);
// Sign a message
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, keypair.secretKey);
// Verify signature
const valid = Ed25519.verify(signature, message, keypair.publicKey);
```
***
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/Ed25519/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/constants.js#L27)
Ed25519 public key size in bytes.
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Ed25519/constants.js';
const publicKey = new Uint8Array(PUBLIC_KEY_SIZE);
```
***
### SECRET\_KEY\_SIZE
> `const` **SECRET\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/Ed25519/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/constants.js#L13)
Ed25519 secret key size in bytes.
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/Ed25519/constants.js';
const secretKey = new Uint8Array(SECRET_KEY_SIZE);
```
***
### SEED\_SIZE
> `const` **SEED\_SIZE**: `32` = `32`
Defined in: [src/crypto/Ed25519/constants.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/constants.js#L55)
Ed25519 seed size in bytes.
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SEED_SIZE } from './crypto/Ed25519/constants.js';
const seed = crypto.getRandomValues(new Uint8Array(SEED_SIZE));
```
***
### SIGNATURE\_SIZE
> `const` **SIGNATURE\_SIZE**: `64` = `64`
Defined in: [src/crypto/Ed25519/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/constants.js#L41)
Ed25519 signature size in bytes.
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SIGNATURE_SIZE } from './crypto/Ed25519/constants.js';
const signature = new Uint8Array(SIGNATURE_SIZE);
```
## Functions
### derivePublicKey()
> **derivePublicKey**(`secretKey`): `PublicKey`
Defined in: [src/crypto/Ed25519/derivePublicKey.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/derivePublicKey.js#L20)
Derive Ed25519 public key from secret key.
#### Parameters
##### secretKey
`SecretKey`
32-byte Ed25519 secret key (seed)
#### Returns
`PublicKey`
32-byte Ed25519 public key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If secret key length is invalid or derivation fails
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const secretKey = new Uint8Array(32); // Your secret key
const publicKey = Ed25519.derivePublicKey(secretKey);
```
***
### keypairFromSeed()
> **keypairFromSeed**(`seed`): `object`
Defined in: [src/crypto/Ed25519/keypairFromSeed.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/keypairFromSeed.js#L22)
Generate Ed25519 keypair from seed deterministically.
#### Parameters
##### seed
`Seed`
32-byte seed for deterministic keypair generation
#### Returns
`object`
Object containing 32-byte secretKey and 32-byte publicKey
##### publicKey
> **publicKey**: `PublicKey`
##### secretKey
> **secretKey**: `SecretKey`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If seed length is not 32 bytes
#### Throws
If keypair generation fails
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = Ed25519.keypairFromSeed(seed);
console.log(keypair.publicKey); // Uint8Array(32)
```
***
### sign()
> **sign**(`message`, `secretKey`): `Signature`
Defined in: [src/crypto/Ed25519/sign.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/sign.js#L24)
Sign message with Ed25519 secret key.
Produces deterministic signatures using EdDSA.
#### Parameters
##### message
`Uint8Array`\<`ArrayBufferLike`>
Message bytes to sign (any length)
##### secretKey
`SecretKey`
32-byte Ed25519 secret key
#### Returns
`Signature`
64-byte Ed25519 signature
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If secret key length is not 32 bytes
#### Throws
If signing operation fails
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, secretKey);
```
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/Ed25519/validatePublicKey.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/validatePublicKey.js#L19)
Validate Ed25519 public key format and curve membership.
#### Parameters
##### publicKey
`PublicKey`
Ed25519 public key to validate
#### Returns
`boolean`
True if public key is valid and on curve, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validatePublicKey(publicKey);
if (!isValid) console.log('Invalid public key');
```
***
### validateSecretKey()
> **validateSecretKey**(`secretKey`): `boolean`
Defined in: [src/crypto/Ed25519/validateSecretKey.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/validateSecretKey.js#L21)
Validate Ed25519 secret key format.
Checks length and attempts public key derivation.
#### Parameters
##### secretKey
`SecretKey`
Ed25519 secret key to validate
#### Returns
`boolean`
True if secret key is valid (32 bytes and can derive public key), false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validateSecretKey(secretKey);
if (!isValid) console.log('Invalid secret key');
```
***
### validateSeed()
> **validateSeed**(`seed`): `boolean`
Defined in: [src/crypto/Ed25519/validateSeed.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/validateSeed.js#L20)
Validate Ed25519 seed format.
Checks if seed has correct 32-byte length.
#### Parameters
##### seed
`Seed`
Ed25519 seed to validate
#### Returns
`boolean`
True if seed is exactly 32 bytes, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const isValid = Ed25519.validateSeed(seed); // true
```
***
### verify()
> **verify**(`signature`, `message`, `publicKey`): `boolean`
Defined in: [src/crypto/Ed25519/verify.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ed25519/verify.js#L25)
Verify Ed25519 signature.
Returns false on verification failure instead of throwing.
#### Parameters
##### signature
`Signature`
64-byte Ed25519 signature to verify
##### message
`Uint8Array`\<`ArrayBufferLike`>
Original message bytes that were signed
##### publicKey
`PublicKey`
32-byte Ed25519 public key
#### Returns
`boolean`
True if signature is cryptographically valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If public key length is not 32 bytes
#### Throws
If signature length is not 64 bytes
#### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const valid = Ed25519.verify(signature, message, publicKey);
if (valid) console.log('Signature verified');
```
# crypto/KZG
Source: https://voltaire.tevm.sh/generated-api/crypto/KZG
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/KZG
# crypto/KZG
## Classes
### KzgError
Defined in: [src/crypto/KZG/errors.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L13)
Base KZG error for polynomial commitment operations
#### See
[https://voltaire.tevm.sh/crypto/kzg](https://voltaire.tevm.sh/crypto/kzg) for KZG documentation
#### Since
0.0.0
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Extended by
* [`KzgNotInitializedError`](#kzgnotinitializederror)
* [`KzgInvalidBlobError`](#kzginvalidbloberror)
* [`KzgVerificationError`](#kzgverificationerror)
#### Constructors
##### Constructor
> **new KzgError**(`message`, `options?`): [`KzgError`](#kzgerror)
Defined in: [src/crypto/KZG/errors.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L14)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`KzgError`](#kzgerror)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
***
### KzgInvalidBlobError
Defined in: [src/crypto/KZG/errors.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L70)
Invalid blob error for EIP-4844 blob validation
Thrown when blob data is malformed, wrong length, or contains invalid field elements
#### See
[https://voltaire.tevm.sh/crypto/kzg/validate-blob](https://voltaire.tevm.sh/crypto/kzg/validate-blob)
#### Since
0.0.0
#### Extends
* [`KzgError`](#kzgerror)
#### Constructors
##### Constructor
> **new KzgInvalidBlobError**(`message`, `options?`): [`KzgInvalidBlobError`](#kzginvalidbloberror)
Defined in: [src/crypto/KZG/errors.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L71)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`KzgInvalidBlobError`](#kzginvalidbloberror)
###### Overrides
[`KzgError`](#kzgerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`KzgError`](#kzgerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`KzgError`](#kzgerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`KzgError`](#kzgerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`KzgError`](#kzgerror).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`KzgError`](#kzgerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`KzgError`](#kzgerror).[`toJSON`](#tojson)
***
### KzgNotInitializedError
Defined in: [src/crypto/KZG/errors.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L41)
Trusted setup not initialized error
Thrown when KZG operations are attempted before loadTrustedSetup() is called
#### See
[https://voltaire.tevm.sh/crypto/kzg/load-trusted-setup](https://voltaire.tevm.sh/crypto/kzg/load-trusted-setup)
#### Since
0.0.0
#### Extends
* [`KzgError`](#kzgerror)
#### Constructors
##### Constructor
> **new KzgNotInitializedError**(`message`, `options?`): [`KzgNotInitializedError`](#kzgnotinitializederror)
Defined in: [src/crypto/KZG/errors.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L42)
###### Parameters
###### message
`string` = `"KZG trusted setup not initialized"`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`KzgNotInitializedError`](#kzgnotinitializederror)
###### Overrides
[`KzgError`](#kzgerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`KzgError`](#kzgerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`KzgError`](#kzgerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`KzgError`](#kzgerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`KzgError`](#kzgerror).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`KzgError`](#kzgerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`KzgError`](#kzgerror).[`toJSON`](#tojson)
***
### KzgVerificationError
Defined in: [src/crypto/KZG/errors.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L98)
Verification error for KZG proof verification failures
Thrown when proof verification fails or verification inputs are invalid
#### See
[https://voltaire.tevm.sh/crypto/kzg/verify-blob-kzg-proof](https://voltaire.tevm.sh/crypto/kzg/verify-blob-kzg-proof)
#### Since
0.0.0
#### Extends
* [`KzgError`](#kzgerror)
#### Constructors
##### Constructor
> **new KzgVerificationError**(`message`, `options?`): [`KzgVerificationError`](#kzgverificationerror)
Defined in: [src/crypto/KZG/errors.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/errors.ts#L99)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`KzgVerificationError`](#kzgverificationerror)
###### Overrides
[`KzgError`](#kzgerror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`KzgError`](#kzgerror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`KzgError`](#kzgerror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`KzgError`](#kzgerror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`KzgError`](#kzgerror).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`KzgError`](#kzgerror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`KzgError`](#kzgerror).[`toJSON`](#tojson)
## Type Aliases
### BlobType
> **BlobType** = `Uint8Array` & `object`
Defined in: [src/crypto/KZG/BlobType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/BlobType.ts#L11)
Branded type for Blob (EIP-4844)
A blob is 131072 bytes (128 KB) containing 4096 field elements
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Blob"`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### KzgCommitmentType
> **KzgCommitmentType** = `Uint8Array` & `object`
Defined in: [src/crypto/KZG/KzgCommitmentType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KzgCommitmentType.ts#L11)
Branded type for KZG Commitment (EIP-4844)
A KZG commitment is 48 bytes representing a BLS12-381 G1 point
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"KzgCommitment"`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### KzgProofType
> **KzgProofType** = `Uint8Array` & `object`
Defined in: [src/crypto/KZG/KzgProofType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KzgProofType.ts#L11)
Branded type for KZG Proof (EIP-4844)
A KZG proof is 48 bytes representing a BLS12-381 G1 point
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"KzgProof"`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
## Variables
### blobToKzgCommitment()
> `const` **blobToKzgCommitment**: (`blob`) => `Uint8Array`
Defined in: [src/crypto/KZG/KZG.js:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L60)
Convert blob to KZG commitment
#### Parameters
##### blob
`Uint8Array`
#### Returns
`Uint8Array`
***
### BYTES\_PER\_BLOB
> `const` **BYTES\_PER\_BLOB**: `number` = `131072`
Defined in: [src/crypto/KZG/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/constants.js#L13)
Total bytes per blob (128 KB)
#### Since
0.0.0
***
### BYTES\_PER\_COMMITMENT
> `const` **BYTES\_PER\_COMMITMENT**: `number` = `48`
Defined in: [src/crypto/KZG/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/constants.js#L20)
Bytes per KZG commitment (BLS12-381 G1 point)
#### Since
0.0.0
***
### BYTES\_PER\_FIELD\_ELEMENT
> `const` **BYTES\_PER\_FIELD\_ELEMENT**: `number` = `32`
Defined in: [src/crypto/KZG/constants.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/constants.js#L34)
Bytes per field element
#### Since
0.0.0
***
### BYTES\_PER\_PROOF
> `const` **BYTES\_PER\_PROOF**: `number` = `48`
Defined in: [src/crypto/KZG/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/constants.js#L27)
Bytes per KZG proof (BLS12-381 G1 point)
#### Since
0.0.0
***
### computeBlobKzgProof()
> `const` **computeBlobKzgProof**: (`blob`, `commitment`) => `Uint8Array`
Defined in: [src/crypto/KZG/KZG.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L76)
Compute KZG blob proof given commitment
#### Parameters
##### blob
`Uint8Array`
##### commitment
`Uint8Array`
#### Returns
`Uint8Array`
***
### computeKzgProof()
> `const` **computeKzgProof**: (`blob`, `z`) => `object`
Defined in: [src/crypto/KZG/KZG.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L68)
Compute KZG proof for a blob at a given point
#### Parameters
##### blob
`Uint8Array`
##### z
`Uint8Array`
#### Returns
`object`
##### proof
> **proof**: `Uint8Array`
##### y
> **y**: `Uint8Array`
***
### FIELD\_ELEMENTS\_PER\_BLOB
> `const` **FIELD\_ELEMENTS\_PER\_BLOB**: `number` = `4096`
Defined in: [src/crypto/KZG/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/constants.js#L41)
Number of field elements per blob
#### Since
0.0.0
***
### verifyBlobKzgProof()
> `const` **verifyBlobKzgProof**: (`blob`, `commitment`, `proof`) => `boolean`
Defined in: [src/crypto/KZG/KZG.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L92)
Verify a KZG blob proof
#### Parameters
##### blob
`Uint8Array`
##### commitment
`Uint8Array`
##### proof
`Uint8Array`
#### Returns
`boolean`
***
### verifyBlobKzgProofBatch()
> `const` **verifyBlobKzgProofBatch**: (`blobs`, `commitments`, `proofs`) => `boolean`
Defined in: [src/crypto/KZG/KZG.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L100)
Verify multiple KZG blob proofs in batch
#### Parameters
##### blobs
`Uint8Array`\<`ArrayBufferLike`>\[]
##### commitments
`Uint8Array`\<`ArrayBufferLike`>\[]
##### proofs
`Uint8Array`\<`ArrayBufferLike`>\[]
#### Returns
`boolean`
***
### verifyKzgProof()
> `const` **verifyKzgProof**: (`commitment`, `z`, `y`, `proof`) => `boolean`
Defined in: [src/crypto/KZG/KZG.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L84)
Verify a KZG proof
#### Parameters
##### commitment
`Uint8Array`
##### z
`Uint8Array`
##### y
`Uint8Array`
##### proof
`Uint8Array`
#### Returns
`boolean`
## Functions
### BlobToKzgCommitment()
> **BlobToKzgCommitment**(`deps`): (`blob`) => `Uint8Array`
Defined in: [src/crypto/KZG/blobToKzgCommitment.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/blobToKzgCommitment.js#L21)
Factory: Convert blob to KZG commitment
#### Parameters
##### deps
Crypto dependencies
###### blobToKzgCommitment
(`blob`) => `Uint8Array`
c-kzg blobToKzgCommitment function
#### Returns
Function that converts blob to KZG commitment
> (`blob`): `Uint8Array`
##### Parameters
###### blob
`Uint8Array`
##### Returns
`Uint8Array`
#### Example
```typescript theme={null}
import { BlobToKzgCommitment } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const blobToKzgCommitment = BlobToKzgCommitment({ blobToKzgCommitment: ckzg.blobToKzgCommitment })
const commitment = blobToKzgCommitment(blob)
```
***
### ComputeBlobKzgProof()
> **ComputeBlobKzgProof**(`deps`): (`blob`, `commitment`) => `Uint8Array`
Defined in: [src/crypto/KZG/computeBlobKzgProof.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/computeBlobKzgProof.js#L28)
Factory: Compute blob KZG proof for a blob given its commitment
This is the optimized version for blob verification (EIP-4844).
Unlike computeKzgProof which requires an evaluation point z,
this function generates a proof that can be used with verifyBlobKzgProof.
#### Parameters
##### deps
Crypto dependencies
###### computeBlobKzgProof
(`blob`, `commitment`) => `Uint8Array`
c-kzg computeBlobKzgProof function
#### Returns
Function that computes blob KZG proof
> (`blob`, `commitment`): `Uint8Array`
##### Parameters
###### blob
`Uint8Array`
###### commitment
`Uint8Array`
##### Returns
`Uint8Array`
#### Example
```typescript theme={null}
import { ComputeBlobKzgProof } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const computeBlobKzgProof = ComputeBlobKzgProof({ computeBlobKzgProof: ckzg.computeBlobKzgProof })
const commitment = KZG.blobToKzgCommitment(blob)
const proof = computeBlobKzgProof(blob, commitment)
// Use with verifyBlobKzgProof(blob, commitment, proof)
```
***
### ComputeKzgProof()
> **ComputeKzgProof**(`deps`): (`blob`, `z`) => `object`
Defined in: [src/crypto/KZG/computeKzgProof.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/computeKzgProof.js#L22)
Factory: Compute KZG proof for blob at evaluation point z
#### Parameters
##### deps
Crypto dependencies
###### computeKzgProof
(`blob`, `z`) => \[`Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
c-kzg computeKzgProof function
#### Returns
Function that computes KZG proof
> (`blob`, `z`): `object`
##### Parameters
###### blob
`Uint8Array`
###### z
`Uint8Array`
##### Returns
`object`
###### proof
> **proof**: `Uint8Array`
###### y
> **y**: `Uint8Array`
#### Example
```typescript theme={null}
import { ComputeKzgProof } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const computeKzgProof = ComputeKzgProof({ computeKzgProof: ckzg.computeKzgProof })
const { proof, y } = computeKzgProof(blob, z)
```
***
### createEmptyBlob()
> **createEmptyBlob**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/KZG/createEmptyBlob.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/createEmptyBlob.js#L16)
Create empty blob filled with zeros
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
New zero-filled blob
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { createEmptyBlob } from './crypto/KZG/index.js';
const blob = createEmptyBlob();
```
***
### freeTrustedSetup()
> **freeTrustedSetup**(): `void`
Defined in: [src/crypto/KZG/loadTrustedSetup.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/loadTrustedSetup.js#L53)
Free trusted setup resources
Call when KZG operations are no longer needed.
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto/kzg](https://voltaire.tevm.sh/crypto/kzg)
#### Since
0.0.0
***
### generateRandomBlob()
> **generateRandomBlob**(`seed?`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/KZG/generateRandomBlob.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/generateRandomBlob.js#L23)
Generate random valid blob (for testing)
#### Parameters
##### seed?
`number`
Optional seed for deterministic generation
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Random blob with valid field elements
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If crypto.getRandomValues not available
#### Example
```javascript theme={null}
import { generateRandomBlob } from './crypto/KZG/index.js';
const blob = generateRandomBlob();
const deterministicBlob = generateRandomBlob(12345);
```
***
### isInitialized()
> **isInitialized**(): `boolean`
Defined in: [src/crypto/KZG/isInitialized.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/isInitialized.js#L18)
Check if KZG is initialized
#### Returns
`boolean`
true if trusted setup is loaded
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { isInitialized, loadTrustedSetup } from './crypto/KZG/index.js';
if (!isInitialized()) {
loadTrustedSetup();
}
```
***
### loadTrustedSetup()
> **loadTrustedSetup**(`_filePath?`): `void`
Defined in: [src/crypto/KZG/loadTrustedSetup.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/loadTrustedSetup.js#L28)
Load trusted setup from embedded data
Uses the embedded trusted setup from c-kzg-4844.
Call this once during application startup before using any KZG operations.
Available in both native FFI and WASM environments.
#### Parameters
##### \_filePath?
`string`
Optional path (ignored, uses embedded setup)
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto/kzg](https://voltaire.tevm.sh/crypto/kzg)
#### Since
0.0.0
#### Throws
If loading fails
#### Example
```javascript theme={null}
import { loadTrustedSetup } from './crypto/KZG/index.js';
loadTrustedSetup();
```
***
### validateBlob()
> **validateBlob**(`blob`): `void`
Defined in: [src/crypto/KZG/validateBlob.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/validateBlob.js#L22)
Validate blob format
#### Parameters
##### blob
`Uint8Array`\<`ArrayBufferLike`>
Blob to validate
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If blob is invalid
#### Example
```javascript theme={null}
import { validateBlob } from './crypto/KZG/index.js';
validateBlob(blob); // throws if invalid
```
***
### VerifyBlobKzgProof()
> **VerifyBlobKzgProof**(`deps`): (`blob`, `commitment`, `proof`) => `boolean`
Defined in: [src/crypto/KZG/verifyBlobKzgProof.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/verifyBlobKzgProof.js#L22)
Factory: Verify blob KZG proof (optimized for blob verification)
#### Parameters
##### deps
Crypto dependencies
###### verifyBlobKzgProof
(`blob`, `commitment`, `proof`) => `boolean`
c-kzg verifyBlobKzgProof function
#### Returns
Function that verifies blob KZG proof
> (`blob`, `commitment`, `proof`): `boolean`
##### Parameters
###### blob
`Uint8Array`
###### commitment
`Uint8Array`
###### proof
`Uint8Array`
##### Returns
`boolean`
#### Example
```typescript theme={null}
import { VerifyBlobKzgProof } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const verifyBlobKzgProof = VerifyBlobKzgProof({ verifyBlobKzgProof: ckzg.verifyBlobKzgProof })
const valid = verifyBlobKzgProof(blob, commitment, proof)
```
***
### VerifyBlobKzgProofBatch()
> **VerifyBlobKzgProofBatch**(`deps`): (`blobs`, `commitments`, `proofs`) => `boolean`
Defined in: [src/crypto/KZG/verifyBlobKzgProofBatch.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/verifyBlobKzgProofBatch.js#L21)
Factory: Verify multiple blob KZG proofs (batch verification)
#### Parameters
##### deps
Crypto dependencies
###### verifyBlobKzgProofBatch
(`blobs`, `commitments`, `proofs`) => `boolean`
c-kzg verifyBlobKzgProofBatch function
#### Returns
Function that verifies batch of blob KZG proofs
> (`blobs`, `commitments`, `proofs`): `boolean`
##### Parameters
###### blobs
`Uint8Array`\<`ArrayBufferLike`>\[]
###### commitments
`Uint8Array`\<`ArrayBufferLike`>\[]
###### proofs
`Uint8Array`\<`ArrayBufferLike`>\[]
##### Returns
`boolean`
#### Example
```typescript theme={null}
import { VerifyBlobKzgProofBatch } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const verifyBlobKzgProofBatch = VerifyBlobKzgProofBatch({ verifyBlobKzgProofBatch: ckzg.verifyBlobKzgProofBatch })
const valid = verifyBlobKzgProofBatch(blobs, commitments, proofs)
```
***
### VerifyKzgProof()
> **VerifyKzgProof**(`deps`): (`commitment`, `z`, `y`, `proof`) => `boolean`
Defined in: [src/crypto/KZG/verifyKzgProof.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/verifyKzgProof.js#L25)
Factory: Verify KZG proof
#### Parameters
##### deps
Crypto dependencies
###### verifyKzgProof
(`commitment`, `z`, `y`, `proof`) => `boolean`
c-kzg verifyKzgProof function
#### Returns
Function that verifies KZG proof
> (`commitment`, `z`, `y`, `proof`): `boolean`
##### Parameters
###### commitment
`Uint8Array`
###### z
`Uint8Array`
###### y
`Uint8Array`
###### proof
`Uint8Array`
##### Returns
`boolean`
#### Example
```typescript theme={null}
import { VerifyKzgProof } from '@tevm/voltaire/crypto/KZG'
import * as ckzg from 'c-kzg'
const verifyKzgProof = VerifyKzgProof({ verifyKzgProof: ckzg.verifyKzgProof })
const valid = verifyKzgProof(commitment, z, y, proof)
```
## References
### InvalidFormatError
Re-exports [InvalidFormatError](../index/index.mdx#invalidformaterror)
***
### InvalidLengthError
Re-exports [InvalidLengthError](../index/index.mdx#invalidlengtherror)
***
### KZG
Re-exports [KZG](../index/index.mdx#kzg)
# crypto/Keccak256
Source: https://voltaire.tevm.sh/generated-api/crypto/Keccak256
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Keccak256
# crypto/Keccak256
## Variables
### DIGEST\_SIZE
> `const` **DIGEST\_SIZE**: `number` = `32`
Defined in: [src/crypto/Keccak256/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/constants.js#L13)
Digest size in bytes (32 bytes = 256 bits)
#### Since
0.0.0
***
### ~~Keccak256~~
> `const` **Keccak256**: (`input`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash) & `object` = `Keccak256Hash`
Defined in: [src/crypto/Keccak256/Keccak256.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/Keccak256.js#L82)
#### Type Declaration
##### ~~contractAddress()~~
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`\<`ArrayBufferLike`>
Compute contract address from deployer and nonce
Uses CREATE formula: keccak256(rlp(\[sender, nonce]))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const address = Keccak256.contractAddress(sender, 0n);
```
##### ~~create2Address()~~
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`\<`ArrayBufferLike`>
Compute CREATE2 address
Uses CREATE2 formula: keccak256(0xff ++ sender ++ salt ++ keccak256(init\_code))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### salt
`Uint8Array`\<`ArrayBufferLike`>
32-byte salt
###### initCodeHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of initialization code
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Throws
If salt is not 32 bytes
###### Throws
If initCodeHash is not 32 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const salt = new Uint8Array(32);
const initCodeHash = new Uint8Array(32);
const address = Keccak256.create2Address(sender, salt, initCodeHash);
```
##### ~~DIGEST\_SIZE~~
> **DIGEST\_SIZE**: `number`
Digest size in bytes (32 bytes = 256 bits)
###### Since
0.0.0
##### ~~from()~~
> **from**: (`input`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Hash input with Keccak-256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/keccak256](https://voltaire.tevm.sh/crypto/keccak256) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash1 = Keccak256Hash.from("0x1234"); // Hex
const hash2 = Keccak256Hash.from("hello"); // String
const hash3 = Keccak256Hash.from(uint8array); // Bytes
```
##### ~~fromHex()~~
> **fromHex**: (`hex`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash) = `hashHex`
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
##### ~~fromString()~~
> **fromString**: (`str`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash) = `hashString`
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
##### ~~fromTopic()~~
> **fromTopic**: (`signature`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash) = `topic`
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
##### ~~hash()~~
> **hash**: (`data`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Hash data with Keccak-256
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Data to hash
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(data);
```
##### ~~hashHex()~~
> **hashHex**: (`hex`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
##### ~~hashMultiple()~~
> **hashMultiple**: (`chunks`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Hash multiple data chunks in sequence
Equivalent to hashing the concatenation of all chunks.
###### Parameters
###### chunks
readonly `Uint8Array`\<`ArrayBufferLike`>\[]
Array of data chunks to hash
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(combined);
```
##### ~~hashString()~~
> **hashString**: (`str`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
##### ~~RATE~~
> **RATE**: `number`
Rate in bytes for Keccak256 (136 bytes = 1088 bits)
###### Since
0.0.0
##### ~~selector()~~
> **selector**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Compute function selector (first 4 bytes of Keccak-256 hash)
Used for Ethereum function signatures.
###### Parameters
###### signature
`string`
Function signature string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte selector
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
```
##### ~~STATE\_SIZE~~
> **STATE\_SIZE**: `number`
State size (25 u64 words = 1600 bits)
###### Since
0.0.0
##### ~~topic()~~
> **topic**: (`signature`) => [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
#### Deprecated
Use Keccak256Hash instead
Keccak256 alias maintained for backward compatibility
***
### RATE
> `const` **RATE**: `number` = `136`
Defined in: [src/crypto/Keccak256/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/constants.js#L20)
Rate in bytes for Keccak256 (136 bytes = 1088 bits)
#### Since
0.0.0
***
### STATE\_SIZE
> `const` **STATE\_SIZE**: `number` = `25`
Defined in: [src/crypto/Keccak256/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/constants.js#L27)
State size (25 u64 words = 1600 bits)
#### Since
0.0.0
## Functions
### contractAddress()
> **contractAddress**(`sender`, `nonce`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Keccak256/contractAddress.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/contractAddress.js#L40)
Compute contract address from deployer and nonce
Uses CREATE formula: keccak256(rlp(\[sender, nonce]))\[12:]
#### Parameters
##### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
##### nonce
`bigint`
Transaction nonce
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If sender is not 20 bytes
#### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const address = Keccak256.contractAddress(sender, 0n);
```
***
### create2Address()
> **create2Address**(`sender`, `salt`, `initCodeHash`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Keccak256/create2Address.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/create2Address.js#L27)
Compute CREATE2 address
Uses CREATE2 formula: keccak256(0xff ++ sender ++ salt ++ keccak256(init\_code))\[12:]
#### Parameters
##### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
##### salt
`Uint8Array`\<`ArrayBufferLike`>
32-byte salt
##### initCodeHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of initialization code
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If sender is not 20 bytes
#### Throws
If salt is not 32 bytes
#### Throws
If initCodeHash is not 32 bytes
#### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const salt = new Uint8Array(32);
const initCodeHash = new Uint8Array(32);
const address = Keccak256.create2Address(sender, salt, initCodeHash);
```
***
### from()
> **from**(`input`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/from.js#L27)
Hash input with Keccak-256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
#### Parameters
##### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto/keccak256](https://voltaire.tevm.sh/crypto/keccak256) for crypto documentation
#### Since
0.0.0
#### Throws
If hex string is invalid
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash1 = Keccak256Hash.from("0x1234"); // Hex
const hash2 = Keccak256Hash.from("hello"); // String
const hash3 = Keccak256Hash.from(uint8array); // Bytes
```
***
### hash()
> **hash**(`data`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/hash.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/hash.js#L17)
Hash data with Keccak-256
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Data to hash
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(data);
```
***
### hashHex()
> **hashHex**(`hex`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/hashHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/hashHex.js#L18)
Hash hex string with Keccak-256
#### Parameters
##### hex
`string`
Hex string to hash (with or without 0x prefix)
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If hex string is invalid or has odd length
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
***
### hashMultiple()
> **hashMultiple**(`chunks`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/hashMultiple.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/hashMultiple.js#L19)
Hash multiple data chunks in sequence
Equivalent to hashing the concatenation of all chunks.
#### Parameters
##### chunks
readonly `Uint8Array`\<`ArrayBufferLike`>\[]
Array of data chunks to hash
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(combined);
```
***
### hashString()
> **hashString**(`str`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/hashString.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/hashString.js#L19)
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
#### Parameters
##### str
`string`
String to hash
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
***
### selector()
> **selector**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Keccak256/selector.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/selector.js#L20)
Compute function selector (first 4 bytes of Keccak-256 hash)
Used for Ethereum function signatures.
#### Parameters
##### signature
`string`
Function signature string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte selector
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
```
***
### topic()
> **topic**(`signature`): [`Keccak256Hash`](../index/index.mdx#keccak256hash)
Defined in: [src/crypto/Keccak256/topic.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/topic.js#L19)
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
#### Parameters
##### signature
`string`
Event signature string
#### Returns
[`Keccak256Hash`](../index/index.mdx#keccak256hash)
32-byte topic
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
## References
### Keccak256Hash
Re-exports [Keccak256Hash](../index/index.mdx#keccak256hash)
# crypto/Keystore
Source: https://voltaire.tevm.sh/generated-api/crypto/Keystore
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Keystore
# crypto/Keystore
## Classes
### DecryptionError
Defined in: [src/crypto/Keystore/errors.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L52)
Error thrown when decryption fails
#### Extends
* [`KeystoreError`](#keystoreerror)
#### Constructors
##### Constructor
> **new DecryptionError**(`message`): [`DecryptionError`](#decryptionerror)
Defined in: [src/crypto/Keystore/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L53)
###### Parameters
###### message
`string` = `"Decryption failed"`
###### Returns
[`DecryptionError`](#decryptionerror)
###### Overrides
[`KeystoreError`](#keystoreerror).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L55)
###### Inherited from
[`KeystoreError`](#keystoreerror).[`name`](#name-3)
***
### EncryptionError
Defined in: [src/crypto/Keystore/errors.js:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L62)
Error thrown when encryption fails
#### Extends
* [`KeystoreError`](#keystoreerror)
#### Constructors
##### Constructor
> **new EncryptionError**(`message`): [`EncryptionError`](#encryptionerror)
Defined in: [src/crypto/Keystore/errors.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L63)
###### Parameters
###### message
`string` = `"Encryption failed"`
###### Returns
[`EncryptionError`](#encryptionerror)
###### Overrides
[`KeystoreError`](#keystoreerror).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L65)
###### Inherited from
[`KeystoreError`](#keystoreerror).[`name`](#name-3)
***
### InvalidMacError
Defined in: [src/crypto/Keystore/errors.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L16)
Error thrown when MAC verification fails
#### Extends
* [`KeystoreError`](#keystoreerror)
#### Constructors
##### Constructor
> **new InvalidMacError**(`message`): [`InvalidMacError`](#invalidmacerror)
Defined in: [src/crypto/Keystore/errors.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L17)
###### Parameters
###### message
`string` = `"MAC verification failed - invalid password or corrupted keystore"`
###### Returns
[`InvalidMacError`](#invalidmacerror)
###### Overrides
[`KeystoreError`](#keystoreerror).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L21)
###### Inherited from
[`KeystoreError`](#keystoreerror).[`name`](#name-3)
***
### KeystoreError
Defined in: [src/crypto/Keystore/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L6)
Base error for Keystore operations
#### Extends
* `Error`
#### Extended by
* [`InvalidMacError`](#invalidmacerror)
* [`UnsupportedVersionError`](#unsupportedversionerror)
* [`UnsupportedKdfError`](#unsupportedkdferror)
* [`DecryptionError`](#decryptionerror)
* [`EncryptionError`](#encryptionerror)
#### Constructors
##### Constructor
> **new KeystoreError**(`message`): [`KeystoreError`](#keystoreerror)
Defined in: [src/crypto/Keystore/errors.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L7)
###### Parameters
###### message
`any`
###### Returns
[`KeystoreError`](#keystoreerror)
###### Overrides
`Error.constructor`
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L9)
###### Inherited from
`Error.name`
***
### UnsupportedKdfError
Defined in: [src/crypto/Keystore/errors.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L41)
Error thrown when KDF is unsupported
#### Extends
* [`KeystoreError`](#keystoreerror)
#### Constructors
##### Constructor
> **new UnsupportedKdfError**(`kdf`): [`UnsupportedKdfError`](#unsupportedkdferror)
Defined in: [src/crypto/Keystore/errors.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L42)
###### Parameters
###### kdf
`any`
###### Returns
[`UnsupportedKdfError`](#unsupportedkdferror)
###### Overrides
[`KeystoreError`](#keystoreerror).[`constructor`](#constructor-3)
#### Properties
##### kdf
> **kdf**: `any`
Defined in: [src/crypto/Keystore/errors.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L45)
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L44)
###### Inherited from
[`KeystoreError`](#keystoreerror).[`name`](#name-3)
***
### UnsupportedVersionError
Defined in: [src/crypto/Keystore/errors.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L28)
Error thrown when keystore version is unsupported
#### Extends
* [`KeystoreError`](#keystoreerror)
#### Constructors
##### Constructor
> **new UnsupportedVersionError**(`version`): [`UnsupportedVersionError`](#unsupportedversionerror)
Defined in: [src/crypto/Keystore/errors.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L29)
###### Parameters
###### version
`any`
###### Returns
[`UnsupportedVersionError`](#unsupportedversionerror)
###### Overrides
[`KeystoreError`](#keystoreerror).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Keystore/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L33)
###### Inherited from
[`KeystoreError`](#keystoreerror).[`name`](#name-3)
##### version
> **version**: `any`
Defined in: [src/crypto/Keystore/errors.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/errors.js#L34)
## Type Aliases
### EncryptOptions
> **EncryptOptions** = `object`
Defined in: [src/crypto/Keystore/KeystoreType.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L49)
Options for encryption
#### Properties
##### includeAddress?
> `optional` **includeAddress**: `boolean`
Defined in: [src/crypto/Keystore/KeystoreType.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L67)
Include address in keystore (default: false)
##### iv?
> `optional` **iv**: `Uint8Array`
Defined in: [src/crypto/Keystore/KeystoreType.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L55)
Custom IV (default: random 16 bytes)
##### kdf?
> `optional` **kdf**: `"scrypt"` | `"pbkdf2"`
Defined in: [src/crypto/Keystore/KeystoreType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L51)
KDF to use (default: scrypt)
##### pbkdf2C?
> `optional` **pbkdf2C**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L65)
PBKDF2 iterations (default: 262144)
##### salt?
> `optional` **salt**: `Uint8Array`
Defined in: [src/crypto/Keystore/KeystoreType.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L57)
Custom salt (default: random 32 bytes)
##### scryptN?
> `optional` **scryptN**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L59)
Scrypt N parameter (default: 262144)
##### scryptP?
> `optional` **scryptP**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L63)
Scrypt p parameter (default: 1)
##### scryptR?
> `optional` **scryptR**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L61)
Scrypt r parameter (default: 8)
##### uuid?
> `optional` **uuid**: `string`
Defined in: [src/crypto/Keystore/KeystoreType.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L53)
Custom UUID (default: auto-generated)
***
### KeystoreV3
> **KeystoreV3** = `object`
Defined in: [src/crypto/Keystore/KeystoreType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L30)
Web3 Secret Storage Definition v3 keystore
#### Properties
##### address?
> `optional` **address**: `string`
Defined in: [src/crypto/Keystore/KeystoreType.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L33)
##### crypto
> **crypto**: `object`
Defined in: [src/crypto/Keystore/KeystoreType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L34)
###### cipher
> **cipher**: `"aes-128-ctr"`
###### cipherparams
> **cipherparams**: `object`
###### cipherparams.iv
> **iv**: `string`
###### ciphertext
> **ciphertext**: `string`
###### kdf
> **kdf**: `"scrypt"` | `"pbkdf2"`
###### kdfparams
> **kdfparams**: [`ScryptParams`](#scryptparams) | [`Pbkdf2Params`](#pbkdf2params)
###### mac
> **mac**: `string`
##### id
> **id**: `string`
Defined in: [src/crypto/Keystore/KeystoreType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L32)
##### version
> **version**: `3`
Defined in: [src/crypto/Keystore/KeystoreType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L31)
***
### Pbkdf2Params
> **Pbkdf2Params** = `object`
Defined in: [src/crypto/Keystore/KeystoreType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L20)
PBKDF2 KDF parameters
#### Properties
##### c
> **c**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L21)
##### dklen
> **dklen**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L22)
##### prf
> **prf**: `"hmac-sha256"`
Defined in: [src/crypto/Keystore/KeystoreType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L23)
##### salt
> **salt**: `string`
Defined in: [src/crypto/Keystore/KeystoreType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L24)
***
### ScryptParams
> **ScryptParams** = `object`
Defined in: [src/crypto/Keystore/KeystoreType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L9)
Scrypt KDF parameters
#### Properties
##### dklen
> **dklen**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L10)
##### n
> **n**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L11)
##### p
> **p**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L12)
##### r
> **r**: `number`
Defined in: [src/crypto/Keystore/KeystoreType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L13)
##### salt
> **salt**: `string`
Defined in: [src/crypto/Keystore/KeystoreType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/KeystoreType.ts#L14)
## Variables
### Keystore
> `const` **Keystore**: `object`
Defined in: [src/crypto/Keystore/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/index.ts#L19)
#### Type Declaration
##### decrypt()
> **decrypt**: (`keystore`, `password`) => [`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Decrypt Web3 Secret Storage v3 keystore to private key
###### Parameters
###### keystore
[`KeystoreV3`](#keystorev3)
Encrypted keystore
###### password
`string`
Password for decryption
###### Returns
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Decrypted private key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If keystore version is not 3
###### Throws
If KDF is not scrypt or pbkdf2
###### Throws
If MAC verification fails (wrong password or corrupted)
###### Throws
If decryption fails
###### Example
```javascript theme={null}
import * as Keystore from './crypto/Keystore/index.js';
const keystore = { version: 3, id: '...', crypto: { ... } };
const privateKey = Keystore.decrypt(keystore, 'my-password');
```
##### encrypt()
> **encrypt**: (`privateKey`, `password`, `options?`) => `Promise`\<[`KeystoreV3`](#keystorev3)>
Encrypt private key to Web3 Secret Storage v3 keystore
###### Parameters
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Private key (32 bytes)
###### password
`string`
Password for encryption
###### options?
[`EncryptOptions`](#encryptoptions) = `{}`
Encryption options
###### Returns
`Promise`\<[`KeystoreV3`](#keystorev3)>
Encrypted keystore
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If encryption fails
###### Example
```javascript theme={null}
import * as Keystore from './crypto/Keystore/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from('0x...');
const keystore = await Keystore.encrypt(privateKey, 'my-password');
```
## Functions
### decrypt()
> **decrypt**(`keystore`, `password`): [`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Defined in: [src/crypto/Keystore/decrypt.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/decrypt.js#L33)
Decrypt Web3 Secret Storage v3 keystore to private key
#### Parameters
##### keystore
[`KeystoreV3`](#keystorev3)
Encrypted keystore
##### password
`string`
Password for decryption
#### Returns
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Decrypted private key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If keystore version is not 3
#### Throws
If KDF is not scrypt or pbkdf2
#### Throws
If MAC verification fails (wrong password or corrupted)
#### Throws
If decryption fails
#### Example
```javascript theme={null}
import * as Keystore from './crypto/Keystore/index.js';
const keystore = { version: 3, id: '...', crypto: { ... } };
const privateKey = Keystore.decrypt(keystore, 'my-password');
```
***
### encrypt()
> **encrypt**(`privateKey`, `password`, `options?`): `Promise`\<[`KeystoreV3`](#keystorev3)>
Defined in: [src/crypto/Keystore/encrypt.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keystore/encrypt.js#L27)
Encrypt private key to Web3 Secret Storage v3 keystore
#### Parameters
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Private key (32 bytes)
##### password
`string`
Password for encryption
##### options?
[`EncryptOptions`](#encryptoptions) = `{}`
Encryption options
#### Returns
`Promise`\<[`KeystoreV3`](#keystorev3)>
Encrypted keystore
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If encryption fails
#### Example
```javascript theme={null}
import * as Keystore from './crypto/Keystore/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from('0x...');
const keystore = await Keystore.encrypt(privateKey, 'my-password');
```
## References
### default
Renames and re-exports [Keystore](#keystore)
# crypto/ModExp
Source: https://voltaire.tevm.sh/generated-api/crypto/ModExp
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/ModExp
# crypto/ModExp
## Variables
### ModExp
> `const` **ModExp**: (`base`, `exp`, `modulus`) => `bigint` & `object`
Defined in: [src/crypto/ModExp/ModExp.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ModExp/ModExp.js#L35)
ModExp - Modular Exponentiation
Computes base^exp mod modulus for arbitrary-precision integers.
Used by MODEXP precompile (0x05) per EIP-198/EIP-2565.
#### Type Declaration
##### calculateGas()
> **calculateGas**: (`baseLen`, `expLen`, `modLen`, `expHead`) => `bigint`
Calculate gas cost for MODEXP operation per EIP-2565
Gas formula: max(200, floor(mult\_complexity \* iteration\_count / 3))
###### Parameters
###### baseLen
`bigint`
Length of base in bytes
###### expLen
`bigint`
Length of exponent in bytes
###### modLen
`bigint`
Length of modulus in bytes
###### expHead
`bigint`
First 32 bytes of exponent as BigInt (for leading zeros calc)
###### Returns
`bigint`
Gas cost
###### See
[https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Calculate gas for 2^3 mod 5
const gas = ModExp.calculateGas(1n, 1n, 1n, 3n);
console.log(gas); // 200n (minimum)
```
##### modexp()
> **modexp**: (`base`, `exp`, `modulus`) => `bigint`
Modular exponentiation: base^exp mod modulus
Computes arbitrary-precision modular exponentiation using native BigInt.
Used by MODEXP precompile (0x05) per EIP-198.
WARNING: This implementation is for general use. For cryptographic
applications, consider timing attack resistance.
###### Parameters
###### base
`bigint`
Base value
###### exp
`bigint`
Exponent value
###### modulus
`bigint`
Modulus value (must be > 0)
###### Returns
`bigint`
Result of base^exp mod modulus
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Compute 2^10 mod 1000 = 24
const result = ModExp.modexp(2n, 10n, 1000n);
console.log(result); // 24n
// RSA verification: signature^e mod n
const verified = ModExp.modexp(signature, e, n);
```
##### modexpBytes()
> **modexpBytes**: (`baseBytes`, `expBytes`, `modBytes`) => `Uint8Array`\<`ArrayBufferLike`>
Modular exponentiation with byte array inputs/outputs
Computes base^exp mod modulus where inputs are big-endian byte arrays.
Output is padded to modulus length per EIP-198 spec.
###### Parameters
###### baseBytes
`Uint8Array`\<`ArrayBufferLike`>
Base as big-endian bytes
###### expBytes
`Uint8Array`\<`ArrayBufferLike`>
Exponent as big-endian bytes
###### modBytes
`Uint8Array`\<`ArrayBufferLike`>
Modulus as big-endian bytes
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Result as big-endian bytes, padded to modulus length
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
const base = new Uint8Array([0x02]); // 2
const exp = new Uint8Array([0x03]); // 3
const mod = new Uint8Array([0x05]); // 5
const result = ModExp.modexpBytes(base, exp, mod);
console.log(result); // Uint8Array([0x03]) = 3
```
#### See
* [https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198) - ModExp precompile
* [https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565) - Gas cost repricing
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Using BigInt directly
const result = ModExp.modexp(2n, 10n, 1000n); // 24n
// Using byte arrays (EIP-198 format)
const base = new Uint8Array([0x02]);
const exp = new Uint8Array([0x0a]);
const mod = new Uint8Array([0x03, 0xe8]);
const resultBytes = ModExp.modexpBytes(base, exp, mod);
// Calculate gas cost
const gas = ModExp.calculateGas(1n, 1n, 2n, 10n);
```
## Functions
### calculateGas()
> **calculateGas**(`baseLen`, `expLen`, `modLen`, `expHead`): `bigint`
Defined in: [src/crypto/ModExp/calculateGas.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ModExp/calculateGas.js#L22)
Calculate gas cost for MODEXP operation per EIP-2565
Gas formula: max(200, floor(mult\_complexity \* iteration\_count / 3))
#### Parameters
##### baseLen
`bigint`
Length of base in bytes
##### expLen
`bigint`
Length of exponent in bytes
##### modLen
`bigint`
Length of modulus in bytes
##### expHead
`bigint`
First 32 bytes of exponent as BigInt (for leading zeros calc)
#### Returns
`bigint`
Gas cost
#### See
[https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565)
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Calculate gas for 2^3 mod 5
const gas = ModExp.calculateGas(1n, 1n, 1n, 3n);
console.log(gas); // 200n (minimum)
```
***
### modexp()
> **modexp**(`base`, `exp`, `modulus`): `bigint`
Defined in: [src/crypto/ModExp/compute.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ModExp/compute.js#L29)
Modular exponentiation: base^exp mod modulus
Computes arbitrary-precision modular exponentiation using native BigInt.
Used by MODEXP precompile (0x05) per EIP-198.
WARNING: This implementation is for general use. For cryptographic
applications, consider timing attack resistance.
#### Parameters
##### base
`bigint`
Base value
##### exp
`bigint`
Exponent value
##### modulus
`bigint`
Modulus value (must be > 0)
#### Returns
`bigint`
Result of base^exp mod modulus
#### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
#### Since
0.0.0
#### Throws
If modulus is zero
#### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Compute 2^10 mod 1000 = 24
const result = ModExp.modexp(2n, 10n, 1000n);
console.log(result); // 24n
// RSA verification: signature^e mod n
const verified = ModExp.modexp(signature, e, n);
```
***
### modexpBytes()
> **modexpBytes**(`baseBytes`, `expBytes`, `modBytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/ModExp/modexpBytes.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ModExp/modexpBytes.js#L28)
Modular exponentiation with byte array inputs/outputs
Computes base^exp mod modulus where inputs are big-endian byte arrays.
Output is padded to modulus length per EIP-198 spec.
#### Parameters
##### baseBytes
`Uint8Array`\<`ArrayBufferLike`>
Base as big-endian bytes
##### expBytes
`Uint8Array`\<`ArrayBufferLike`>
Exponent as big-endian bytes
##### modBytes
`Uint8Array`\<`ArrayBufferLike`>
Modulus as big-endian bytes
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Result as big-endian bytes, padded to modulus length
#### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
#### Since
0.0.0
#### Throws
If modulus is zero
#### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
const base = new Uint8Array([0x02]); // 2
const exp = new Uint8Array([0x03]); // 3
const mod = new Uint8Array([0x05]); // 5
const result = ModExp.modexpBytes(base, exp, mod);
console.log(result); // Uint8Array([0x03]) = 3
```
# crypto/P256
Source: https://voltaire.tevm.sh/generated-api/crypto/P256
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/P256
# crypto/P256
## Classes
### InvalidPrivateKeyError
Defined in: [src/crypto/P256/errors.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L80)
Error for invalid private keys
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Extends
* [`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror)
#### Constructors
##### Constructor
> **new InvalidPrivateKeyError**(`message`, `options?`): [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
Defined in: [src/crypto/P256/errors.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L85)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPrivateKeyError`](#invalidprivatekeyerror)
###### Overrides
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`constructor`](../index/index.mdx#constructor-9)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`cause`](../index/index.mdx#cause-9)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`code`](../index/index.mdx#code-9)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`context`](../index/index.mdx#context-9)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`docsPath`](../index/index.mdx#docspath-9)
##### name
> **name**: `string`
Defined in: [src/crypto/P256/errors.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L92)
###### Inherited from
`BaseInvalidPrivateKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-18)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`toJSON`](../index/index.mdx#tojson-18)
***
### InvalidPublicKeyError
Defined in: [src/crypto/P256/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L58)
Error for invalid public keys
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Extends
* [`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`, `options?`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/P256/errors.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L63)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`constructor`](../index/index.mdx#constructor-10)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`cause`](../index/index.mdx#cause-10)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`code`](../index/index.mdx#code-10)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`context`](../index/index.mdx#context-10)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`docsPath`](../index/index.mdx#docspath-10)
##### name
> **name**: `string`
Defined in: [src/crypto/P256/errors.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L70)
###### Inherited from
`BaseInvalidPublicKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-20)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`toJSON`](../index/index.mdx#tojson-20)
***
### InvalidSignatureError
Defined in: [src/crypto/P256/errors.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L36)
Error for invalid signatures
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`, `options?`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/crypto/P256/errors.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L41)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/crypto/P256/errors.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L48)
###### Inherited from
`BaseInvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
***
### P256Error
Defined in: [src/crypto/P256/errors.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L14)
Base error for P256 operations
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Constructors
##### Constructor
> **new P256Error**(`message`, `options?`): [`P256Error`](#p256error)
Defined in: [src/crypto/P256/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L19)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`P256Error`](#p256error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/P256/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/errors.js#L26)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
## Interfaces
### P256Constructor
Defined in: [src/crypto/P256/P256Constructor.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L15)
#### Properties
##### CURVE\_ORDER
> **CURVE\_ORDER**: `bigint`
Defined in: [src/crypto/P256/P256Constructor.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L22)
##### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => [`P256PublicKeyType`](#p256publickeytype)
Defined in: [src/crypto/P256/P256Constructor.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L18)
Derive public key from private key
###### Parameters
###### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
32-byte private key
###### Returns
[`P256PublicKeyType`](#p256publickeytype)
64-byte uncompressed public key (x || y coordinates)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const privateKey = new Uint8Array(32);
const publicKey = P256.derivePublicKey(privateKey);
```
##### ecdh()
> **ecdh**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/P256/P256Constructor.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L19)
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point.
###### Parameters
###### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
Your 32-byte private key
###### publicKey
[`P256PublicKeyType`](#p256publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = P256.derivePublicKey(theirPrivateKey);
const sharedSecret = P256.ecdh(myPrivateKey, theirPublicKey);
```
##### PRIVATE\_KEY\_SIZE
> **PRIVATE\_KEY\_SIZE**: `number`
Defined in: [src/crypto/P256/P256Constructor.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L23)
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `number`
Defined in: [src/crypto/P256/P256Constructor.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L24)
##### SHARED\_SECRET\_SIZE
> **SHARED\_SECRET\_SIZE**: `number`
Defined in: [src/crypto/P256/P256Constructor.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L26)
##### sign()
> **sign**: (`messageHash`, `privateKey`) => [`P256SignatureType`](#p256signaturetype)
Defined in: [src/crypto/P256/P256Constructor.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L16)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
###### Parameters
###### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash to sign
###### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
32-byte private key
###### Returns
[`P256SignatureType`](#p256signaturetype)
ECDSA signature with r, s components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
import * as Keccak256 from './crypto/Keccak256/index.js';
const messageHash = Keccak256.hashString('Hello!');
const privateKey = new Uint8Array(32);
const signature = P256.sign(messageHash, privateKey);
```
##### SIGNATURE\_COMPONENT\_SIZE
> **SIGNATURE\_COMPONENT\_SIZE**: `number`
Defined in: [src/crypto/P256/P256Constructor.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L25)
##### validatePrivateKey()
> **validatePrivateKey**: (`privateKey`) => `boolean`
Defined in: [src/crypto/P256/P256Constructor.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L20)
Validate a private key
Checks if the private key is in the valid range \[1, n-1]
###### Parameters
###### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
Private key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const privateKey = new Uint8Array(32);
const isValid = P256.validatePrivateKey(privateKey);
```
##### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Defined in: [src/crypto/P256/P256Constructor.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L21)
Validate a public key
Checks if the public key is a valid point on the P256 curve
###### Parameters
###### publicKey
[`P256PublicKeyType`](#p256publickeytype)
Public key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const publicKey = new Uint8Array(64);
const isValid = P256.validatePublicKey(publicKey);
```
##### verify()
> **verify**: (`signature`, `messageHash`, `publicKey`) => `boolean`
Defined in: [src/crypto/P256/P256Constructor.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256Constructor.ts#L17)
Verify an ECDSA signature
###### Parameters
###### signature
[`P256SignatureType`](#p256signaturetype)
ECDSA signature to verify (r and s are HashType)
###### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
###### publicKey
[`P256PublicKeyType`](#p256publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
True if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If public key format is invalid
###### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = P256.verify({ r, s }, messageHash, publicKey);
if (valid) console.log('Signature is valid!');
```
## Type Aliases
### P256PrivateKeyType
> **P256PrivateKeyType** = `Uint8Array`
Defined in: [src/crypto/P256/P256PrivateKeyType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256PrivateKeyType.ts#L7)
Private key (32 bytes scalar value)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### P256PublicKeyType
> **P256PublicKeyType** = `Uint8Array`
Defined in: [src/crypto/P256/P256PublicKeyType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256PublicKeyType.ts#L9)
Uncompressed public key (64 bytes)
Format: x-coordinate (32 bytes) || y-coordinate (32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### P256SignatureType
> **P256SignatureType** = `object`
Defined in: [src/crypto/P256/P256SignatureType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256SignatureType.ts#L11)
ECDSA signature (r, s components)
Components:
* r: x-coordinate of the ephemeral public key (32 bytes, HashType)
* s: signature proof value (32 bytes, HashType)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Properties
##### r
> **r**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/P256/P256SignatureType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256SignatureType.ts#L12)
##### s
> **s**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/P256/P256SignatureType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256SignatureType.ts#L13)
## Variables
### CURVE\_ORDER
> `const` **CURVE\_ORDER**: `bigint` = `0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n`
Defined in: [src/crypto/P256/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/constants.js#L8)
P256 curve order (number of points on the curve)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### P256
> `const` **P256**: [`P256Constructor`](#p256constructor)
Defined in: [src/crypto/P256/P256.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/P256.js#L67)
P256 namespace with cryptographic operations
***
### PRIVATE\_KEY\_SIZE
> `const` **PRIVATE\_KEY\_SIZE**: `number` = `32`
Defined in: [src/crypto/P256/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/constants.js#L18)
Private key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `number` = `64`
Defined in: [src/crypto/P256/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/constants.js#L27)
Uncompressed public key size in bytes (64 bytes, no prefix)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### SHARED\_SECRET\_SIZE
> `const` **SHARED\_SECRET\_SIZE**: `number` = `32`
Defined in: [src/crypto/P256/constants.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/constants.js#L45)
ECDH shared secret size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
***
### SIGNATURE\_COMPONENT\_SIZE
> `const` **SIGNATURE\_COMPONENT\_SIZE**: `number` = `32`
Defined in: [src/crypto/P256/constants.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/constants.js#L36)
Signature component size in bytes (r and s are each 32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
## Functions
### derivePublicKey()
> **derivePublicKey**(`privateKey`): [`P256PublicKeyType`](#p256publickeytype)
Defined in: [src/crypto/P256/derivePublicKey.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/derivePublicKey.js#L21)
Derive public key from private key
#### Parameters
##### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
32-byte private key
#### Returns
[`P256PublicKeyType`](#p256publickeytype)
64-byte uncompressed public key (x || y coordinates)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const privateKey = new Uint8Array(32);
const publicKey = P256.derivePublicKey(privateKey);
```
***
### ecdh()
> **ecdh**(`privateKey`, `publicKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/P256/ecdh.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/ecdh.js#L32)
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point.
#### Parameters
##### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
Your 32-byte private key
##### publicKey
[`P256PublicKeyType`](#p256publickeytype)
Their 64-byte uncompressed public key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If public key is invalid
#### Throws
If ECDH computation fails
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = P256.derivePublicKey(theirPrivateKey);
const sharedSecret = P256.ecdh(myPrivateKey, theirPublicKey);
```
***
### sign()
> **sign**(`messageHash`, `privateKey`): [`P256SignatureType`](#p256signaturetype)
Defined in: [src/crypto/P256/sign.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/sign.js#L28)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
#### Parameters
##### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash to sign
##### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
32-byte private key
#### Returns
[`P256SignatureType`](#p256signaturetype)
ECDSA signature with r, s components
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If signing fails
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
import * as Keccak256 from './crypto/Keccak256/index.js';
const messageHash = Keccak256.hashString('Hello!');
const privateKey = new Uint8Array(32);
const signature = P256.sign(messageHash, privateKey);
```
***
### validatePrivateKey()
> **validatePrivateKey**(`privateKey`): `boolean`
Defined in: [src/crypto/P256/validatePrivateKey.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/validatePrivateKey.js#L22)
Validate a private key
Checks if the private key is in the valid range \[1, n-1]
#### Parameters
##### privateKey
[`P256PrivateKeyType`](#p256privatekeytype)
Private key to validate
#### Returns
`boolean`
True if valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const privateKey = new Uint8Array(32);
const isValid = P256.validatePrivateKey(privateKey);
```
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/P256/validatePublicKey.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/validatePublicKey.js#L22)
Validate a public key
Checks if the public key is a valid point on the P256 curve
#### Parameters
##### publicKey
[`P256PublicKeyType`](#p256publickeytype)
Public key to validate
#### Returns
`boolean`
True if valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
const publicKey = new Uint8Array(64);
const isValid = P256.validatePublicKey(publicKey);
```
***
### verify()
> **verify**(`signature`, `messageHash`, `publicKey`): `boolean`
Defined in: [src/crypto/P256/verify.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/P256/verify.js#L26)
Verify an ECDSA signature
#### Parameters
##### signature
[`P256SignatureType`](#p256signaturetype)
ECDSA signature to verify (r and s are HashType)
##### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
##### publicKey
[`P256PublicKeyType`](#p256publickeytype)
64-byte uncompressed public key
#### Returns
`boolean`
True if signature is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If public key format is invalid
#### Example
```javascript theme={null}
import * as P256 from './crypto/P256/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = P256.verify({ r, s }, messageHash, publicKey);
if (valid) console.log('Signature is valid!');
```
# crypto/Ripemd160
Source: https://voltaire.tevm.sh/generated-api/crypto/Ripemd160
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Ripemd160
# crypto/Ripemd160
## Variables
### HEX\_SIZE
> `const` **HEX\_SIZE**: `40` = `40`
Defined in: [src/crypto/Ripemd160/constants.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/constants.js#L28)
Size of RIPEMD160 hash in hex characters (without 0x prefix)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { HEX_SIZE } from './crypto/Ripemd160/index.js';
console.log(HEX_SIZE); // 40
```
***
### ~~Ripemd160~~
> `const` **Ripemd160**: (`input`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash) & `object` = `Ripemd160Hash`
Defined in: [src/crypto/Ripemd160/Ripemd160.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/Ripemd160.js#L53)
#### Type Declaration
##### ~~from()~~
> **from**: (`input`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Hash input with RIPEMD160 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto/ripemd160](https://voltaire.tevm.sh/crypto/ripemd160) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash1 = Ripemd160Hash.from("hello"); // String
const hash2 = Ripemd160Hash.from(uint8array); // Bytes
```
##### ~~fromHex()~~
> **fromHex**: (`hex`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash) = `hashHex`
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
##### ~~fromString()~~
> **fromString**: (`str`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash) = `hashString`
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
##### ~~hash()~~
> **hash**: (`data`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash (20 bytes)
###### Parameters
###### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hash(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 20
```
##### ~~hashHex()~~
> **hashHex**: (`hex`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
##### ~~hashString()~~
> **hashString**: (`str`) => [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
##### ~~HEX\_SIZE~~
> **HEX\_SIZE**: `number`
Size of RIPEMD160 hash in hex characters (without 0x prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { HEX_SIZE } from './crypto/Ripemd160/index.js';
console.log(HEX_SIZE); // 40
```
##### ~~SIZE~~
> **SIZE**: `number`
Size of RIPEMD160 hash in bytes (160 bits)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIZE } from './crypto/Ripemd160/index.js';
console.log(SIZE); // 20
```
#### Deprecated
Use Ripemd160Hash instead
Ripemd160 alias maintained for backward compatibility
***
### SIZE
> `const` **SIZE**: `20` = `20`
Defined in: [src/crypto/Ripemd160/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/constants.js#L14)
Size of RIPEMD160 hash in bytes (160 bits)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SIZE } from './crypto/Ripemd160/index.js';
console.log(SIZE); // 20
```
## Functions
### from()
> **from**(`input`): [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Defined in: [src/crypto/Ripemd160/from.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/from.js#L24)
Hash input with RIPEMD160 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
#### Parameters
##### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
#### See
[https://voltaire.tevm.sh/crypto/ripemd160](https://voltaire.tevm.sh/crypto/ripemd160) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash1 = Ripemd160Hash.from("hello"); // String
const hash2 = Ripemd160Hash.from(uint8array); // Bytes
```
***
### hash()
> **hash**(`data`): [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Defined in: [src/crypto/Ripemd160/hash.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/hash.js#L19)
Compute RIPEMD160 hash (20 bytes)
#### Parameters
##### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hash(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 20
```
***
### hashHex()
> **hashHex**(`hex`): [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Defined in: [src/crypto/Ripemd160/hashHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/hashHex.js#L19)
Compute RIPEMD160 hash of hex string (without 0x prefix)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
***
### hashString()
> **hashString**(`str`): [`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
Defined in: [src/crypto/Ripemd160/hashString.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/hashString.js#L19)
Compute RIPEMD160 hash of UTF-8 string
#### Parameters
##### str
`string`
Input string
#### Returns
[`Ripemd160Hash`](../index/index.mdx#ripemd160hash)
20-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
## References
### Ripemd160Hash
Re-exports [Ripemd160Hash](../index/index.mdx#ripemd160hash)
# crypto/SHA256
Source: https://voltaire.tevm.sh/generated-api/crypto/SHA256
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/SHA256
# crypto/SHA256
## Variables
### BLOCK\_SIZE
> `const` **BLOCK\_SIZE**: `64` = `64`
Defined in: [src/crypto/SHA256/constants.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/constants.js#L27)
SHA256 block size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { BLOCK_SIZE } from './crypto/SHA256/index.js';
console.log(BLOCK_SIZE); // 64
```
***
### OUTPUT\_SIZE
> `const` **OUTPUT\_SIZE**: `32` = `32`
Defined in: [src/crypto/SHA256/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/constants.js#L13)
SHA256 output size in bytes (256 bits / 8)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { OUTPUT_SIZE } from './crypto/SHA256/index.js';
console.log(OUTPUT_SIZE); // 32
```
***
### ~~SHA256~~
> `const` **SHA256**: (`input`) => [`SHA256Hash`](../index/index.mdx#sha256hash) & `object` = `SHA256Hash`
Defined in: [src/crypto/SHA256/SHA256.js:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/SHA256.js#L62)
#### Type Declaration
##### ~~BLOCK\_SIZE~~
> **BLOCK\_SIZE**: `number`
SHA256 block size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { BLOCK_SIZE } from './crypto/SHA256/index.js';
console.log(BLOCK_SIZE); // 64
```
##### ~~create()~~
> **create**: () => `object`
Incremental hasher for streaming data
###### Returns
`object`
Hasher instance
###### ~~digest()~~
> **digest**: () => `Uint8Array`
###### Returns
`Uint8Array`
###### ~~update()~~
> **update**: (`data`) => `void`
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hasher = SHA256.create();
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new Uint8Array([4, 5, 6]));
const hash = hasher.digest();
```
##### ~~from()~~
> **from**: (`input`) => [`SHA256Hash`](../index/index.mdx#sha256hash)
Hash input with SHA256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/sha256](https://voltaire.tevm.sh/crypto/sha256) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash1 = SHA256Hash.from("0x1234"); // Hex
const hash2 = SHA256Hash.from("hello"); // String
const hash3 = SHA256Hash.from(uint8array); // Bytes
```
##### ~~fromHex()~~
> **fromHex**: (`hex`) => [`SHA256Hash`](../index/index.mdx#sha256hash) = `hashHex`
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
##### ~~fromString()~~
> **fromString**: (`str`) => [`SHA256Hash`](../index/index.mdx#sha256hash) = `hashString`
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
##### ~~hash()~~
> **hash**: (`data`) => [`SHA256Hash`](../index/index.mdx#sha256hash)
Compute SHA256 hash of input data
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Input data as Uint8Array
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash = SHA256Hash.from(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 32
```
##### ~~hashHex()~~
> **hashHex**: (`hex`) => [`SHA256Hash`](../index/index.mdx#sha256hash)
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
##### ~~hashString()~~
> **hashString**: (`str`) => [`SHA256Hash`](../index/index.mdx#sha256hash)
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
##### ~~OUTPUT\_SIZE~~
> **OUTPUT\_SIZE**: `number`
SHA256 output size in bytes (256 bits / 8)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { OUTPUT_SIZE } from './crypto/SHA256/index.js';
console.log(OUTPUT_SIZE); // 32
```
##### ~~toHex()~~
> **toHex**: (`hash`) => `string`
Convert hash output to hex string
###### Parameters
###### hash
`Uint8Array`\<`ArrayBufferLike`>
Hash bytes
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hash(new Uint8Array([1, 2, 3]));
const hexStr = SHA256.toHex(hash);
console.log(hexStr); // "0x..."
```
#### Deprecated
Use SHA256Hash instead
SHA256 alias maintained for backward compatibility
## Functions
### create()
> **create**(): `object`
Defined in: [src/crypto/SHA256/create.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/create.js#L19)
Incremental hasher for streaming data
#### Returns
`object`
Hasher instance
##### digest()
> **digest**: () => `Uint8Array`
###### Returns
`Uint8Array`
##### update()
> **update**: (`data`) => `void`
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hasher = SHA256.create();
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new Uint8Array([4, 5, 6]));
const hash = hasher.digest();
```
***
### from()
> **from**(`input`): [`SHA256Hash`](../index/index.mdx#sha256hash)
Defined in: [src/crypto/SHA256/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/from.js#L27)
Hash input with SHA256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
#### Parameters
##### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto/sha256](https://voltaire.tevm.sh/crypto/sha256) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash1 = SHA256Hash.from("0x1234"); // Hex
const hash2 = SHA256Hash.from("hello"); // String
const hash3 = SHA256Hash.from(uint8array); // Bytes
```
***
### hash()
> **hash**(`data`): [`SHA256Hash`](../index/index.mdx#sha256hash)
Defined in: [src/crypto/SHA256/hash.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/hash.js#L18)
Compute SHA256 hash of input data
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Input data as Uint8Array
#### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash = SHA256Hash.from(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 32
```
***
### hashHex()
> **hashHex**(`hex`): [`SHA256Hash`](../index/index.mdx#sha256hash)
Defined in: [src/crypto/SHA256/hashHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/hashHex.js#L18)
Compute SHA256 hash of hex string (without 0x prefix)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
***
### hashString()
> **hashString**(`str`): [`SHA256Hash`](../index/index.mdx#sha256hash)
Defined in: [src/crypto/SHA256/hashString.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/hashString.js#L18)
Compute SHA256 hash of UTF-8 string
#### Parameters
##### str
`string`
Input string
#### Returns
[`SHA256Hash`](../index/index.mdx#sha256hash)
32-byte hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
***
### toHex()
> **toHex**(`hash`): `string`
Defined in: [src/crypto/SHA256/toHex.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/toHex.js#L17)
Convert hash output to hex string
#### Parameters
##### hash
`Uint8Array`\<`ArrayBufferLike`>
Hash bytes
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hash(new Uint8Array([1, 2, 3]));
const hexStr = SHA256.toHex(hash);
console.log(hexStr); // "0x..."
```
## References
### SHA256Hash
Re-exports [SHA256Hash](../index/index.mdx#sha256hash)
# crypto/Secp256k1
Source: https://voltaire.tevm.sh/generated-api/crypto/Secp256k1
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/Secp256k1
# crypto/Secp256k1
## Classes
### InvalidPrivateKeyError
Defined in: [src/crypto/Secp256k1/errors.js:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L71)
Error for invalid private keys
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidPrivateKeyError } from './crypto/Secp256k1/index.js';
throw new InvalidPrivateKeyError('Invalid private key');
```
#### Extends
* [`Secp256k1Error`](#secp256k1error)
#### Constructors
##### Constructor
> **new InvalidPrivateKeyError**(`message`): [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
Defined in: [src/crypto/Secp256k1/errors.js:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L72)
###### Parameters
###### message
`any`
###### Returns
[`InvalidPrivateKeyError`](#invalidprivatekeyerror)
###### Overrides
[`Secp256k1Error`](#secp256k1error).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Secp256k1/errors.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L74)
###### Inherited from
[`Secp256k1Error`](#secp256k1error).[`name`](#name-3)
***
### InvalidPublicKeyError
Defined in: [src/crypto/Secp256k1/errors.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L52)
Error for invalid public keys
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidPublicKeyError } from './crypto/Secp256k1/index.js';
throw new InvalidPublicKeyError('Invalid public key');
```
#### Extends
* [`Secp256k1Error`](#secp256k1error)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/Secp256k1/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L53)
###### Parameters
###### message
`any`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`Secp256k1Error`](#secp256k1error).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Secp256k1/errors.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L55)
###### Inherited from
[`Secp256k1Error`](#secp256k1error).[`name`](#name-3)
***
### InvalidSignatureError
Defined in: [src/crypto/Secp256k1/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L33)
Error for invalid signatures
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidSignatureError } from './crypto/Secp256k1/index.js';
throw new InvalidSignatureError('Invalid signature');
```
#### Extends
* [`Secp256k1Error`](#secp256k1error)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/crypto/Secp256k1/errors.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L34)
###### Parameters
###### message
`any`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`Secp256k1Error`](#secp256k1error).[`constructor`](#constructor-3)
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Secp256k1/errors.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L36)
###### Inherited from
[`Secp256k1Error`](#secp256k1error).[`name`](#name-3)
***
### Secp256k1Error
Defined in: [src/crypto/Secp256k1/errors.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L14)
Base error for secp256k1 operations
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Secp256k1Error } from './crypto/Secp256k1/index.js';
throw new Secp256k1Error('Invalid operation');
```
#### Extends
* `Error`
#### Extended by
* [`InvalidSignatureError`](#invalidsignatureerror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
* [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
#### Constructors
##### Constructor
> **new Secp256k1Error**(`message`): [`Secp256k1Error`](#secp256k1error)
Defined in: [src/crypto/Secp256k1/errors.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L15)
###### Parameters
###### message
`any`
###### Returns
[`Secp256k1Error`](#secp256k1error)
###### Overrides
`Error.constructor`
#### Properties
##### name
> **name**: `string`
Defined in: [src/crypto/Secp256k1/errors.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/errors.js#L17)
###### Inherited from
`Error.name`
## Interfaces
### Secp256k1SignatureType
Defined in: [src/crypto/Secp256k1/SignatureType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/SignatureType.ts#L22)
ECDSA signature with Ethereum-compatible v value
Components:
* r: x-coordinate of the ephemeral public key (32 bytes, HashType)
* s: signature proof value (32 bytes, HashType)
* v: recovery id (27 or 28 for Ethereum)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature: BrandedSignature = {
r: Hash.from(new Uint8Array(32)),
s: Hash.from(new Uint8Array(32)),
v: 27
};
```
#### Properties
##### r
> **r**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/Secp256k1/SignatureType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/SignatureType.ts#L23)
##### s
> **s**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/crypto/Secp256k1/SignatureType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/SignatureType.ts#L24)
##### v
> **v**: `number`
Defined in: [src/crypto/Secp256k1/SignatureType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/SignatureType.ts#L25)
## Type Aliases
### ~~BrandedSignature~~
> **BrandedSignature** = [`Secp256k1SignatureType`](#secp256k1signaturetype)
Defined in: [src/crypto/Secp256k1/SignatureType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/SignatureType.ts#L31)
#### Deprecated
Use Secp256k1SignatureType instead
***
### Secp256k1PublicKeyType
> **Secp256k1PublicKeyType** = `Uint8Array` & `object`
Defined in: [src/crypto/Secp256k1/Secp256k1PublicKeyType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/Secp256k1PublicKeyType.ts#L11)
Branded secp256k1 public key type - 64 byte uncompressed public key
Format: x-coordinate (32 bytes) || y-coordinate (32 bytes)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Secp256k1PublicKey"`
##### length
> `readonly` **length**: `64`
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
## Variables
### CURVE\_ORDER
> `const` **CURVE\_ORDER**: `115792089237316195423570985008687907852837564279074904382605163141518161494337n` = `0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n`
Defined in: [src/crypto/Secp256k1/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/constants.js#L14)
secp256k1 curve order (number of points on the curve)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { CURVE_ORDER } from './crypto/Secp256k1/index.js';
console.log(CURVE_ORDER); // 0xffffffffffff...
```
***
### PRIVATE\_KEY\_SIZE
> `const` **PRIVATE\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/Secp256k1/constants.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/constants.js#L29)
Private key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { PRIVATE_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PRIVATE_KEY_SIZE); // 32
```
***
### PrivateKey
> `const` **PrivateKey**: `__module` = `PrivateKeyMethods`
Defined in: [src/crypto/Secp256k1/Secp256k1.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/Secp256k1.js#L54)
***
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `64` = `64`
Defined in: [src/crypto/Secp256k1/constants.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/constants.js#L43)
Uncompressed public key size in bytes (64 bytes, no prefix)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PUBLIC_KEY_SIZE); // 64
```
***
### PublicKey
> `const` **PublicKey**: `__module` = `PublicKeyMethods`
Defined in: [src/crypto/Secp256k1/Secp256k1.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/Secp256k1.js#L53)
***
### Secp256k1
> `const` **Secp256k1**: `object`
Defined in: [src/crypto/Secp256k1/Secp256k1.js:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/Secp256k1.js#L93)
secp256k1/ECDSA Cryptography namespace
Complete ECDSA signing and verification using the secp256k1 elliptic curve.
All operations use the audited @noble/curves library for security.
Full Ethereum compatibility with v = 27/28 recovery IDs.
#### Type Declaration
##### addPoints()
> **addPoints**: (`pubKey1`, `pubKey2`) => [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Add two secp256k1 public key points
Performs elliptic curve point addition: P1 + P2.
Used in ERC-5564 stealth address generation.
###### Parameters
###### pubKey1
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
First 64-byte uncompressed public key
###### pubKey2
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Second 64-byte uncompressed public key
###### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If either public key is invalid
###### Throws
If point addition fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const pubKey1 = Secp256k1.derivePublicKey(privateKey1);
const pubKey2 = Secp256k1.derivePublicKey(privateKey2);
const sum = Secp256k1.addPoints(pubKey1, pubKey2);
console.log(sum.length); // 64
```
##### createKeyPair()
> **createKeyPair**: () => `object`
Generate a new secp256k1 key pair
###### Returns
`object`
Key pair with 32-byte private key and 65-byte uncompressed public key
###### privateKey
> **privateKey**: `Uint8Array`
###### publicKey
> **publicKey**: `Uint8Array`
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const { privateKey, publicKey } = Secp256k1.createKeyPair();
```
##### CURVE\_ORDER
> **CURVE\_ORDER**: `bigint`
secp256k1 curve order (number of points on the curve)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { CURVE_ORDER } from './crypto/Secp256k1/index.js';
console.log(CURVE_ORDER); // 0xffffffffffff...
```
##### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Derive public key from private key
Computes the public key point from a private key using scalar
multiplication on the secp256k1 curve.
###### Parameters
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from(new Uint8Array(32));
const publicKey = Secp256k1.derivePublicKey(privateKey);
console.log(publicKey.length); // 64
```
##### ecdh()
> **ecdh**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`>
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
##### getSharedSecret()
> **getSharedSecret**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`> = `ecdh`
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
##### isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Validate private key
Checks that the private key is within valid range \[1, n-1] where n
is the curve order.
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
`boolean`
true if private key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const privateKey = new Uint8Array(32);
const valid = Secp256k1.isValidPrivateKey(privateKey);
```
##### isValidPublicKey()
> **isValidPublicKey**: (`publicKey`) => `publicKey is Secp256k1PublicKeyType`
Validate public key
Checks that the public key is a valid point on the secp256k1 curve.
###### Parameters
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
###### Returns
`publicKey is Secp256k1PublicKeyType`
true if public key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const publicKey = new Uint8Array(64);
if (Secp256k1.isValidPublicKey(publicKey)) {
const branded = publicKey; // now Secp256k1PublicKeyType
}
```
##### isValidSignature()
> **isValidSignature**: (`signature`) => `boolean`
Validate signature components
Checks that r and s are within valid range \[1, n-1] where n is the
curve order. Also enforces low-s values to prevent malleability.
###### Parameters
###### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature to validate (r and s are HashType)
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature = { r: Hash.from(new Uint8Array(32)), s: Hash.from(new Uint8Array(32)), v: 27 };
const valid = Secp256k1.isValidSignature(signature);
```
##### PRIVATE\_KEY\_SIZE
> **PRIVATE\_KEY\_SIZE**: `number`
Private key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PRIVATE_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PRIVATE_KEY_SIZE); // 32
```
##### PrivateKey
> **PrivateKey**: `__module` = `PrivateKeyMethods`
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `number`
Uncompressed public key size in bytes (64 bytes, no prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PUBLIC_KEY_SIZE); // 64
```
##### PublicKey
> **PublicKey**: `__module` = `PublicKeyMethods`
##### randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a cryptographically secure random secp256k1 private key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const privateKey = Secp256k1.randomPrivateKey();
const publicKey = Secp256k1.derivePublicKey(privateKey);
```
##### recoverPublicKey()
> **recoverPublicKey**: (`signature`, `messageHash`) => [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Recover public key from signature and message hash
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
###### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const messageHash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
##### recoverPublicKeyFromHash()
> **recoverPublicKeyFromHash**: (`signature`, `hash`) => [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Recover public key from signature and pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use recoverPublicKey() instead.
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Recover public key from a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKeyFromHash(
{ r: rBytes, s: sBytes, v: 27 },
hash
);
// For comparison, recoverPublicKey() hashes internally (message-level API)
const recovered2 = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
##### scalarMultiply()
> **scalarMultiply**: (`scalar`) => [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Multiply generator point by scalar
Performs scalar multiplication: scalar \* G (generator point).
Used in ERC-5564 stealth address generation.
###### Parameters
###### scalar
`Uint8Array`\<`ArrayBufferLike`>
32-byte scalar value
###### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const scalar = new Uint8Array(32);
scalar[31] = 5; // scalar = 5
const result = Secp256k1.scalarMultiply(scalar);
console.log(result.length); // 64
```
##### sign()
> **sign**: (`messageHash`, `privateKey`) => [`Secp256k1SignatureType`](#secp256k1signaturetype)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash to sign
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const messageHash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.sign(messageHash, privateKey);
```
##### Signature
> **Signature**: `__module` = `SignatureMethods`
##### SIGNATURE\_COMPONENT\_SIZE
> **SIGNATURE\_COMPONENT\_SIZE**: `number`
Signature component size in bytes (r and s are each 32 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIGNATURE_COMPONENT_SIZE } from './crypto/Secp256k1/index.js';
console.log(SIGNATURE_COMPONENT_SIZE); // 32
```
##### signHash()
> **signHash**: (`hash`, `privateKey`) => [`Secp256k1SignatureType`](#secp256k1signaturetype)
Sign a pre-hashed message with a private key
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use sign() instead.
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash to sign (pre-hashed message)
###### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails or hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
// Sign a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.signHash(hash, privateKey);
// For comparison, sign() hashes internally (message-level API)
const signature2 = Secp256k1.sign(Hash.keccak256String('Hello!'), privateKey);
```
##### verify()
> **verify**: (`signature`, `messageHash`, `publicKey`) => `boolean`
Verify an ECDSA signature
###### Parameters
###### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
###### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature v is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
##### verifyHash()
> **verifyHash**: (`signature`, `hash`, `publicKey`) => `boolean`
Verify an ECDSA signature against a pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use verify() instead.
###### Parameters
###### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Verify a signature against a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const valid = Secp256k1.verifyHash({ r, s, v: 27 }, hash, publicKey);
// For comparison, verify() hashes internally (message-level API)
const valid2 = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Sign a message hash
const messageHash = Hash.keccak256String('Hello, Ethereum!');
const privateKey = new Uint8Array(32);
const signature = Secp256k1.sign(messageHash, privateKey);
// Verify signature
const publicKey = Secp256k1.derivePublicKey(privateKey);
const valid = Secp256k1.verify(signature, messageHash, publicKey);
// Recover public key from signature
const recovered = Secp256k1.recoverPublicKey(signature, messageHash);
// Hash-level API for interop with other libraries
const hash = Hash.keccak256String('Hello');
const hashSig = Secp256k1.signHash(hash, privateKey);
const hashValid = Secp256k1.verifyHash(hashSig, hash, publicKey);
```
***
### Signature
> `const` **Signature**: `__module` = `SignatureMethods`
Defined in: [src/crypto/Secp256k1/Secp256k1.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/Secp256k1.js#L52)
***
### SIGNATURE\_COMPONENT\_SIZE
> `const` **SIGNATURE\_COMPONENT\_SIZE**: `32` = `32`
Defined in: [src/crypto/Secp256k1/constants.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/constants.js#L57)
Signature component size in bytes (r and s are each 32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SIGNATURE_COMPONENT_SIZE } from './crypto/Secp256k1/index.js';
console.log(SIGNATURE_COMPONENT_SIZE); // 32
```
## Functions
### addPoints()
> **addPoints**(`pubKey1`, `pubKey2`): [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Defined in: [src/crypto/Secp256k1/addPoints.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/addPoints.js#L29)
Add two secp256k1 public key points
Performs elliptic curve point addition: P1 + P2.
Used in ERC-5564 stealth address generation.
#### Parameters
##### pubKey1
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
First 64-byte uncompressed public key
##### pubKey2
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Second 64-byte uncompressed public key
#### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Result 64-byte uncompressed public key
#### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
#### Since
0.0.0
#### Throws
If either public key is invalid
#### Throws
If point addition fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const pubKey1 = Secp256k1.derivePublicKey(privateKey1);
const pubKey2 = Secp256k1.derivePublicKey(privateKey2);
const sum = Secp256k1.addPoints(pubKey1, pubKey2);
console.log(sum.length); // 64
```
***
### createKeyPair()
> **createKeyPair**(): `object`
Defined in: [src/crypto/Secp256k1/createKeyPair.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/createKeyPair.js#L15)
Generate a new secp256k1 key pair
#### Returns
`object`
Key pair with 32-byte private key and 65-byte uncompressed public key
##### privateKey
> **privateKey**: `Uint8Array`
##### publicKey
> **publicKey**: `Uint8Array`
#### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const { privateKey, publicKey } = Secp256k1.createKeyPair();
```
***
### derivePublicKey()
> **derivePublicKey**(`privateKey`): [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Defined in: [src/crypto/Secp256k1/derivePublicKey.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/derivePublicKey.js#L25)
Derive public key from private key
Computes the public key point from a private key using scalar
multiplication on the secp256k1 curve.
#### Parameters
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
#### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from(new Uint8Array(32));
const publicKey = Secp256k1.derivePublicKey(privateKey);
console.log(publicKey.length); // 64
```
***
### ecdh()
> **ecdh**(`privateKey`, `publicKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Secp256k1/ecdh.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/ecdh.js#L34)
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
#### Parameters
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
##### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Their 64-byte uncompressed public key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
#### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If public key is invalid
#### Throws
If ECDH computation fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
***
### getSharedSecret()
> **getSharedSecret**(`privateKey`, `publicKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Secp256k1/ecdh.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/ecdh.js#L34)
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
#### Parameters
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
##### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Their 64-byte uncompressed public key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
#### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If public key is invalid
#### Throws
If ECDH computation fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
***
### isValidPrivateKey()
> **isValidPrivateKey**(`privateKey`): `boolean`
Defined in: [src/crypto/Secp256k1/isValidPrivateKey.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/isValidPrivateKey.js#L38)
Validate private key
Checks that the private key is within valid range \[1, n-1] where n
is the curve order.
#### Parameters
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
#### Returns
`boolean`
true if private key is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const privateKey = new Uint8Array(32);
const valid = Secp256k1.isValidPrivateKey(privateKey);
```
***
### isValidPublicKey()
> **isValidPublicKey**(`publicKey`): `publicKey is Secp256k1PublicKeyType`
Defined in: [src/crypto/Secp256k1/isValidPublicKey.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/isValidPublicKey.js#L24)
Validate public key
Checks that the public key is a valid point on the secp256k1 curve.
#### Parameters
##### publicKey
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
#### Returns
`publicKey is Secp256k1PublicKeyType`
true if public key is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const publicKey = new Uint8Array(64);
if (Secp256k1.isValidPublicKey(publicKey)) {
const branded = publicKey; // now Secp256k1PublicKeyType
}
```
***
### isValidSignature()
> **isValidSignature**(`signature`): `boolean`
Defined in: [src/crypto/Secp256k1/isValidSignature.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/isValidSignature.js#L39)
Validate signature components
Checks that r and s are within valid range \[1, n-1] where n is the
curve order. Also enforces low-s values to prevent malleability.
#### Parameters
##### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature to validate (r and s are HashType)
#### Returns
`boolean`
true if signature is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature = { r: Hash.from(new Uint8Array(32)), s: Hash.from(new Uint8Array(32)), v: 27 };
const valid = Secp256k1.isValidSignature(signature);
```
***
### randomPrivateKey()
> **randomPrivateKey**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/Secp256k1/randomPrivateKey.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/randomPrivateKey.js#L16)
Generate a cryptographically secure random secp256k1 private key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
#### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const privateKey = Secp256k1.randomPrivateKey();
const publicKey = Secp256k1.derivePublicKey(privateKey);
```
***
### recoverPublicKey()
> **recoverPublicKey**(`signature`, `messageHash`): [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Defined in: [src/crypto/Secp256k1/recoverPublicKey.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/recoverPublicKey.js#L49)
Recover public key from signature and message hash
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
#### Parameters
##### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
##### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
#### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If signature or recovery fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const messageHash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
***
### recoverPublicKeyFromHash()
> **recoverPublicKeyFromHash**(`signature`, `hash`): [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Defined in: [src/crypto/Secp256k1/recoverPublicKeyFromHash.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/recoverPublicKeyFromHash.js#L64)
Recover public key from signature and pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use recoverPublicKey() instead.
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
#### Parameters
##### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
#### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If signature or recovery fails
#### Throws
If hash is not 32 bytes
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Recover public key from a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKeyFromHash(
{ r: rBytes, s: sBytes, v: 27 },
hash
);
// For comparison, recoverPublicKey() hashes internally (message-level API)
const recovered2 = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
***
### scalarMultiply()
> **scalarMultiply**(`scalar`): [`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Defined in: [src/crypto/Secp256k1/scalarMultiply.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/scalarMultiply.js#L26)
Multiply generator point by scalar
Performs scalar multiplication: scalar \* G (generator point).
Used in ERC-5564 stealth address generation.
#### Parameters
##### scalar
`Uint8Array`\<`ArrayBufferLike`>
32-byte scalar value
#### Returns
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
Result 64-byte uncompressed public key
#### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
#### Since
0.0.0
#### Throws
If scalar multiplication fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const scalar = new Uint8Array(32);
scalar[31] = 5; // scalar = 5
const result = Secp256k1.scalarMultiply(scalar);
console.log(result.length); // 64
```
***
### sign()
> **sign**(`messageHash`, `privateKey`): [`Secp256k1SignatureType`](#secp256k1signaturetype)
Defined in: [src/crypto/Secp256k1/sign.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/sign.js#L32)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
#### Parameters
##### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash to sign
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
#### Returns
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If signing fails
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const messageHash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.sign(messageHash, privateKey);
```
***
### signHash()
> **signHash**(`hash`, `privateKey`): [`Secp256k1SignatureType`](#secp256k1signaturetype)
Defined in: [src/crypto/Secp256k1/signHash.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/signHash.js#L41)
Sign a pre-hashed message with a private key
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use sign() instead.
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash to sign (pre-hashed message)
##### privateKey
[`PrivateKeyType`](../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
#### Returns
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If private key is invalid
#### Throws
If signing fails or hash is not 32 bytes
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
// Sign a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.signHash(hash, privateKey);
// For comparison, sign() hashes internally (message-level API)
const signature2 = Secp256k1.sign(Hash.keccak256String('Hello!'), privateKey);
```
***
### verify()
> **verify**(`signature`, `messageHash`, `publicKey`): `boolean`
Defined in: [src/crypto/Secp256k1/verify.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/verify.js#L41)
Verify an ECDSA signature
#### Parameters
##### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
##### messageHash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
##### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
#### Returns
`boolean`
true if signature is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If signature v is invalid
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
***
### verifyHash()
> **verifyHash**(`signature`, `hash`, `publicKey`): `boolean`
Defined in: [src/crypto/Secp256k1/verifyHash.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Secp256k1/verifyHash.js#L49)
Verify an ECDSA signature against a pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use verify() instead.
#### Parameters
##### signature
[`Secp256k1SignatureType`](#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
##### publicKey
[`Secp256k1PublicKeyType`](#secp256k1publickeytype)
64-byte uncompressed public key
#### Returns
`boolean`
true if signature is valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If hash is not 32 bytes
#### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Verify a signature against a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const valid = Secp256k1.verifyHash({ r, s, v: 27 }, hash, publicKey);
// For comparison, verify() hashes internally (message-level API)
const valid2 = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
# crypto/X25519
Source: https://voltaire.tevm.sh/generated-api/crypto/X25519
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / crypto/X25519
# crypto/X25519
## Classes
### InvalidPublicKeyError
Defined in: [src/crypto/X25519/errors.js:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L87)
Error thrown when public key is invalid
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidPublicKeyError } from './crypto/X25519/index.js';
throw new InvalidPublicKeyError('Invalid public key', {
code: 'X25519_INVALID_PUBLIC_KEY_LENGTH',
context: { length: 16, expected: 32 },
docsPath: '/crypto/x25519/scalarmult#error-handling'
});
```
#### Extends
* [`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`, `options?`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/X25519/errors.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L92)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`constructor`](../index/index.mdx#constructor-10)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`cause`](../index/index.mdx#cause-10)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`code`](../index/index.mdx#code-10)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`context`](../index/index.mdx#context-10)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`docsPath`](../index/index.mdx#docspath-10)
##### name
> **name**: `string`
Defined in: [src/crypto/X25519/errors.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L99)
###### Inherited from
`BaseInvalidPublicKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-20)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPublicKeyError`](../index/index.mdx#invalidpublickeyerror).[`toJSON`](../index/index.mdx#tojson-20)
***
### InvalidSecretKeyError
Defined in: [src/crypto/X25519/errors.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L55)
Error thrown when secret key is invalid
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { InvalidSecretKeyError } from './crypto/X25519/index.js';
throw new InvalidSecretKeyError('Invalid secret key', {
code: 'X25519_INVALID_SECRET_KEY_LENGTH',
context: { length: 16, expected: 32 },
docsPath: '/crypto/x25519/scalarmult#error-handling'
});
```
#### Extends
* [`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror)
#### Constructors
##### Constructor
> **new InvalidSecretKeyError**(`message`, `options?`): [`InvalidSecretKeyError`](#invalidsecretkeyerror)
Defined in: [src/crypto/X25519/errors.js:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L60)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSecretKeyError`](#invalidsecretkeyerror)
###### Overrides
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`constructor`](../index/index.mdx#constructor-9)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`cause`](../index/index.mdx#cause-9)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`code`](../index/index.mdx#code-9)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`context`](../index/index.mdx#context-9)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`docsPath`](../index/index.mdx#docspath-9)
##### name
> **name**: `string`
Defined in: [src/crypto/X25519/errors.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L67)
###### Inherited from
`InvalidPrivateKeyError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`getErrorChain`](../index/index.mdx#geterrorchain-18)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidPrivateKeyError`](../index/index.mdx#invalidprivatekeyerror).[`toJSON`](../index/index.mdx#tojson-18)
***
### X25519Error
Defined in: [src/crypto/X25519/errors.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L23)
Base error for X25519 operations
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519Error } from './crypto/X25519/index.js';
throw new X25519Error('Invalid operation', {
code: 'X25519_ERROR',
context: { operation: 'scalarmult' },
docsPath: '/crypto/x25519#error-handling'
});
```
#### Extends
* [`CryptoError`](../index/index.mdx#cryptoerror)
#### Constructors
##### Constructor
> **new X25519Error**(`message`, `options?`): [`X25519Error`](#x25519error)
Defined in: [src/crypto/X25519/errors.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L28)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`X25519Error`](#x25519error)
###### Overrides
[`CryptoError`](../index/index.mdx#cryptoerror).[`constructor`](../index/index.mdx#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`cause`](../index/index.mdx#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`code`](../index/index.mdx#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`context`](../index/index.mdx#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`docsPath`](../index/index.mdx#docspath-1)
##### name
> **name**: `string`
Defined in: [src/crypto/X25519/errors.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/errors.js#L35)
###### Inherited from
`CryptoError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`getErrorChain`](../index/index.mdx#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](../index/index.mdx#cryptoerror).[`toJSON`](../index/index.mdx#tojson-2)
## Type Aliases
### PublicKey
> **PublicKey** = `Uint8Array`
Defined in: [src/crypto/X25519/PublicKey.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/PublicKey.ts#L12)
X25519 public key (32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { PublicKey } from './crypto/X25519/PublicKey.js';
const publicKey: PublicKey = new Uint8Array(32);
```
***
### SecretKey
> **SecretKey** = `Uint8Array`
Defined in: [src/crypto/X25519/SecretKey.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/SecretKey.ts#L12)
X25519 secret key (32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { SecretKey } from './crypto/X25519/SecretKey.js';
const secretKey: SecretKey = new Uint8Array(32);
```
***
### SharedSecret
> **SharedSecret** = `Uint8Array`
Defined in: [src/crypto/X25519/SharedSecret.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/SharedSecret.ts#L12)
Shared secret from key exchange (32 bytes)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { SharedSecret } from './crypto/X25519/SharedSecret.js';
const shared: SharedSecret = new Uint8Array(32);
```
## Variables
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/X25519/constants.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/constants.js#L29)
Public key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/X25519/index.js';
console.log(PUBLIC_KEY_SIZE); // 32
```
***
### SECRET\_KEY\_SIZE
> `const` **SECRET\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/X25519/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/constants.js#L14)
Secret key size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/X25519/index.js';
console.log(SECRET_KEY_SIZE); // 32
```
***
### SHARED\_SECRET\_SIZE
> `const` **SHARED\_SECRET\_SIZE**: `32` = `32`
Defined in: [src/crypto/X25519/constants.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/constants.js#L44)
Shared secret size in bytes
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { SHARED_SECRET_SIZE } from './crypto/X25519/index.js';
console.log(SHARED_SECRET_SIZE); // 32
```
***
### X25519
> `const` **X25519**: `object`
Defined in: [src/crypto/X25519/X25519.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/X25519.js#L56)
X25519 Elliptic Curve Diffie-Hellman
Curve25519 key exchange algorithm for secure shared secret generation.
Fast, simple, and designed for ECDH key agreement.
Used in modern protocols like TLS 1.3, WireGuard, Signal, and SSH.
#### Type Declaration
##### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => [`PublicKey`](#publickey)
Derive public key from secret key
###### Parameters
###### secretKey
[`SecretKey`](#secretkey)
32-byte secret key
###### Returns
[`PublicKey`](#publickey)
32-byte public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const publicKey = X25519.derivePublicKey(secretKey);
console.log(publicKey.length); // 32
```
##### generateKeypair()
> **generateKeypair**: () => `object`
Generate random keypair
Uses crypto.getRandomValues for secure random generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const keypair = X25519.generateKeypair();
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
##### generateSecretKey()
> **generateSecretKey**: () => [`SecretKey`](#secretkey)
Generate random secret key
Uses crypto.getRandomValues for secure random generation
###### Returns
[`SecretKey`](#secretkey)
32-byte random secret key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = X25519.generateSecretKey();
const publicKey = X25519.derivePublicKey(secretKey);
console.log(secretKey.length); // 32
```
##### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate X25519 keypair from seed
###### Parameters
###### seed
`Uint8Array`\<`ArrayBufferLike`>
32-byte seed for deterministic generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = X25519.keypairFromSeed(seed);
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Public key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/X25519/index.js';
console.log(PUBLIC_KEY_SIZE); // 32
```
##### scalarmult()
> **scalarmult**: (`secretKey`, `publicKey`) => [`SharedSecret`](#sharedsecret)
Perform X25519 scalar multiplication (ECDH)
Computes shared secret from your secret key and their public key.
###### Parameters
###### secretKey
[`SecretKey`](#secretkey)
Your 32-byte secret key
###### publicKey
[`PublicKey`](#publickey)
Their 32-byte public key
###### Returns
[`SharedSecret`](#sharedsecret)
32-byte shared secret
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Throws
If public key is invalid
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const mySecret = crypto.getRandomValues(new Uint8Array(32));
const theirPublic = X25519.derivePublicKey(theirSecret);
const shared = X25519.scalarmult(mySecret, theirPublic);
console.log(shared.length); // 32
```
##### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Secret key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/X25519/index.js';
console.log(SECRET_KEY_SIZE); // 32
```
##### SHARED\_SECRET\_SIZE
> **SHARED\_SECRET\_SIZE**: `32`
Shared secret size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHARED_SECRET_SIZE } from './crypto/X25519/index.js';
console.log(SHARED_SECRET_SIZE); // 32
```
##### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate a public key
Checks if the public key has correct length
###### Parameters
###### publicKey
[`PublicKey`](#publickey)
Public key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const publicKey = new Uint8Array(32);
const valid = X25519.validatePublicKey(publicKey);
```
##### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate a secret key
Checks if the secret key has correct length and can derive a public key
###### Parameters
###### secretKey
[`SecretKey`](#secretkey)
Secret key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = new Uint8Array(32);
const valid = X25519.validateSecretKey(secretKey);
```
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
// Generate two keypairs
const seed1 = crypto.getRandomValues(new Uint8Array(32));
const seed2 = crypto.getRandomValues(new Uint8Array(32));
const keypair1 = X25519.keypairFromSeed(seed1);
const keypair2 = X25519.keypairFromSeed(seed2);
// Perform key exchange
const shared1 = X25519.scalarmult(keypair1.secretKey, keypair2.publicKey);
const shared2 = X25519.scalarmult(keypair2.secretKey, keypair1.publicKey);
// shared1 === shared2 (same shared secret from both sides)
```
## Functions
### derivePublicKey()
> **derivePublicKey**(`secretKey`): [`PublicKey`](#publickey)
Defined in: [src/crypto/X25519/derivePublicKey.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/derivePublicKey.js#L21)
Derive public key from secret key
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
32-byte secret key
#### Returns
[`PublicKey`](#publickey)
32-byte public key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If secret key is invalid
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const publicKey = X25519.derivePublicKey(secretKey);
console.log(publicKey.length); // 32
```
***
### generateKeypair()
> **generateKeypair**(): `object`
Defined in: [src/crypto/X25519/generateKeypair.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/generateKeypair.js#L21)
Generate random keypair
Uses crypto.getRandomValues for secure random generation
#### Returns
`object`
Object with secretKey and publicKey
##### publicKey
> **publicKey**: [`PublicKey`](#publickey)
##### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const keypair = X25519.generateKeypair();
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
***
### generateSecretKey()
> **generateSecretKey**(): [`SecretKey`](#secretkey)
Defined in: [src/crypto/X25519/generateSecretKey.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/generateSecretKey.js#L20)
Generate random secret key
Uses crypto.getRandomValues for secure random generation
#### Returns
[`SecretKey`](#secretkey)
32-byte random secret key
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = X25519.generateSecretKey();
const publicKey = X25519.derivePublicKey(secretKey);
console.log(secretKey.length); // 32
```
***
### keypairFromSeed()
> **keypairFromSeed**(`seed`): `object`
Defined in: [src/crypto/X25519/keypairFromSeed.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/keypairFromSeed.js#L22)
Generate X25519 keypair from seed
#### Parameters
##### seed
`Uint8Array`\<`ArrayBufferLike`>
32-byte seed for deterministic generation
#### Returns
`object`
Object with secretKey and publicKey
##### publicKey
> **publicKey**: [`PublicKey`](#publickey)
##### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If seed length is invalid
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = X25519.keypairFromSeed(seed);
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
***
### scalarmult()
> **scalarmult**(`secretKey`, `publicKey`): [`SharedSecret`](#sharedsecret)
Defined in: [src/crypto/X25519/scalarmult.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/scalarmult.js#L31)
Perform X25519 scalar multiplication (ECDH)
Computes shared secret from your secret key and their public key.
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
Your 32-byte secret key
##### publicKey
[`PublicKey`](#publickey)
Their 32-byte public key
#### Returns
[`SharedSecret`](#sharedsecret)
32-byte shared secret
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If secret key is invalid
#### Throws
If public key is invalid
#### Throws
If scalar multiplication fails
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const mySecret = crypto.getRandomValues(new Uint8Array(32));
const theirPublic = X25519.derivePublicKey(theirSecret);
const shared = X25519.scalarmult(mySecret, theirPublic);
console.log(shared.length); // 32
```
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/X25519/validatePublicKey.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/validatePublicKey.js#L20)
Validate a public key
Checks if the public key has correct length
#### Parameters
##### publicKey
[`PublicKey`](#publickey)
Public key to validate
#### Returns
`boolean`
True if valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const publicKey = new Uint8Array(32);
const valid = X25519.validatePublicKey(publicKey);
```
***
### validateSecretKey()
> **validateSecretKey**(`secretKey`): `boolean`
Defined in: [src/crypto/X25519/validateSecretKey.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/X25519/validateSecretKey.js#L21)
Validate a secret key
Checks if the secret key has correct length and can derive a public key
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
Secret key to validate
#### Returns
`boolean`
True if valid, false otherwise
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = new Uint8Array(32);
const valid = X25519.validateSecretKey(secretKey);
```
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/evm/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / evm
# evm
EVM (Ethereum Virtual Machine) module
Provides execution frame, host interface, and complete opcode handler implementations.
Based on guillotine-mini architecture with TypeScript/Zig dual implementation.
## Namespaces
* [Arithmetic](namespaces/Arithmetic.mdx)
* [Bitwise](namespaces/Bitwise.mdx)
* [Block](namespaces/Block.mdx)
* [Comparison](namespaces/Comparison.mdx)
* [Context](namespaces/Context.mdx)
* [Control](namespaces/Control.mdx)
* [Keccak](namespaces/Keccak.mdx)
* [Log](namespaces/Log.mdx)
* [Memory](namespaces/Memory.mdx)
* [Stack](namespaces/Stack.mdx)
* [Storage](namespaces/Storage.mdx)
* [System](namespaces/System.mdx)
## Type Aliases
### BrandedFrame
> **BrandedFrame** = `object`
Defined in: [src/evm/Frame/FrameType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L11)
BrandedFrame - EVM execution frame
Represents an EVM execution frame with stack, memory, gas accounting,
and execution state. Based on guillotine-mini Frame structure.
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Frame"`
Defined in: [src/evm/Frame/FrameType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L12)
##### accessedAddresses?
> `optional` **accessedAddresses**: `Set`\<`string`>
Defined in: [src/evm/Frame/FrameType.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L47)
##### accessedStorageKeys?
> `optional` **accessedStorageKeys**: `Map`\<`string`, `boolean`>
Defined in: [src/evm/Frame/FrameType.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L48)
##### address
> **address**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/Frame/FrameType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L28)
##### authorized
> **authorized**: `bigint` | `null`
Defined in: [src/evm/Frame/FrameType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L40)
##### blobBaseFee?
> `optional` **blobBaseFee**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L62)
##### blobVersionedHashes?
> `optional` **blobVersionedHashes**: `bigint`\[]
Defined in: [src/evm/Frame/FrameType.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L65)
##### blockBaseFee?
> `optional` **blockBaseFee**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L60)
##### blockDifficulty?
> `optional` **blockDifficulty**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L58)
##### blockGasLimit?
> `optional` **blockGasLimit**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L57)
##### blockHashes?
> `optional` **blockHashes**: `Map`\<`bigint`, `bigint`>
Defined in: [src/evm/Frame/FrameType.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L64)
##### blockNumber?
> `optional` **blockNumber**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L55)
##### blockPrevrandao?
> `optional` **blockPrevrandao**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L59)
##### blockTimestamp?
> `optional` **blockTimestamp**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L56)
##### bytecode
> **bytecode**: `Uint8Array`
Defined in: [src/evm/Frame/FrameType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L24)
##### calldata
> **calldata**: `Uint8Array`
Defined in: [src/evm/Frame/FrameType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L30)
##### callDepth
> **callDepth**: `number`
Defined in: [src/evm/Frame/FrameType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L41)
##### caller
> **caller**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/Frame/FrameType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L27)
##### chainId?
> `optional` **chainId**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L61)
##### coinbase?
> `optional` **coinbase**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/Frame/FrameType.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L63)
##### gasRefunds?
> `optional` **gasRefunds**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L52)
##### gasRemaining
> **gasRemaining**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L23)
##### hardfork?
> `optional` **hardfork**: [`HardforkType`](../primitives/Hardfork.mdx#hardforktype)
Defined in: [src/evm/Frame/FrameType.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L44)
##### isStatic
> **isStatic**: `boolean`
Defined in: [src/evm/Frame/FrameType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L37)
##### logs?
> `optional` **logs**: `object`\[]
Defined in: [src/evm/Frame/FrameType.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L69)
###### address
> **address**: [`AddressType`](../primitives/Address.mdx#addresstype)
###### data
> **data**: `Uint8Array`
###### topics
> **topics**: `bigint`\[]
##### memory
> **memory**: `Map`\<`number`, `number`>
Defined in: [src/evm/Frame/FrameType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L18)
##### memorySize
> **memorySize**: `number`
Defined in: [src/evm/Frame/FrameType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L19)
##### output
> **output**: `Uint8Array`
Defined in: [src/evm/Frame/FrameType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L31)
##### pc
> **pc**: `number`
Defined in: [src/evm/Frame/FrameType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L22)
##### returnData
> **returnData**: `Uint8Array`
Defined in: [src/evm/Frame/FrameType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L32)
##### reverted
> **reverted**: `boolean`
Defined in: [src/evm/Frame/FrameType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L36)
##### selfBalance?
> `optional` **selfBalance**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L66)
##### stack
> **stack**: `bigint`\[]
Defined in: [src/evm/Frame/FrameType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L15)
##### stopped
> **stopped**: `boolean`
Defined in: [src/evm/Frame/FrameType.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L35)
##### storageOriginalValues?
> `optional` **storageOriginalValues**: `Map`\<`string`, `bigint`>
Defined in: [src/evm/Frame/FrameType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L51)
##### value
> **value**: `bigint`
Defined in: [src/evm/Frame/FrameType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L29)
#### Methods
##### add()
> **add**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L76)
###### Returns
[`EvmError`](#evmerror) | `null`
##### addmod()
> **addmod**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L83)
###### Returns
[`EvmError`](#evmerror) | `null`
##### div()
> **div**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L79)
###### Returns
[`EvmError`](#evmerror) | `null`
##### exp()
> **exp**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L85)
###### Returns
[`EvmError`](#evmerror) | `null`
##### mod()
> **mod**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L81)
###### Returns
[`EvmError`](#evmerror) | `null`
##### mul()
> **mul**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L77)
###### Returns
[`EvmError`](#evmerror) | `null`
##### mulmod()
> **mulmod**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L84)
###### Returns
[`EvmError`](#evmerror) | `null`
##### sdiv()
> **sdiv**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L80)
###### Returns
[`EvmError`](#evmerror) | `null`
##### signextend()
> **signextend**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L86)
###### Returns
[`EvmError`](#evmerror) | `null`
##### smod()
> **smod**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L82)
###### Returns
[`EvmError`](#evmerror) | `null`
##### sub()
> **sub**(): [`EvmError`](#evmerror) | `null`
Defined in: [src/evm/Frame/FrameType.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L78)
###### Returns
[`EvmError`](#evmerror) | `null`
***
### BrandedHost
> **BrandedHost** = `object`
Defined in: [src/evm/Host/HostType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L30)
BrandedHost - EVM host interface for external state access
Provides access to account state (balances, storage, code, nonces) and
nested execution capabilities.
## Architecture Note
This module provides low-level EVM primitives (opcode handlers, frame management).
For full EVM execution with nested calls, use:
* **guillotine**: Production EVM with async state access, tracing, and full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing and simple use cases
The `call` and `create` methods on this interface are optional - when not provided,
system opcodes (CALL, CREATE, etc.) will return a NotImplemented error. This is
intentional: these low-level utils don't include a full execution engine.
Based on guillotine-mini HostInterface vtable pattern.
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Host"`
Defined in: [src/evm/Host/HostType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L31)
##### call()?
> `optional` **call**: (`params`) => [`CallResult`](#callresult)
Defined in: [src/evm/Host/HostType.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L91)
Execute a nested CALL operation (CALL, STATICCALL, DELEGATECALL, CALLCODE)
Optional - when not provided, CALL-family opcodes return NotImplemented error.
Full implementations provided by guillotine/guillotine-mini EVM engines.
###### Parameters
###### params
[`CallParams`](#callparams)
###### Returns
[`CallResult`](#callresult)
##### create()?
> `optional` **create**: (`params`) => [`CreateResult`](#createresult)
Defined in: [src/evm/Host/HostType.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L99)
Execute a nested CREATE operation (CREATE, CREATE2)
Optional - when not provided, CREATE-family opcodes return NotImplemented error.
Full implementations provided by guillotine/guillotine-mini EVM engines.
###### Parameters
###### params
[`CreateParams`](#createparams)
###### Returns
[`CreateResult`](#createresult)
##### getBalance()
> **getBalance**: (`address`) => `bigint`
Defined in: [src/evm/Host/HostType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L36)
Get account balance
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### Returns
`bigint`
##### getCode()
> **getCode**: (`address`) => `Uint8Array`
Defined in: [src/evm/Host/HostType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L46)
Get account code
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### Returns
`Uint8Array`
##### getNonce()
> **getNonce**: (`address`) => `bigint`
Defined in: [src/evm/Host/HostType.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L66)
Get account nonce
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### Returns
`bigint`
##### getStorage()
> **getStorage**: (`address`, `slot`) => `bigint`
Defined in: [src/evm/Host/HostType.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L56)
Get storage slot value
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
`bigint`
##### getTransientStorage()
> **getTransientStorage**: (`address`, `slot`) => `bigint`
Defined in: [src/evm/Host/HostType.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L77)
Get transient storage slot value (EIP-1153)
Transaction-scoped, cleared at end of transaction
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
`bigint`
##### setBalance()
> **setBalance**: (`address`, `balance`) => `void`
Defined in: [src/evm/Host/HostType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L41)
Set account balance
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### balance
`bigint`
###### Returns
`void`
##### setCode()
> **setCode**: (`address`, `code`) => `void`
Defined in: [src/evm/Host/HostType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L51)
Set account code
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### code
`Uint8Array`
###### Returns
`void`
##### setNonce()
> **setNonce**: (`address`, `nonce`) => `void`
Defined in: [src/evm/Host/HostType.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L71)
Set account nonce
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### nonce
`bigint`
###### Returns
`void`
##### setStorage()
> **setStorage**: (`address`, `slot`, `value`) => `void`
Defined in: [src/evm/Host/HostType.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L61)
Set storage slot value
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### value
`bigint`
###### Returns
`void`
##### setTransientStorage()
> **setTransientStorage**: (`address`, `slot`, `value`) => `void`
Defined in: [src/evm/Host/HostType.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/HostType.ts#L83)
Set transient storage slot value (EIP-1153)
Transaction-scoped, cleared at end of transaction
###### Parameters
###### address
[`AddressType`](../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### value
`bigint`
###### Returns
`void`
***
### CallParams
> **CallParams** = `object`
Defined in: [src/evm/InstructionHandlerType.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L60)
CallParams - Parameters for EVM call operations
Used by CALL, STATICCALL, DELEGATECALL, CALLCODE opcodes.
#### Example
```typescript theme={null}
const params: CallParams = {
callType: "CALL",
target: targetAddress,
value: 1000000000000000000n, // 1 ether in wei
gasLimit: 100000n,
input: calldata,
caller: frame.address,
isStatic: false,
};
```
#### Properties
##### caller
> **caller**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/InstructionHandlerType.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L77)
Caller address
##### callType
> **callType**: [`CallType`](#calltype-1)
Defined in: [src/evm/InstructionHandlerType.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L62)
Type of call operation
##### depth
> **depth**: `number`
Defined in: [src/evm/InstructionHandlerType.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L83)
Call depth
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L71)
Gas limit for call
##### input
> **input**: `Uint8Array`
Defined in: [src/evm/InstructionHandlerType.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L74)
Input data (calldata)
##### isStatic
> **isStatic**: `boolean`
Defined in: [src/evm/InstructionHandlerType.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L80)
Static call flag (write protection)
##### target
> **target**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/InstructionHandlerType.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L65)
Target contract address
##### value
> **value**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L68)
Value to transfer (wei)
***
### CallResult
> **CallResult** = `object`
Defined in: [src/evm/InstructionHandlerType.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L112)
CallResult - Result of EVM call operation
Returned by call operations (CALL, STATICCALL, DELEGATECALL, etc.)
#### Example
```typescript theme={null}
// Successful call
const result: CallResult = {
success: true,
gasUsed: 21000n,
output: returnData,
logs: [{ address, topics, data }],
gasRefund: 0n,
};
// Failed call (reverted)
const revertResult: CallResult = {
success: false,
gasUsed: 50000n,
output: revertReason,
logs: [],
gasRefund: 0n,
};
```
#### Properties
##### gasRefund
> **gasRefund**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L130)
Gas refund from storage deletions
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L117)
Gas consumed by call
##### logs
> **logs**: `object`\[]
Defined in: [src/evm/InstructionHandlerType.ts:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L123)
Logs emitted during call
###### address
> **address**: [`AddressType`](../primitives/Address.mdx#addresstype)
###### data
> **data**: `Uint8Array`
###### topics
> **topics**: `bigint`\[]
##### output
> **output**: `Uint8Array`
Defined in: [src/evm/InstructionHandlerType.ts:120](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L120)
Return data or revert reason
##### success
> **success**: `boolean`
Defined in: [src/evm/InstructionHandlerType.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L114)
Whether call succeeded (false if reverted)
***
### CallType
> **CallType** = `"CALL"` | `"STATICCALL"` | `"DELEGATECALL"` | `"CALLCODE"`
Defined in: [src/evm/InstructionHandlerType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L36)
CallType - EVM call operation types
Determines context preservation for cross-contract calls.
***
### CreateParams
> **CreateParams** = `object`
Defined in: [src/evm/InstructionHandlerType.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L150)
CreateParams - Parameters for contract creation
Used by CREATE and CREATE2 opcodes.
#### Example
```typescript theme={null}
// CREATE2 with deterministic address
const params: CreateParams = {
caller: deployerAddress,
value: 0n,
initCode: contractBytecode,
gasLimit: 1000000n,
salt: 0x123n, // For CREATE2
};
```
#### Properties
##### caller
> **caller**: [`AddressType`](../primitives/Address.mdx#addresstype)
Defined in: [src/evm/InstructionHandlerType.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L152)
Deployer address
##### depth
> **depth**: `number`
Defined in: [src/evm/InstructionHandlerType.ts:167](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L167)
Call depth
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:161](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L161)
Gas limit for deployment
##### initCode
> **initCode**: `Uint8Array`
Defined in: [src/evm/InstructionHandlerType.ts:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L158)
Initialization code
##### salt?
> `optional` **salt**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:164](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L164)
Salt for CREATE2 (optional)
##### value
> **value**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L155)
Value to transfer (wei)
***
### CreateResult
> **CreateResult** = `object`
Defined in: [src/evm/InstructionHandlerType.ts:194](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L194)
CreateResult - Result of contract creation
Returned by CREATE and CREATE2 operations.
#### Example
```typescript theme={null}
// Successful deployment
const result: CreateResult = {
success: true,
address: newContractAddress,
gasUsed: 200000n,
output: runtimeCode,
};
// Failed deployment
const failResult: CreateResult = {
success: false,
address: null,
gasUsed: 100000n,
output: revertReason,
};
```
#### Properties
##### address
> **address**: [`AddressType`](../primitives/Address.mdx#addresstype) | `null`
Defined in: [src/evm/InstructionHandlerType.ts:199](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L199)
Address of deployed contract (null if failed)
##### gasRefund
> **gasRefund**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:208](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L208)
Gas refund
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/evm/InstructionHandlerType.ts:202](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L202)
Gas consumed by deployment
##### output
> **output**: `Uint8Array`
Defined in: [src/evm/InstructionHandlerType.ts:205](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L205)
Runtime code or revert reason
##### success
> **success**: `boolean`
Defined in: [src/evm/InstructionHandlerType.ts:196](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L196)
Whether deployment succeeded
***
### EvmError
> **EvmError** = \{ `type`: `"StackOverflow"`; } | \{ `type`: `"StackUnderflow"`; } | \{ `type`: `"OutOfGas"`; } | \{ `type`: `"OutOfBounds"`; } | \{ `type`: `"InvalidJump"`; } | \{ `type`: `"InvalidOpcode"`; } | \{ `type`: `"RevertExecuted"`; } | \{ `type`: `"CallDepthExceeded"`; } | \{ `type`: `"WriteProtection"`; } | \{ `type`: `"InsufficientBalance"`; } | \{ `message`: `string`; `type`: `"NotImplemented"`; }
Defined in: [src/evm/Frame/FrameType.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/FrameType.ts#L92)
EvmError - Frame execution errors
***
### InstructionHandler()
> **InstructionHandler** = (`frame`, `host`) => [`EvmError`](#evmerror) | \{ `type`: `"Success"`; }
Defined in: [src/evm/InstructionHandlerType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/InstructionHandlerType.ts#L26)
InstructionHandler - Function signature for EVM opcode handlers
Each opcode is implemented as a function that mutates the frame state
and returns success or an error.
Based on guillotine-mini instruction handler pattern.
#### Parameters
##### frame
[`BrandedFrame`](#brandedframe)
##### host
[`BrandedHost`](#brandedhost)
#### Returns
[`EvmError`](#evmerror) | \{ `type`: `"Success"`; }
#### Example
```typescript theme={null}
// ADD opcode handler (0x01)
const addHandler: InstructionHandler = (frame: BrandedFrame, host: BrandedHost) => {
if (frame.stack.length < 2) {
return { type: "StackUnderflow" };
}
const b = frame.stack.pop()!;
const a = frame.stack.pop()!;
frame.stack.push((a + b) % 2n**256n); // Mod 2^256
return { type: "Success" };
};
```
## Functions
### Frame()
> **Frame**(`params`): [`BrandedFrame`](#brandedframe)
Defined in: [src/evm/Frame/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Frame/index.ts#L59)
Create a new EVM execution frame
#### Parameters
##### params
`FrameParams` = `{}`
Frame initialization parameters
#### Returns
[`BrandedFrame`](#brandedframe)
New Frame instance
#### Example
```typescript theme={null}
import { Frame } from 'voltaire/evm/Frame';
const frame = Frame({
bytecode: new Uint8Array([0x60, 0x01]),
gas: 100000n,
});
```
***
### Host()
> **Host**(`impl`): [`BrandedHost`](#brandedhost)
Defined in: [src/evm/Host/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/Host/index.ts#L65)
Create a Host interface implementation
#### Parameters
##### impl
`HostImpl`
Host implementation with state access methods
#### Returns
[`BrandedHost`](#brandedhost)
Host instance
#### Example
```typescript theme={null}
import { Host } from 'voltaire/evm/Host';
const host = Host({
getBalance: (addr) => balances.get(addr) ?? 0n,
setBalance: (addr, bal) => balances.set(addr, bal),
// ... other methods
});
```
## References
### Precompiles
Renames and re-exports [precompiles](../index/namespaces/precompiles.mdx)
# Arithmetic
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Arithmetic
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Arithmetic
# Arithmetic
## Functions
### add()
> **add**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x01\_ADD.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x01_ADD.js#L7)
ADD opcode (0x01) - Addition with overflow wrapping
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### addmod()
> **addmod**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x08\_ADDMOD.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x08_ADDMOD.js#L7)
ADDMOD opcode (0x08) - Addition modulo n (mod by zero returns 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### div()
> **div**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x04\_DIV.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x04_DIV.js#L7)
DIV opcode (0x04) - Integer division (division by zero returns 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### exp()
> **exp**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x0a\_EXP.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x0a_EXP.js#L7)
EXP opcode (0x0a) - Exponential operation
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mod()
> **mod**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x06\_MOD.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x06_MOD.js#L7)
MOD opcode (0x06) - Modulo operation (mod by zero returns 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mul()
> **mul**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x02\_MUL.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x02_MUL.js#L7)
MUL opcode (0x02) - Multiplication with overflow wrapping
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mulmod()
> **mulmod**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x09\_MULMOD.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x09_MULMOD.js#L7)
MULMOD opcode (0x09) - Multiplication modulo n (mod by zero returns 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### sdiv()
> **sdiv**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x05\_SDIV.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x05_SDIV.js#L7)
SDIV opcode (0x05) - Signed integer division
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### signextend()
> **signextend**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x0b\_SIGNEXTEND.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x0b_SIGNEXTEND.js#L7)
SIGNEXTEND opcode (0x0b) - Sign extension
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### smod()
> **smod**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x07\_SMOD.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x07_SMOD.js#L7)
SMOD opcode (0x07) - Signed modulo operation
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### sub()
> **sub**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/arithmetic/0x03\_SUB.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/arithmetic/0x03_SUB.js#L7)
SUB opcode (0x03) - Subtraction with underflow wrapping
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Bitwise
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Bitwise
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Bitwise
# Bitwise
## Functions
### AND()
> **AND**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x16\_AND.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x16_AND.js#L7)
AND opcode (0x16) - Bitwise AND
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### BYTE()
> **BYTE**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x1a\_BYTE.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x1a_BYTE.js#L7)
BYTE opcode (0x1a) - Extract byte from word
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### NOT()
> **NOT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x19\_NOT.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x19_NOT.js#L7)
NOT opcode (0x19) - Bitwise NOT
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### OR()
> **OR**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x17\_OR.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x17_OR.js#L7)
OR opcode (0x17) - Bitwise OR
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### SAR()
> **SAR**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x1d\_SAR.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x1d_SAR.js#L7)
SAR opcode (0x1d) - Arithmetic shift right (EIP-145, Constantinople+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### SHL()
> **SHL**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x1b\_SHL.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x1b_SHL.js#L7)
SHL opcode (0x1b) - Shift left (EIP-145, Constantinople+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### SHR()
> **SHR**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x1c\_SHR.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x1c_SHR.js#L7)
SHR opcode (0x1c) - Logical shift right (EIP-145, Constantinople+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### XOR()
> **XOR**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/bitwise/0x18\_XOR.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/bitwise/0x18_XOR.js#L7)
XOR opcode (0x18) - Bitwise XOR
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Block
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Block
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Block
# Block
## Functions
### handler\_0x40\_BLOCKHASH()
> **handler\_0x40\_BLOCKHASH**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x40\_BLOCKHASH.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x40_BLOCKHASH.js#L17)
BLOCKHASH opcode (0x40) - Get hash of recent block
Per Python reference (cancun/vm/instructions/block.py:21-64):
* Charges GAS\_BLOCK\_HASH (20 gas)
* Returns hash of one of the 256 most recent complete blocks
* Returns 0 if block number is out of range (too old or >= current)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x41\_COINBASE()
> **handler\_0x41\_COINBASE**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x41\_COINBASE.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x41_COINBASE.js#L11)
COINBASE opcode (0x41) - Get block coinbase address
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x42\_TIMESTAMP()
> **handler\_0x42\_TIMESTAMP**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x42\_TIMESTAMP.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x42_TIMESTAMP.js#L11)
TIMESTAMP opcode (0x42) - Get block timestamp
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x43\_NUMBER()
> **handler\_0x43\_NUMBER**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x43\_NUMBER.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x43_NUMBER.js#L11)
NUMBER opcode (0x43) - Get block number
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x44\_DIFFICULTY()
> **handler\_0x44\_DIFFICULTY**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x44\_DIFFICULTY.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x44_DIFFICULTY.js#L14)
DIFFICULTY/PREVRANDAO opcode (0x44) - Get block difficulty or prevrandao
Pre-Merge: returns block difficulty
Post-Merge: returns prevrandao value
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x45\_GASLIMIT()
> **handler\_0x45\_GASLIMIT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x45\_GASLIMIT.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x45_GASLIMIT.js#L11)
GASLIMIT opcode (0x45) - Get block gas limit
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x46\_CHAINID()
> **handler\_0x46\_CHAINID**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x46\_CHAINID.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x46_CHAINID.js#L11)
CHAINID opcode (0x46) - Get chain ID (EIP-1344, Istanbul+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x47\_SELFBALANCE()
> **handler\_0x47\_SELFBALANCE**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x47\_SELFBALANCE.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x47_SELFBALANCE.js#L11)
SELFBALANCE opcode (0x47) - Get balance of currently executing account (EIP-1884, Istanbul+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x48\_BASEFEE()
> **handler\_0x48\_BASEFEE**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x48\_BASEFEE.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x48_BASEFEE.js#L11)
BASEFEE opcode (0x48) - Get base fee per gas (EIP-3198, London+)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x49\_BLOBHASH()
> **handler\_0x49\_BLOBHASH**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x49\_BLOBHASH.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x49_BLOBHASH.js#L15)
BLOBHASH opcode (0x49) - Get versioned blob hash (EIP-4844, Cancun+)
Per Python reference (cancun/vm/gas.py:68):
* GAS\_BLOBHASH\_OPCODE = 3 (same as GasFastestStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x4a\_BLOBBASEFEE()
> **handler\_0x4a\_BLOBBASEFEE**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/block/0x4a\_BLOBBASEFEE.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/block/0x4a_BLOBBASEFEE.js#L15)
BLOBBASEFEE opcode (0x4a) - Get blob base fee (EIP-7516, Cancun+)
Per Python reference (cancun/vm/gas.py and BlobBaseFeeGas constant):
* GAS\_BASE = 2 (same as GasQuickStep)
* Returns blob\_base\_fee calculated from excess\_blob\_gas
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
# Comparison
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Comparison
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Comparison
# Comparison
## Functions
### EQ()
> **EQ**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x14\_EQ.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x14_EQ.js#L18)
EQ opcode (0x14) - Equality comparison
Pops two values from stack and pushes 1 if they are equal, 0 otherwise.
Comparison is bitwise equality.
Gas: 3 (GasFastestStep)
Stack: a b -> (a == b ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### GT()
> **GT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x11\_GT.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x11_GT.js#L18)
GT opcode (0x11) - Greater than comparison (unsigned)
Pops two values from stack and pushes 1 if first > second, 0 otherwise.
All comparisons are unsigned 256-bit integers.
Gas: 3 (GasFastestStep)
Stack: a b -> (a > b ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### ISZERO()
> **ISZERO**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x15\_ISZERO.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x15_ISZERO.js#L17)
ISZERO opcode (0x15) - Check if value is zero
Pops one value from stack and pushes 1 if it is zero, 0 otherwise.
Gas: 3 (GasFastestStep)
Stack: a -> (a == 0 ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### LT()
> **LT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x10\_LT.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x10_LT.js#L18)
LT opcode (0x10) - Less than comparison (unsigned)
Pops two values from stack and pushes 1 if first \< second, 0 otherwise.
All comparisons are unsigned 256-bit integers.
Gas: 3 (GasFastestStep)
Stack: a b -> (a \< b ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### SGT()
> **SGT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x13\_SGT.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x13_SGT.js#L19)
SGT opcode (0x13) - Signed greater than comparison
Pops two values from stack and pushes 1 if first > second (signed), 0 otherwise.
Values are interpreted as signed 256-bit two's complement integers.
Gas: 3 (GasFastestStep)
Stack: a b -> (signed(a) > signed(b) ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### SLT()
> **SLT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/comparison/0x12\_SLT.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/0x12_SLT.js#L19)
SLT opcode (0x12) - Signed less than comparison
Pops two values from stack and pushes 1 if first \< second (signed), 0 otherwise.
Values are interpreted as signed 256-bit two's complement integers.
Gas: 3 (GasFastestStep)
Stack: a b -> (signed(a) \< signed(b) ? 1 : 0)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Execution frame
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### toSigned256()
> **toSigned256**(`value`): `bigint`
Defined in: [src/evm/comparison/toSigned256.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/comparison/toSigned256.js#L10)
Convert unsigned 256-bit BigInt to signed 256-bit BigInt
Interprets the BigInt as a two's complement signed integer.
Values >= 2^255 are negative.
#### Parameters
##### value
`bigint`
Unsigned 256-bit value
#### Returns
`bigint`
Signed 256-bit value
# Context
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Context
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Context
# Context
## Functions
### address()
> **address**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x30\_ADDRESS.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x30_ADDRESS.js#L14)
ADDRESS opcode (0x30) - Get address of currently executing account
Stack: \[] => \[address]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### balance()
> **balance**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x31\_BALANCE.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x31_BALANCE.js#L27)
BALANCE opcode (0x31) - Get balance of an account
Stack: \[address] => \[balance]
Gas costs vary by hardfork (EIP-150, EIP-1884, EIP-2929):
* Pre-Tangerine Whistle: 20 gas
* Tangerine Whistle (EIP-150): 400 gas
* Istanbul (EIP-1884): 700 gas
* Berlin (EIP-2929): 2600 gas (cold) / 100 gas (warm)
EIP-2929 (Berlin) tracks warm/cold access for state operations:
* Cold access: First time address is accessed in transaction (2600 gas)
* Warm access: Subsequent accesses to same address (100 gas)
* Tracking maintained in frame.accessedAddresses Set
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### calldatacopy()
> **calldatacopy**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x37\_CALLDATACOPY.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x37_CALLDATACOPY.js#L42)
CALLDATACOPY opcode (0x37) - Copy input data in current environment to memory
Stack: \[destOffset, offset, length] => \[]
Gas: 3 (GasFastestStep) + memory expansion + copy cost
Copies length bytes from calldata\[offset:offset+length] to memory\[destOffset:destOffset+length].
If offset + i >= calldata.length, remaining bytes are zero-padded.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### calldataload()
> **calldataload**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x35\_CALLDATALOAD.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x35_CALLDATALOAD.js#L32)
CALLDATALOAD opcode (0x35) - Get input data of current environment
Stack: \[offset] => \[data]
Gas: 3 (GasFastestStep)
Loads 32 bytes from calldata starting at offset. If offset + i >= calldata.length,
remaining bytes are zero-padded.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### calldatasize()
> **calldatasize**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x36\_CALLDATASIZE.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x36_CALLDATASIZE.js#L13)
CALLDATASIZE opcode (0x36) - Get size of input data in current environment
Stack: \[] => \[size]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### caller()
> **caller**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x33\_CALLER.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x33_CALLER.js#L14)
CALLER opcode (0x33) - Get caller address
Stack: \[] => \[caller]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### callvalue()
> **callvalue**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x34\_CALLVALUE.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x34_CALLVALUE.js#L13)
CALLVALUE opcode (0x34) - Get deposited value by instruction/transaction responsible for this execution
Stack: \[] => \[value]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### codecopy()
> **codecopy**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x39\_CODECOPY.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x39_CODECOPY.js#L42)
CODECOPY opcode (0x39) - Copy code running in current environment to memory
Stack: \[destOffset, offset, length] => \[]
Gas: 3 (GasFastestStep) + memory expansion + copy cost
Copies length bytes from bytecode\[offset:offset+length] to memory\[destOffset:destOffset+length].
If offset + i >= bytecode.length, remaining bytes are zero-padded.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### codesize()
> **codesize**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x38\_CODESIZE.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x38_CODESIZE.js#L13)
CODESIZE opcode (0x38) - Get size of code running in current environment
Stack: \[] => \[size]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### extcodecopy()
> **extcodecopy**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3c\_EXTCODECOPY.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3c_EXTCODECOPY.js#L57)
EXTCODECOPY opcode (0x3c) - Copy an account's code to memory
Stack: \[address, destOffset, offset, size] => \[]
Gas costs include three components:
1. Access cost: hardfork-dependent (EIP-150, EIP-1884, EIP-2929)
2. Copy cost: 3 gas per 32-byte word (rounded up)
3. Memory expansion cost: Quadratic expansion cost for new memory
Gas varies by hardfork:
* Pre-Tangerine Whistle: 20 gas access
* Tangerine Whistle (EIP-150): 700 gas access
* Istanbul (EIP-1884): 700 gas access
* Berlin (EIP-2929): 2600 gas (cold) / 100 gas (warm) access
EIP-2929 (Berlin) tracks warm/cold access for state operations.
Copies size bytes from code\[offset:offset+size] to memory\[destOffset:].
Missing bytes (beyond code length) are zero-padded.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### extcodehash()
> **extcodehash**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3f\_EXTCODEHASH.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3f_EXTCODEHASH.js#L32)
EXTCODEHASH opcode (0x3f) - Get hash of an account's code
Stack: \[address] => \[hash]
Gas costs vary by hardfork (EIP-1884, EIP-2929):
* Constantinople-Istanbul: 400 gas
* Istanbul-Berlin: 700 gas (EIP-1884)
* Berlin+ (EIP-2929): 2600 gas (cold) / 100 gas (warm)
EIP-1052 (Constantinople): Introduces EXTCODEHASH opcode
* Returns keccak256 hash of account's code
* Returns 0 for non-existent accounts (instead of empty hash)
* Can be used for code verification without deploying full code
EIP-2929 (Berlin) tracks warm/cold access for state operations.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### extcodesize()
> **extcodesize**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3b\_EXTCODESIZE.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3b_EXTCODESIZE.js#L27)
EXTCODESIZE opcode (0x3b) - Get size of an account's code
Stack: \[address] => \[codeSize]
Gas costs vary by hardfork (EIP-150, EIP-1884, EIP-2929):
* Pre-Tangerine Whistle: 20 gas
* Tangerine Whistle (EIP-150): 700 gas
* Istanbul (EIP-1884): 700 gas
* Berlin (EIP-2929): 2600 gas (cold) / 100 gas (warm)
EIP-2929 (Berlin) tracks warm/cold access for state operations:
* Cold access: First time address is accessed in transaction (2600 gas)
* Warm access: Subsequent accesses to same address (100 gas)
* Tracking maintained in frame.accessedAddresses Set
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### gasprice()
> **gasprice**(`frame`, `gasPrice`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3a\_GASPRICE.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3a_GASPRICE.js#L14)
GASPRICE opcode (0x3a) - Get price of gas in current environment
Stack: \[] => \[gasPrice]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### gasPrice
`bigint`
Transaction gas price
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### origin()
> **origin**(`frame`, `origin`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x32\_ORIGIN.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x32_ORIGIN.js#L15)
ORIGIN opcode (0x32) - Get execution origination address
Stack: \[] => \[origin]
Gas: 2 (GasQuickStep)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### origin
[`AddressType`](../../primitives/Address.mdx#addresstype)
Transaction origin address
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### returndatacopy()
> **returndatacopy**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3e\_RETURNDATACOPY.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3e_RETURNDATACOPY.js#L53)
RETURNDATACOPY opcode (0x3e) - Copy output data from the previous call to memory
Stack: \[destOffset, offset, length] => \[]
Gas: 3 (GasFastestStep) + memory expansion + copy cost
EIP-211: Introduced in Byzantium hardfork
Copies length bytes from returnData\[offset:offset+length] to memory\[destOffset:destOffset+length].
Throws OutOfBounds if offset + length > returnData.length.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### returndatasize()
> **returndatasize**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/context/0x3d\_RETURNDATASIZE.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/context/0x3d_RETURNDATASIZE.js#L15)
RETURNDATASIZE opcode (0x3d) - Get size of output data from the previous call
Stack: \[] => \[size]
Gas: 2 (GasQuickStep)
EIP-211: Introduced in Byzantium hardfork
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Control
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Control
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Control
# Control
## Functions
### handler\_0x00\_STOP()
> **handler\_0x00\_STOP**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0x00\_STOP.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0x00_STOP.js#L7)
STOP opcode (0x00) - Halt execution
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x56\_JUMP()
> **handler\_0x56\_JUMP**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0x56\_JUMP.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0x56_JUMP.js#L12)
JUMP opcode (0x56) - Unconditional jump
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x57\_JUMPI()
> **handler\_0x57\_JUMPI**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0x57\_JUMPI.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0x57_JUMPI.js#L12)
JUMPI opcode (0x57) - Conditional jump
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x58\_PC()
> **handler\_0x58\_PC**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0x58\_PC.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0x58_PC.js#L11)
PC opcode (0x58) - Get program counter
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x5b\_JUMPDEST()
> **handler\_0x5b\_JUMPDEST**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0x5b\_JUMPDEST.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0x5b_JUMPDEST.js#L10)
JUMPDEST opcode (0x5b) - Jump destination marker (no-op)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0xf3\_RETURN()
> **handler\_0xf3\_RETURN**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0xf3\_RETURN.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0xf3_RETURN.js#L31)
RETURN opcode (0xf3) - Halt execution and return output data
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0xfd\_REVERT()
> **handler\_0xfd\_REVERT**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/control/0xfd\_REVERT.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/control/0xfd_REVERT.js#L34)
REVERT opcode (0xfd) - Halt execution and revert state changes
Note: REVERT was introduced in Byzantium hardfork (EIP-140).
Hardfork validation should be handled by the EVM executor.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
# Keccak
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Keccak
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Keccak
# Keccak
## Functions
### sha3()
> **sha3**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/keccak/0x20\_SHA3.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/keccak/0x20_SHA3.js#L25)
SHA3 opcode (0x20) - Compute Keccak-256 hash
Pops offset and length from stack, reads data from memory,
computes Keccak-256 hash, and pushes the 32-byte result.
Gas cost: 30 (base) + 6 \* word\_count + memory expansion
where word\_count = ceil(length / 32)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Log
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Log
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Log
# Log
## Functions
### handler\_0xa0\_LOG0()
> **handler\_0xa0\_LOG0**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/log/0xa0\_LOG0.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/log/0xa0_LOG0.js#L19)
LOG0 (0xa0) - Log with 0 topics
Stack:
in: offset, length
out: -
Gas: 375 (base) + 8 \* dataLength + memory expansion
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### handler\_0xa1\_LOG1()
> **handler\_0xa1\_LOG1**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/log/0xa1\_LOG1.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/log/0xa1_LOG1.js#L23)
LOG1 (0xa1) - Log with 1 topic
Stack:
in: offset, length, topic0
out: -
Gas: 375 (base) + 375 (topic) + 8 \* dataLength + memory expansion
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### handler\_0xa2\_LOG2()
> **handler\_0xa2\_LOG2**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/log/0xa2\_LOG2.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/log/0xa2_LOG2.js#L23)
LOG2 (0xa2) - Log with 2 topics
Stack:
in: offset, length, topic0, topic1
out: -
Gas: 375 (base) + 750 (2 topics) + 8 \* dataLength + memory expansion
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### handler\_0xa3\_LOG3()
> **handler\_0xa3\_LOG3**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/log/0xa3\_LOG3.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/log/0xa3_LOG3.js#L24)
LOG3 (0xa3) - Log with 3 topics
Stack:
in: offset, length, topic0, topic1, topic2
out: -
Gas: 375 (base) + 1125 (3 topics) + 8 \* dataLength + memory expansion
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### handler\_0xa4\_LOG4()
> **handler\_0xa4\_LOG4**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/log/0xa4\_LOG4.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/log/0xa4_LOG4.js#L24)
LOG4 (0xa4) - Log with 4 topics
Stack:
in: offset, length, topic0, topic1, topic2, topic3
out: -
Gas: 375 (base) + 1500 (4 topics) + 8 \* dataLength + memory expansion
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Memory
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Memory
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Memory
# Memory
## Functions
### mcopy()
> **mcopy**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/memory/0x5e\_MCOPY.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/memory/0x5e_MCOPY.js#L41)
MCOPY opcode (0x5e) - Copy memory (EIP-5656, Cancun+)
Pops dest, src, len from stack. Copies len bytes from src to dest.
Handles overlapping regions correctly using temporary buffer.
Gas cost: GasFastestStep (3) + memory expansion cost + copy cost (3 gas per word)
Note: This opcode was introduced in the Cancun hardfork (EIP-5656).
Implementation assumes hardfork check is done externally.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mload()
> **mload**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/memory/0x51\_MLOAD.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/memory/0x51_MLOAD.js#L18)
MLOAD opcode (0x51) - Load word from memory
Pops offset from stack, reads 32 bytes from memory starting at offset,
and pushes the result as a 256-bit value onto the stack.
Gas cost: GasFastestStep (3) + memory expansion cost
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mstore()
> **mstore**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/memory/0x52\_MSTORE.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/memory/0x52_MSTORE.js#L17)
MSTORE opcode (0x52) - Save word to memory
Pops offset and value from stack, writes 32 bytes to memory starting at offset.
Value is stored in big-endian format.
Gas cost: GasFastestStep (3) + memory expansion cost
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### mstore8()
> **mstore8**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/memory/0x53\_MSTORE8.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/memory/0x53_MSTORE8.js#L17)
MSTORE8 opcode (0x53) - Save byte to memory
Pops offset and value from stack, writes the least significant byte
of value to memory at offset.
Gas cost: GasFastestStep (3) + memory expansion cost
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Stack
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Stack
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Stack
# Stack
## Functions
### handler\_0x50\_POP()
> **handler\_0x50\_POP**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x50\_POP.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x50_POP.js#L11)
POP opcode (0x50) - Remove top item from stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x5f\_PUSH0()
> **handler\_0x5f\_PUSH0**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x5f\_PUSH0.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x5f_PUSH0.js#L12)
PUSH0 opcode (0x5f) - Push 0 onto stack
EIP-3855: Introduced in Shanghai hardfork
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x60\_PUSH1()
> **handler\_0x60\_PUSH1**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x60\_PUSH1.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x60_PUSH1.js#L33)
PUSH1 opcode (0x60) - Push 1 byte onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x61\_PUSH2()
> **handler\_0x61\_PUSH2**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x61\_PUSH2.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x61_PUSH2.js#L33)
PUSH2 opcode (0x61) - Push 2 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x62\_PUSH3()
> **handler\_0x62\_PUSH3**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x62\_PUSH3.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x62_PUSH3.js#L33)
PUSH3 opcode (0x62) - Push 3 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x63\_PUSH4()
> **handler\_0x63\_PUSH4**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x63\_PUSH4.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x63_PUSH4.js#L33)
PUSH4 opcode (0x63) - Push 4 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x64\_PUSH5()
> **handler\_0x64\_PUSH5**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x64\_PUSH5.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x64_PUSH5.js#L33)
PUSH5 opcode (0x64) - Push 5 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x65\_PUSH6()
> **handler\_0x65\_PUSH6**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x65\_PUSH6.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x65_PUSH6.js#L33)
PUSH6 opcode (0x65) - Push 6 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x66\_PUSH7()
> **handler\_0x66\_PUSH7**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x66\_PUSH7.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x66_PUSH7.js#L33)
PUSH7 opcode (0x66) - Push 7 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x67\_PUSH8()
> **handler\_0x67\_PUSH8**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x67\_PUSH8.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x67_PUSH8.js#L33)
PUSH8 opcode (0x67) - Push 8 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x68\_PUSH9()
> **handler\_0x68\_PUSH9**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x68\_PUSH9.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x68_PUSH9.js#L33)
PUSH9 opcode (0x68) - Push 9 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x69\_PUSH10()
> **handler\_0x69\_PUSH10**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x69\_PUSH10.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x69_PUSH10.js#L33)
PUSH10 opcode (0x69) - Push 10 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6A\_PUSH11()
> **handler\_0x6A\_PUSH11**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6A\_PUSH11.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6A_PUSH11.js#L33)
PUSH11 opcode (0x6A) - Push 11 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6B\_PUSH12()
> **handler\_0x6B\_PUSH12**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6B\_PUSH12.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6B_PUSH12.js#L33)
PUSH12 opcode (0x6B) - Push 12 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6C\_PUSH13()
> **handler\_0x6C\_PUSH13**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6C\_PUSH13.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6C_PUSH13.js#L33)
PUSH13 opcode (0x6C) - Push 13 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6D\_PUSH14()
> **handler\_0x6D\_PUSH14**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6D\_PUSH14.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6D_PUSH14.js#L33)
PUSH14 opcode (0x6D) - Push 14 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6E\_PUSH15()
> **handler\_0x6E\_PUSH15**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6E\_PUSH15.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6E_PUSH15.js#L33)
PUSH15 opcode (0x6E) - Push 15 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x6F\_PUSH16()
> **handler\_0x6F\_PUSH16**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x6F\_PUSH16.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x6F_PUSH16.js#L33)
PUSH16 opcode (0x6F) - Push 16 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x70\_PUSH17()
> **handler\_0x70\_PUSH17**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x70\_PUSH17.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x70_PUSH17.js#L33)
PUSH17 opcode (0x70) - Push 17 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x71\_PUSH18()
> **handler\_0x71\_PUSH18**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x71\_PUSH18.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x71_PUSH18.js#L33)
PUSH18 opcode (0x71) - Push 18 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x72\_PUSH19()
> **handler\_0x72\_PUSH19**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x72\_PUSH19.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x72_PUSH19.js#L33)
PUSH19 opcode (0x72) - Push 19 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x73\_PUSH20()
> **handler\_0x73\_PUSH20**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x73\_PUSH20.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x73_PUSH20.js#L33)
PUSH20 opcode (0x73) - Push 20 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x74\_PUSH21()
> **handler\_0x74\_PUSH21**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x74\_PUSH21.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x74_PUSH21.js#L33)
PUSH21 opcode (0x74) - Push 21 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x75\_PUSH22()
> **handler\_0x75\_PUSH22**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x75\_PUSH22.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x75_PUSH22.js#L33)
PUSH22 opcode (0x75) - Push 22 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x76\_PUSH23()
> **handler\_0x76\_PUSH23**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x76\_PUSH23.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x76_PUSH23.js#L33)
PUSH23 opcode (0x76) - Push 23 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x77\_PUSH24()
> **handler\_0x77\_PUSH24**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x77\_PUSH24.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x77_PUSH24.js#L33)
PUSH24 opcode (0x77) - Push 24 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x78\_PUSH25()
> **handler\_0x78\_PUSH25**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x78\_PUSH25.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x78_PUSH25.js#L33)
PUSH25 opcode (0x78) - Push 25 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x79\_PUSH26()
> **handler\_0x79\_PUSH26**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x79\_PUSH26.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x79_PUSH26.js#L33)
PUSH26 opcode (0x79) - Push 26 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7A\_PUSH27()
> **handler\_0x7A\_PUSH27**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7A\_PUSH27.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7A_PUSH27.js#L33)
PUSH27 opcode (0x7A) - Push 27 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7B\_PUSH28()
> **handler\_0x7B\_PUSH28**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7B\_PUSH28.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7B_PUSH28.js#L33)
PUSH28 opcode (0x7B) - Push 28 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7C\_PUSH29()
> **handler\_0x7C\_PUSH29**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7C\_PUSH29.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7C_PUSH29.js#L33)
PUSH29 opcode (0x7C) - Push 29 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7D\_PUSH30()
> **handler\_0x7D\_PUSH30**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7D\_PUSH30.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7D_PUSH30.js#L33)
PUSH30 opcode (0x7D) - Push 30 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7E\_PUSH31()
> **handler\_0x7E\_PUSH31**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7E\_PUSH31.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7E_PUSH31.js#L33)
PUSH31 opcode (0x7E) - Push 31 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x7F\_PUSH32()
> **handler\_0x7F\_PUSH32**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x7F\_PUSH32.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x7F_PUSH32.js#L33)
PUSH32 opcode (0x7F) - Push 32 bytes onto stack
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x80\_DUP1()
> **handler\_0x80\_DUP1**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x80\_DUP1.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x80_DUP1.js#L11)
DUP1 opcode (0x80) - Duplicate 1st stack item (top)
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x81\_DUP2()
> **handler\_0x81\_DUP2**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x81\_DUP2.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x81_DUP2.js#L11)
DUP2 opcode (0x81) - Duplicate 2th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x82\_DUP3()
> **handler\_0x82\_DUP3**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x82\_DUP3.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x82_DUP3.js#L11)
DUP3 opcode (0x82) - Duplicate 3th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x83\_DUP4()
> **handler\_0x83\_DUP4**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x83\_DUP4.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x83_DUP4.js#L11)
DUP4 opcode (0x83) - Duplicate 4th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x84\_DUP5()
> **handler\_0x84\_DUP5**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x84\_DUP5.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x84_DUP5.js#L11)
DUP5 opcode (0x84) - Duplicate 5th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x85\_DUP6()
> **handler\_0x85\_DUP6**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x85\_DUP6.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x85_DUP6.js#L11)
DUP6 opcode (0x85) - Duplicate 6th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x86\_DUP7()
> **handler\_0x86\_DUP7**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x86\_DUP7.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x86_DUP7.js#L11)
DUP7 opcode (0x86) - Duplicate 7th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x87\_DUP8()
> **handler\_0x87\_DUP8**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x87\_DUP8.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x87_DUP8.js#L11)
DUP8 opcode (0x87) - Duplicate 8th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x88\_DUP9()
> **handler\_0x88\_DUP9**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x88\_DUP9.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x88_DUP9.js#L11)
DUP9 opcode (0x88) - Duplicate 9th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x89\_DUP10()
> **handler\_0x89\_DUP10**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x89\_DUP10.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x89_DUP10.js#L11)
DUP10 opcode (0x89) - Duplicate 10th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8A\_DUP11()
> **handler\_0x8A\_DUP11**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8A\_DUP11.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8A_DUP11.js#L11)
DUP11 opcode (0x8A) - Duplicate 11th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8B\_DUP12()
> **handler\_0x8B\_DUP12**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8B\_DUP12.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8B_DUP12.js#L11)
DUP12 opcode (0x8B) - Duplicate 12th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8C\_DUP13()
> **handler\_0x8C\_DUP13**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8C\_DUP13.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8C_DUP13.js#L11)
DUP13 opcode (0x8C) - Duplicate 13th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8D\_DUP14()
> **handler\_0x8D\_DUP14**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8D\_DUP14.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8D_DUP14.js#L11)
DUP14 opcode (0x8D) - Duplicate 14th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8E\_DUP15()
> **handler\_0x8E\_DUP15**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8E\_DUP15.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8E_DUP15.js#L11)
DUP15 opcode (0x8E) - Duplicate 15th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x8F\_DUP16()
> **handler\_0x8F\_DUP16**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x8F\_DUP16.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x8F_DUP16.js#L11)
DUP16 opcode (0x8F) - Duplicate 16th stack item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x90\_SWAP1()
> **handler\_0x90\_SWAP1**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x90\_SWAP1.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x90_SWAP1.js#L10)
SWAP1 opcode (0x90) - Swap top with 2nd item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x91\_SWAP2()
> **handler\_0x91\_SWAP2**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x91\_SWAP2.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x91_SWAP2.js#L10)
SWAP2 opcode (0x91) - Swap top with (2+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x92\_SWAP3()
> **handler\_0x92\_SWAP3**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x92\_SWAP3.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x92_SWAP3.js#L10)
SWAP3 opcode (0x92) - Swap top with (3+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x93\_SWAP4()
> **handler\_0x93\_SWAP4**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x93\_SWAP4.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x93_SWAP4.js#L10)
SWAP4 opcode (0x93) - Swap top with (4+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x94\_SWAP5()
> **handler\_0x94\_SWAP5**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x94\_SWAP5.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x94_SWAP5.js#L10)
SWAP5 opcode (0x94) - Swap top with (5+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x95\_SWAP6()
> **handler\_0x95\_SWAP6**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x95\_SWAP6.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x95_SWAP6.js#L10)
SWAP6 opcode (0x95) - Swap top with (6+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x96\_SWAP7()
> **handler\_0x96\_SWAP7**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x96\_SWAP7.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x96_SWAP7.js#L10)
SWAP7 opcode (0x96) - Swap top with (7+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x97\_SWAP8()
> **handler\_0x97\_SWAP8**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x97\_SWAP8.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x97_SWAP8.js#L10)
SWAP8 opcode (0x97) - Swap top with (8+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x98\_SWAP9()
> **handler\_0x98\_SWAP9**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x98\_SWAP9.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x98_SWAP9.js#L10)
SWAP9 opcode (0x98) - Swap top with (9+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x99\_SWAP10()
> **handler\_0x99\_SWAP10**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x99\_SWAP10.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x99_SWAP10.js#L10)
SWAP10 opcode (0x99) - Swap top with (10+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9A\_SWAP11()
> **handler\_0x9A\_SWAP11**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9A\_SWAP11.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9A_SWAP11.js#L10)
SWAP11 opcode (0x9A) - Swap top with (11+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9B\_SWAP12()
> **handler\_0x9B\_SWAP12**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9B\_SWAP12.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9B_SWAP12.js#L10)
SWAP12 opcode (0x9B) - Swap top with (12+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9C\_SWAP13()
> **handler\_0x9C\_SWAP13**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9C\_SWAP13.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9C_SWAP13.js#L10)
SWAP13 opcode (0x9C) - Swap top with (13+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9D\_SWAP14()
> **handler\_0x9D\_SWAP14**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9D\_SWAP14.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9D_SWAP14.js#L10)
SWAP14 opcode (0x9D) - Swap top with (14+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9E\_SWAP15()
> **handler\_0x9E\_SWAP15**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9E\_SWAP15.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9E_SWAP15.js#L10)
SWAP15 opcode (0x9E) - Swap top with (15+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
***
### handler\_0x9F\_SWAP16()
> **handler\_0x9F\_SWAP16**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/stack/handlers/0x9F\_SWAP16.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/stack/handlers/0x9F_SWAP16.js#L10)
SWAP16 opcode (0x9F) - Swap top with (16+1)th item
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if operation fails
# Storage
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/Storage
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / Storage
# Storage
## Functions
### sload()
> **sload**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/storage/handlers/0x54\_SLOAD.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/storage/handlers/0x54_SLOAD.js#L26)
SLOAD (0x54) - Load word from storage
Stack:
in: key
out: value
Gas: 100 (warm) or 2100 (cold) - EIP-2929
EIP-2929 (Berlin+): Warm/cold storage access tracking
* First access to slot: 2100 gas (cold)
* Subsequent accesses: 100 gas (warm)
* Slot is marked warm for rest of transaction
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### sstore()
> **sstore**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/storage/handlers/0x55\_SSTORE.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/storage/handlers/0x55_SSTORE.js#L44)
SSTORE (0x55) - Save word to storage
Stack:
in: key, value
out: -
Gas: Complex - EIP-2200 (Istanbul+) / EIP-2929 (Berlin+) / EIP-3529 (London+)
EIP-2200 (Istanbul+):
* Sentry: Requires >= 2300 gas remaining
* Cost varies based on current vs original value
* Refunds for clearing and restoring values
EIP-2929 (Berlin+):
* Cold/warm storage slot tracking
* Cold slot access adds 2000 gas (100 -> 2100 for first access)
EIP-3529 (London+):
* Reduced refunds: 4800 instead of 15000 for clearing
* Max refund capped at 20% of tx gas
Pre-Istanbul:
* Zero to non-zero: 20000 gas
* Otherwise: 5000 gas
* Refund 15000 when clearing
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### tload()
> **tload**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/storage/handlers/0x5c\_TLOAD.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/storage/handlers/0x5c_TLOAD.js#L21)
TLOAD (0x5c) - Load word from transient storage
Stack:
in: key
out: value
Gas: 100
EIP-1153: Transient storage opcodes (Cancun hardfork)
* Transaction-scoped storage, cleared at end of transaction
* No refunds or complex gas metering
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### tstore()
> **tstore**(`frame`, `host`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/storage/handlers/0x5d\_TSTORE.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/storage/handlers/0x5d_TSTORE.js#L22)
TSTORE (0x5d) - Save word to transient storage
Stack:
in: key, value
out: -
Gas: 100
EIP-1153: Transient storage opcodes (Cancun hardfork)
* Transaction-scoped storage, cleared at end of transaction
* No refunds or complex gas metering
* Cannot be called in static context
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host
[`BrandedHost`](../index.mdx#brandedhost)
Host interface
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# System
Source: https://voltaire.tevm.sh/generated-api/evm/namespaces/System
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [evm](../index.mdx) / System
# System
## Functions
### call()
> **call**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xf1\_CALL.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xf1_CALL.js#L32)
CALL opcode (0xf1) - Message call into an account
Stack: \[gas, address, value, inOffset, inLength, outOffset, outLength] => \[success]
Gas: Complex (base + memory + cold access + value transfer + new account)
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `call` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.call is not provided, returns NotImplemented error.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### callcode()
> **callcode**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xf2\_CALLCODE.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xf2_CALLCODE.js#L34)
CALLCODE opcode (0xf2) - Message call into this account with another account's code
Stack: \[gas, address, value, inOffset, inLength, outOffset, outLength] => \[success]
Gas: Similar to CALL but executes code in current context
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `call` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.call is not provided, returns NotImplemented error.
Note: CALLCODE is deprecated in favor of DELEGATECALL (EIP-7).
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### create()
> **create**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xf0\_CREATE.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xf0_CREATE.js#L21)
CREATE opcode (0xf0) - Create a new contract
Stack: \[value, offset, length] => \[address]
Gas: 32000 + memory expansion + init code hash cost
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `create` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.create is not provided, returns NotImplemented error.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### create2()
> **create2**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xf5\_CREATE2.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xf5_CREATE2.js#L23)
CREATE2 opcode (0xf5) - Create a new contract with deterministic address
Stack: \[value, offset, length, salt] => \[address]
Gas: 32000 + memory expansion + init code hash cost + keccak256 cost
Address: keccak256(0xff ++ sender ++ salt ++ keccak256(initCode))
Note: Introduced in EIP-1014 (Constantinople)
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `create` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.create is not provided, returns NotImplemented error.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### delegatecall()
> **delegatecall**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xf4\_DELEGATECALL.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xf4_DELEGATECALL.js#L22)
DELEGATECALL opcode (0xf4) - Message call with another account's code, preserving msg.sender and msg.value
Stack: \[gas, address, inOffset, inLength, outOffset, outLength] => \[success]
Gas: Similar to CALL but no value parameter (preserves current msg.value)
Note: Introduced in EIP-7 (Homestead)
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `call` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.call is not provided, returns NotImplemented error.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### selfdestruct()
> **selfdestruct**(`frame`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xff\_SELFDESTRUCT.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xff_SELFDESTRUCT.js#L14)
SELFDESTRUCT opcode (0xff) - Halt execution and register account for deletion
Stack: \[beneficiary] => \[]
Gas: 5000 + cold account access (EIP-2929) + new account (if needed)
Note: Behavior changed significantly in EIP-6780 (Cancun)
Pre-Cancun: Marks account for deletion, transfers balance to beneficiary
Post-Cancun: Only deletes if account was created in same transaction, always transfers balance
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
***
### staticcall()
> **staticcall**(`frame`, `host?`): [`EvmError`](../index.mdx#evmerror) | `null`
Defined in: [src/evm/system/0xfa\_STATICCALL.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/system/0xfa_STATICCALL.js#L32)
STATICCALL opcode (0xfa) - Static message call (no state modifications allowed)
Stack: \[gas, address, inOffset, inLength, outOffset, outLength] => \[success]
Gas: Similar to CALL but no value parameter
Note: Introduced in EIP-214 (Byzantium)
Note: Sets isStatic flag, preventing any state modifications in called context
## Architecture Note
This is a low-level opcode handler. For full nested execution, the host must
provide a `call` method. Full EVM implementations are in:
* **guillotine**: Production EVM with async state, tracing, full EIP support
* **guillotine-mini**: Lightweight synchronous EVM for testing
When host.call is not provided, returns NotImplemented error.
#### Parameters
##### frame
[`BrandedFrame`](../index.mdx#brandedframe)
Frame instance
##### host?
[`BrandedHost`](../index.mdx#brandedhost)
Host interface (optional)
#### Returns
[`EvmError`](../index.mdx#evmerror) | `null`
Error if any
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index
Auto-generated TypeScript API documentation from source code
**@tevm/voltaire**
***
# @tevm/voltaire
## Modules
* [crypto](crypto.mdx)
* [crypto/AesGcm](crypto/AesGcm.mdx)
* [crypto/Bip39](crypto/Bip39.mdx)
* [crypto/Blake2](crypto/Blake2.mdx)
* [crypto/Bls12381](crypto/Bls12381/index.mdx)
* [crypto/ChaCha20Poly1305](crypto/ChaCha20Poly1305.mdx)
* [crypto/Ed25519](crypto/Ed25519.mdx)
* [crypto/EIP712](crypto/EIP712.mdx)
* [crypto/Keccak256](crypto/Keccak256.mdx)
* [crypto/Keystore](crypto/Keystore.mdx)
* [crypto/KZG](crypto/KZG.mdx)
* [crypto/ModExp](crypto/ModExp.mdx)
* [crypto/P256](crypto/P256.mdx)
* [crypto/Ripemd160](crypto/Ripemd160.mdx)
* [crypto/Secp256k1](crypto/Secp256k1.mdx)
* [crypto/SHA256](crypto/SHA256.mdx)
* [crypto/X25519](crypto/X25519.mdx)
* [evm](evm/index.mdx)
* [GasCosts](GasCosts.mdx)
* [HDWallet](HDWallet.mdx)
* [index](index/index.mdx)
* [native](native.mdx)
* [primitives](primitives.mdx)
* [primitives/Abi](primitives/Abi/index.mdx)
* [primitives/AccessList](primitives/AccessList.mdx)
* [primitives/AccountState](primitives/AccountState.mdx)
* [primitives/Address](primitives/Address.mdx)
* [primitives/Authorization](primitives/Authorization.mdx)
* [primitives/Base64](primitives/Base64.mdx)
* [primitives/BaseFeePerGas](primitives/BaseFeePerGas.mdx)
* [primitives/BeaconBlockRoot](primitives/BeaconBlockRoot.mdx)
* [primitives/BinaryTree](primitives/BinaryTree.mdx)
* [primitives/Blob](primitives/Blob.mdx)
* [primitives/Block](primitives/Block.mdx)
* [primitives/BlockBody](primitives/BlockBody.mdx)
* [primitives/BlockFilter](primitives/BlockFilter.mdx)
* [primitives/BlockHash](primitives/BlockHash.mdx)
* [primitives/BlockHeader](primitives/BlockHeader.mdx)
* [primitives/BlockNumber](primitives/BlockNumber.mdx)
* [primitives/BloomFilter](primitives/BloomFilter.mdx)
* [primitives/BuilderBid](primitives/BuilderBid.mdx)
* [primitives/Bundle](primitives/Bundle.mdx)
* [primitives/BundleHash](primitives/BundleHash.mdx)
* [primitives/Bundler](primitives/Bundler.mdx)
* [primitives/Bytecode](primitives/Bytecode.mdx)
* [primitives/Bytes](primitives/Bytes.mdx)
* [primitives/Bytes32](primitives/Bytes32.mdx)
* [primitives/CallData](primitives/CallData.mdx)
* [primitives/CallTrace](primitives/CallTrace.mdx)
* [primitives/ChainHead](primitives/ChainHead.mdx)
* [primitives/ChainId](primitives/ChainId.mdx)
* [primitives/CompilerVersion](primitives/CompilerVersion.mdx)
* [primitives/ContractCode](primitives/ContractCode.mdx)
* [primitives/ContractResult](primitives/ContractResult.mdx)
* [primitives/ContractSignature](primitives/ContractSignature.mdx)
* [primitives/DecodedData](primitives/DecodedData.mdx)
* [primitives/Domain](primitives/Domain.mdx)
* [primitives/DomainSeparator](primitives/DomainSeparator.mdx)
* [primitives/EffectiveGasPrice](primitives/EffectiveGasPrice.mdx)
* [primitives/EncodedData](primitives/EncodedData.mdx)
* [primitives/Ens](primitives/Ens.mdx)
* [primitives/EntryPoint](primitives/EntryPoint.mdx)
* [primitives/Epoch](primitives/Epoch.mdx)
* [primitives/ErrorSignature](primitives/ErrorSignature.mdx)
* [primitives/EventLog](primitives/EventLog.mdx)
* [primitives/EventSignature](primitives/EventSignature.mdx)
* [primitives/FeeOracle](primitives/FeeOracle.mdx)
* [primitives/FilterId](primitives/FilterId.mdx)
* [primitives/ForkId](primitives/ForkId.mdx)
* [primitives/FunctionSignature](primitives/FunctionSignature.mdx)
* [primitives/Gas](primitives/Gas.mdx)
* [primitives/GasConstants](primitives/GasConstants/index.mdx)
* [primitives/GasEstimate](primitives/GasEstimate.mdx)
* [primitives/GasRefund](primitives/GasRefund.mdx)
* [primitives/GasUsed](primitives/GasUsed.mdx)
* [primitives/Hardfork](primitives/Hardfork.mdx)
* [primitives/Hash](primitives/Hash.mdx)
* [primitives/Hex](primitives/Hex.mdx)
* [primitives/InitCode](primitives/InitCode.mdx)
* [primitives/Int128](primitives/Int128.mdx)
* [primitives/Int16](primitives/Int16.mdx)
* [primitives/Int256](primitives/Int256.mdx)
* [primitives/Int32](primitives/Int32.mdx)
* [primitives/Int64](primitives/Int64.mdx)
* [primitives/Int8](primitives/Int8.mdx)
* [primitives/License](primitives/License.mdx)
* [primitives/LogFilter](primitives/LogFilter.mdx)
* [primitives/LogIndex](primitives/LogIndex.mdx)
* [primitives/MaxFeePerGas](primitives/MaxFeePerGas.mdx)
* [primitives/MaxPriorityFeePerGas](primitives/MaxPriorityFeePerGas.mdx)
* [primitives/MemoryDump](primitives/MemoryDump.mdx)
* [primitives/Metadata](primitives/Metadata.mdx)
* [primitives/MultiTokenId](primitives/MultiTokenId.mdx)
* [primitives/NetworkId](primitives/NetworkId.mdx)
* [primitives/NodeInfo](primitives/NodeInfo.mdx)
* [primitives/Nonce](primitives/Nonce.mdx)
* [primitives/Opcode](primitives/Opcode.mdx)
* [primitives/OpStep](primitives/OpStep.mdx)
* [primitives/PackedUserOperation](primitives/PackedUserOperation.mdx)
* [primitives/Paymaster](primitives/Paymaster.mdx)
* [primitives/PeerId](primitives/PeerId.mdx)
* [primitives/PeerInfo](primitives/PeerInfo.mdx)
* [primitives/PendingTransactionFilter](primitives/PendingTransactionFilter.mdx)
* [primitives/Permit](primitives/Permit/index.mdx)
* [primitives/PrivateKey](primitives/PrivateKey.mdx)
* [primitives/Proof](primitives/Proof.mdx)
* [primitives/ProtocolVersion](primitives/ProtocolVersion.mdx)
* [primitives/PublicKey](primitives/PublicKey.mdx)
* [primitives/Receipt](primitives/Receipt.mdx)
* [primitives/RelayData](primitives/RelayData.mdx)
* [primitives/ReturnData](primitives/ReturnData.mdx)
* [primitives/RevertReason](primitives/RevertReason.mdx)
* [primitives/Rlp](primitives/Rlp.mdx)
* [primitives/RuntimeCode](primitives/RuntimeCode.mdx)
* [primitives/Selector](primitives/Selector.mdx)
* [primitives/Signature](primitives/Signature.mdx)
* [primitives/SignedData](primitives/SignedData.mdx)
* [primitives/Siwe](primitives/Siwe.mdx)
* [primitives/Slot](primitives/Slot.mdx)
* [primitives/SourceMap](primitives/SourceMap.mdx)
* [primitives/State](primitives/State.mdx)
* [primitives/StateDiff](primitives/StateDiff.mdx)
* [primitives/StateProof](primitives/StateProof.mdx)
* [primitives/StateRoot](primitives/StateRoot.mdx)
* [primitives/StealthAddress](primitives/StealthAddress.mdx)
* [primitives/StorageDiff](primitives/StorageDiff.mdx)
* [primitives/StorageProof](primitives/StorageProof.mdx)
* [primitives/StorageValue](primitives/StorageValue.mdx)
* [primitives/StructLog](primitives/StructLog.mdx)
* [primitives/SyncStatus](primitives/SyncStatus.mdx)
* [primitives/TokenBalance](primitives/TokenBalance.mdx)
* [primitives/TokenId](primitives/TokenId.mdx)
* [primitives/TopicFilter](primitives/TopicFilter.mdx)
* [primitives/TraceConfig](primitives/TraceConfig.mdx)
* [primitives/TraceResult](primitives/TraceResult.mdx)
* [primitives/Transaction](primitives/Transaction/index.mdx)
* [primitives/TransactionHash](primitives/TransactionHash.mdx)
* [primitives/TransactionIndex](primitives/TransactionIndex.mdx)
* [primitives/TransactionStatus](primitives/TransactionStatus.mdx)
* [primitives/TypedData](primitives/TypedData.mdx)
* [primitives/Uint](primitives/Uint.mdx)
* [primitives/Uint128](primitives/Uint128.mdx)
* [primitives/Uint16](primitives/Uint16.mdx)
* [primitives/Uint32](primitives/Uint32.mdx)
* [primitives/Uint64](primitives/Uint64.mdx)
* [primitives/Uint8](primitives/Uint8.mdx)
* [primitives/Uncle](primitives/Uncle.mdx)
* [primitives/UserOperation](primitives/UserOperation.mdx)
* [primitives/ValidatorIndex](primitives/ValidatorIndex.mdx)
* [primitives/Withdrawal](primitives/Withdrawal.mdx)
* [primitives/WithdrawalIndex](primitives/WithdrawalIndex.mdx)
* [provider](provider/index.mdx)
* [Proxy](Proxy.mdx)
* [Ssz](Ssz.mdx)
* [Storage](Storage.mdx)
* [TransactionUrl](TransactionUrl.mdx)
* [utils](utils.mdx)
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / index
# index
## Namespaces
* [BrandedAddress](namespaces/BrandedAddress/index.mdx)
* [BrandedBase64](namespaces/BrandedBase64.mdx)
* [BrandedBytes](namespaces/BrandedBytes.mdx)
* [BrandedBytes1](namespaces/BrandedBytes1.mdx)
* [BrandedBytes16](namespaces/BrandedBytes16.mdx)
* [BrandedBytes2](namespaces/BrandedBytes2.mdx)
* [BrandedBytes3](namespaces/BrandedBytes3.mdx)
* [BrandedBytes32](namespaces/BrandedBytes32.mdx)
* [BrandedBytes4](namespaces/BrandedBytes4.mdx)
* [BrandedBytes5](namespaces/BrandedBytes5.mdx)
* [BrandedBytes6](namespaces/BrandedBytes6.mdx)
* [BrandedBytes64](namespaces/BrandedBytes64.mdx)
* [BrandedBytes7](namespaces/BrandedBytes7.mdx)
* [BrandedBytes8](namespaces/BrandedBytes8.mdx)
* [BrandedChain](namespaces/BrandedChain.mdx)
* [BrandedEther](namespaces/BrandedEther.mdx)
* [BrandedFeeMarket](namespaces/BrandedFeeMarket.mdx)
* [BrandedGwei](namespaces/BrandedGwei.mdx)
* [BrandedHex](namespaces/BrandedHex.mdx)
* [BrandedOpcode](namespaces/BrandedOpcode.mdx)
* [BrandedRlp](namespaces/BrandedRlp.mdx)
* [BrandedWei](namespaces/BrandedWei.mdx)
* [ERC1155](namespaces/ERC1155.mdx)
* [ERC165](namespaces/ERC165.mdx)
* [ERC20](namespaces/ERC20.mdx)
* [ERC721](namespaces/ERC721.mdx)
* [FeeMarket](namespaces/FeeMarket.mdx)
* [HashType](namespaces/HashType.mdx)
* [precompiles](namespaces/precompiles.mdx)
* [wasm](namespaces/wasm/index.mdx)
## Classes
### `abstract` AbstractError
Defined in: [src/primitives/errors/AbstractError.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L34)
Abstract base error for all Voltaire errors
Provides standardized error handling with:
* Error cause chain for debugging
* Error codes for programmatic handling
* Context object for additional metadata
* Documentation links for user guidance
#### Example
```typescript theme={null}
class InvalidAddressError extends AbstractError {
constructor(address: string, options?: ErrorOptions) {
super(
`Invalid address format: ${address}`,
{
...options,
code: options?.code || 'INVALID_ADDRESS',
docsPath: '/primitives/address/from-hex#error-handling'
}
)
this.name = 'InvalidAddressError'
}
}
// Usage with cause chain
try {
parseHex(input)
} catch (e) {
throw new InvalidAddressError(input, { cause: e })
}
```
#### Extends
* `Error`
#### Extended by
* [`PrimitiveError`](#primitiveerror)
#### Constructors
##### Constructor
> **new AbstractError**(`message`, `options?`): [`AbstractError`](#abstracterror)
Defined in: [src/primitives/errors/AbstractError.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L58)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`AbstractError`](#abstracterror)
###### Overrides
`Error.constructor`
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Overrides
`Error.cause`
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
***
### CryptoError
Defined in: [src/primitives/errors/CryptoError.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L16)
Base crypto error
#### Example
```typescript theme={null}
throw new CryptoError('Cryptographic operation failed', {
code: 'CRYPTO_ERROR',
context: { operation: 'sign' },
docsPath: '/crypto/secp256k1/sign#error-handling',
cause: originalError
})
```
#### Extends
* [`PrimitiveError`](#primitiveerror)
#### Extended by
* [`AesGcmError`](../crypto/AesGcm.mdx#aesgcmerror)
* [`Bip39Error`](../crypto/Bip39.mdx#bip39error)
* [`ChaCha20Poly1305Error`](../crypto/ChaCha20Poly1305.mdx#chacha20poly1305error)
* [`Eip712Error`](../crypto/EIP712.mdx#eip712error)
* [`Ed25519Error`](../crypto/Ed25519.mdx#ed25519error)
* [`KzgError`](../crypto/KZG.mdx#kzgerror)
* [`P256Error`](../crypto/P256.mdx#p256error)
* [`X25519Error`](../crypto/X25519.mdx#x25519error)
* [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
* [`InvalidSignatureError`](#invalidsignatureerror)
#### Constructors
##### Constructor
> **new CryptoError**(`message`, `options?`): [`CryptoError`](#cryptoerror)
Defined in: [src/primitives/errors/CryptoError.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L17)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`CryptoError`](#cryptoerror)
###### Overrides
[`PrimitiveError`](#primitiveerror).[`constructor`](#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`cause`](#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`code`](#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`context`](#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`docsPath`](#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`getErrorChain`](#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`toJSON`](#tojson-32)
***
### DecodingError
Defined in: [src/primitives/errors/SerializationError.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L66)
Decoding error (e.g., RLP decoding failure)
#### Throws
#### Extends
* [`SerializationError`](#serializationerror)
#### Extended by
* [`SiweParseError`](../primitives/Siwe.mdx#siweparseerror)
#### Constructors
##### Constructor
> **new DecodingError**(`message`, `options?`): [`DecodingError`](#decodingerror)
Defined in: [src/primitives/errors/SerializationError.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L67)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`DecodingError`](#decodingerror)
###### Overrides
[`SerializationError`](#serializationerror).[`constructor`](#constructor-17)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`SerializationError`](#serializationerror).[`cause`](#cause-17)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`SerializationError`](#serializationerror).[`code`](#code-17)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`SerializationError`](#serializationerror).[`context`](#context-17)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`SerializationError`](#serializationerror).[`docsPath`](#docspath-17)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`SerializationError`](#serializationerror).[`getErrorChain`](#geterrorchain-34)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`SerializationError`](#serializationerror).[`toJSON`](#tojson-34)
***
### EncodingError
Defined in: [src/primitives/errors/SerializationError.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L41)
Encoding error (e.g., RLP encoding failure)
#### Throws
#### Extends
* [`SerializationError`](#serializationerror)
#### Constructors
##### Constructor
> **new EncodingError**(`message`, `options?`): [`EncodingError`](#encodingerror)
Defined in: [src/primitives/errors/SerializationError.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L42)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`EncodingError`](#encodingerror)
###### Overrides
[`SerializationError`](#serializationerror).[`constructor`](#constructor-17)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`SerializationError`](#serializationerror).[`cause`](#cause-17)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`SerializationError`](#serializationerror).[`code`](#code-17)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`SerializationError`](#serializationerror).[`context`](#context-17)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`SerializationError`](#serializationerror).[`docsPath`](#docspath-17)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`SerializationError`](#serializationerror).[`getErrorChain`](#geterrorchain-34)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`SerializationError`](#serializationerror).[`toJSON`](#tojson-34)
***
### IntegerOverflowError
Defined in: [src/primitives/errors/OverflowError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L18)
Error thrown when integer value exceeds maximum bound
#### Example
```typescript theme={null}
throw new IntegerOverflowError(
'Value exceeds uint8 maximum',
{
value: 256n,
max: 255n,
type: 'uint8',
}
)
```
#### Extends
* [`InvalidRangeError`](#invalidrangeerror)
#### Constructors
##### Constructor
> **new IntegerOverflowError**(`message`, `options`): [`IntegerOverflowError`](#integeroverflowerror)
Defined in: [src/primitives/errors/OverflowError.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L24)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### max
`number` | `bigint`
###### type
`string`
###### value
`number` | `bigint`
###### Returns
[`IntegerOverflowError`](#integeroverflowerror)
###### Overrides
[`InvalidRangeError`](#invalidrangeerror).[`constructor`](#constructor-11)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`cause`](#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`code`](#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`context`](#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`docsPath`](#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`expected`](#expected-5)
##### integerType
> **integerType**: `string`
Defined in: [src/primitives/errors/OverflowError.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L22)
Integer type (e.g., 'uint8', 'uint256')
##### max
> **max**: `number` | `bigint`
Defined in: [src/primitives/errors/OverflowError.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L20)
Maximum allowed value
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`value`](#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`getErrorChain`](#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`toJSON`](#tojson-22)
***
### IntegerUnderflowError
Defined in: [src/primitives/errors/OverflowError.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L70)
Error thrown when integer value is below minimum bound (e.g., negative for unsigned)
#### Example
```typescript theme={null}
throw new IntegerUnderflowError(
'Unsigned integer cannot be negative',
{
value: -1n,
min: 0n,
type: 'uint256',
}
)
```
#### Extends
* [`InvalidRangeError`](#invalidrangeerror)
#### Constructors
##### Constructor
> **new IntegerUnderflowError**(`message`, `options`): [`IntegerUnderflowError`](#integerunderflowerror)
Defined in: [src/primitives/errors/OverflowError.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L76)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### min
`number` | `bigint`
###### type
`string`
###### value
`number` | `bigint`
###### Returns
[`IntegerUnderflowError`](#integerunderflowerror)
###### Overrides
[`InvalidRangeError`](#invalidrangeerror).[`constructor`](#constructor-11)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`cause`](#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`code`](#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`context`](#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`docsPath`](#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`expected`](#expected-5)
##### integerType
> **integerType**: `string`
Defined in: [src/primitives/errors/OverflowError.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L74)
Integer type (e.g., 'uint8', 'int256')
##### min
> **min**: `number` | `bigint`
Defined in: [src/primitives/errors/OverflowError.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L72)
Minimum allowed value
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`value`](#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`getErrorChain`](#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`toJSON`](#tojson-22)
***
### InvalidChecksumError
Defined in: [src/primitives/errors/ValidationError.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L115)
Invalid checksum error (e.g., EIP-55 checksum mismatch)
#### Throws
#### Extends
* [`ValidationError`](#validationerror)
#### Constructors
##### Constructor
> **new InvalidChecksumError**(`message`, `options`): [`InvalidChecksumError`](#invalidchecksumerror)
Defined in: [src/primitives/errors/ValidationError.ts:116](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L116)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected
`string`
###### value
`unknown`
###### Returns
[`InvalidChecksumError`](#invalidchecksumerror)
###### Overrides
[`ValidationError`](#validationerror).[`constructor`](#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](#validationerror).[`cause`](#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](#validationerror).[`code`](#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](#validationerror).[`context`](#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](#validationerror).[`docsPath`](#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](#validationerror).[`expected`](#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](#validationerror).[`value`](#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](#validationerror).[`getErrorChain`](#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](#validationerror).[`toJSON`](#tojson-38)
***
### InvalidFormatError
Defined in: [src/primitives/errors/ValidationError.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L49)
Invalid format error (e.g., wrong hex prefix, invalid characters)
#### Throws
#### Extends
* [`ValidationError`](#validationerror)
#### Extended by
* [`InvalidHexFormatError`](../primitives/Address.mdx#invalidhexformaterror)
* [`InvalidHexStringError`](../primitives/Address.mdx#invalidhexstringerror)
* [`InvalidChainIdError`](../primitives/Authorization.mdx#invalidchainiderror)
* [`InvalidAddressError`](../primitives/Authorization.mdx#invalidaddresserror)
* [`InvalidBytes32HexError`](../primitives/Bytes32.mdx#invalidbytes32hexerror)
* [`InvalidLabelExtensionError`](../primitives/Ens.mdx#invalidlabelextensionerror)
* [`IllegalMixtureError`](../primitives/Ens.mdx#illegalmixtureerror)
* [`WholeConfusableError`](../primitives/Ens.mdx#wholeconfusableerror)
* [`DisallowedCharacterError`](../primitives/Ens.mdx#disallowedcharactererror)
* [`EmptyLabelError`](../primitives/Ens.mdx#emptylabelerror)
* [`InvalidUtf8Error`](../primitives/Ens.mdx#invalidutf8error)
* [`InvalidSignatureFormatError`](../primitives/Signature.mdx#invalidsignatureformaterror)
* [`InvalidDERError`](../primitives/Signature.mdx#invaliddererror)
* [`InvalidMnemonicError`](../crypto/Bip39.mdx#invalidmnemonicerror)
* [`InvalidFieldError`](../primitives/Siwe.mdx#invalidfielderror)
* [`InvalidSiweMessageError`](../primitives/Siwe.mdx#invalidsiwemessageerror)
* [`MissingFieldError`](../primitives/Siwe.mdx#missingfielderror)
#### Constructors
##### Constructor
> **new InvalidFormatError**(`message`, `options`): [`InvalidFormatError`](#invalidformaterror)
Defined in: [src/primitives/errors/ValidationError.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L50)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected
`string`
###### value
`unknown`
###### Returns
[`InvalidFormatError`](#invalidformaterror)
###### Overrides
[`ValidationError`](#validationerror).[`constructor`](#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](#validationerror).[`cause`](#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](#validationerror).[`code`](#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](#validationerror).[`context`](#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](#validationerror).[`docsPath`](#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](#validationerror).[`expected`](#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](#validationerror).[`value`](#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](#validationerror).[`getErrorChain`](#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](#validationerror).[`toJSON`](#tojson-38)
***
### InvalidLengthError
Defined in: [src/primitives/errors/ValidationError.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L71)
Invalid length error (e.g., wrong byte count)
#### Throws
#### Extends
* [`ValidationError`](#validationerror)
#### Extended by
* [`InvalidAddressLengthError`](../primitives/Address.mdx#invalidaddresslengtherror)
* [`InvalidAddressLengthError`](../primitives/BinaryTree.mdx#invalidaddresslengtherror)
* [`InvalidKeyLengthError`](../primitives/BinaryTree.mdx#invalidkeylengtherror)
* [`InvalidBloomFilterLengthError`](../primitives/BloomFilter.mdx#invalidbloomfilterlengtherror)
* [`InvalidBytes32LengthError`](../primitives/Bytes32.mdx#invalidbytes32lengtherror)
* [`InvalidSignatureLengthError`](../primitives/Signature.mdx#invalidsignaturelengtherror)
* [`InvalidNonceLengthError`](../primitives/Siwe.mdx#invalidnoncelengtherror)
#### Constructors
##### Constructor
> **new InvalidLengthError**(`message`, `options`): [`InvalidLengthError`](#invalidlengtherror)
Defined in: [src/primitives/errors/ValidationError.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L72)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected
`string`
###### value
`unknown`
###### Returns
[`InvalidLengthError`](#invalidlengtherror)
###### Overrides
[`ValidationError`](#validationerror).[`constructor`](#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](#validationerror).[`cause`](#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](#validationerror).[`code`](#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](#validationerror).[`context`](#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](#validationerror).[`docsPath`](#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](#validationerror).[`expected`](#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](#validationerror).[`value`](#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](#validationerror).[`getErrorChain`](#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](#validationerror).[`toJSON`](#tojson-38)
***
### InvalidPrivateKeyError
Defined in: [src/primitives/errors/CryptoError.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L91)
Invalid private key error (e.g., out of range private key)
#### Throws
#### Extends
* [`CryptoError`](#cryptoerror)
#### Extended by
* [`InvalidSecretKeyError`](../crypto/Ed25519.mdx#invalidsecretkeyerror)
* [`InvalidPrivateKeyError`](../crypto/P256.mdx#invalidprivatekeyerror)
* [`InvalidSecretKeyError`](../crypto/X25519.mdx#invalidsecretkeyerror)
#### Constructors
##### Constructor
> **new InvalidPrivateKeyError**(`message`, `options?`): [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
Defined in: [src/primitives/errors/CryptoError.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L92)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPrivateKeyError`](#invalidprivatekeyerror)
###### Overrides
[`CryptoError`](#cryptoerror).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](#cryptoerror).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`docsPath`](#docspath-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](#cryptoerror).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](#cryptoerror).[`toJSON`](#tojson-2)
***
### InvalidPublicKeyError
Defined in: [src/primitives/errors/CryptoError.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L66)
Invalid public key error (e.g., malformed public key)
#### Throws
#### Extends
* [`CryptoError`](#cryptoerror)
#### Extended by
* [`InvalidPublicKeyError`](../crypto/Ed25519.mdx#invalidpublickeyerror)
* [`InvalidPublicKeyError`](../crypto/P256.mdx#invalidpublickeyerror)
* [`InvalidPublicKeyError`](../crypto/X25519.mdx#invalidpublickeyerror)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`, `options?`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/primitives/errors/CryptoError.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L67)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`CryptoError`](#cryptoerror).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](#cryptoerror).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`docsPath`](#docspath-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](#cryptoerror).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](#cryptoerror).[`toJSON`](#tojson-2)
***
### InvalidRangeError
Defined in: [src/primitives/errors/ValidationError.ts:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L93)
Invalid range error (e.g., value out of bounds)
#### Throws
#### Extends
* [`ValidationError`](#validationerror)
#### Extended by
* [`InvalidYParityError`](../primitives/Authorization.mdx#invalidyparityerror)
* [`InvalidSignatureRangeError`](../primitives/Authorization.mdx#invalidsignaturerangeerror)
* [`InvalidBloomFilterParameterError`](../primitives/BloomFilter.mdx#invalidbloomfilterparametererror)
* [`IntegerOverflowError`](#integeroverflowerror)
* [`IntegerUnderflowError`](#integerunderflowerror)
* [`InvalidSizeError`](#invalidsizeerror)
#### Constructors
##### Constructor
> **new InvalidRangeError**(`message`, `options`): [`InvalidRangeError`](#invalidrangeerror)
Defined in: [src/primitives/errors/ValidationError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L94)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected
`string`
###### value
`unknown`
###### Returns
[`InvalidRangeError`](#invalidrangeerror)
###### Overrides
[`ValidationError`](#validationerror).[`constructor`](#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](#validationerror).[`cause`](#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](#validationerror).[`code`](#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](#validationerror).[`context`](#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](#validationerror).[`docsPath`](#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](#validationerror).[`expected`](#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](#validationerror).[`value`](#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](#validationerror).[`getErrorChain`](#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](#validationerror).[`toJSON`](#tojson-38)
***
### InvalidSignatureError
Defined in: [src/primitives/errors/CryptoError.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L41)
Invalid signature error (e.g., signature verification failed)
#### Throws
#### Extends
* [`CryptoError`](#cryptoerror)
#### Extended by
* [`InvalidSignatureComponentError`](../primitives/Authorization.mdx#invalidsignaturecomponenterror)
* [`MalleableSignatureError`](../primitives/Authorization.mdx#malleablesignatureerror)
* [`InvalidAlgorithmError`](../primitives/Signature.mdx#invalidalgorithmerror)
* [`NonCanonicalSignatureError`](../primitives/Signature.mdx#noncanonicalsignatureerror)
* [`InvalidSignatureError`](../crypto/Ed25519.mdx#invalidsignatureerror)
* [`InvalidSignatureError`](../crypto/P256.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`, `options?`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/primitives/errors/CryptoError.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/CryptoError.ts#L42)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`CryptoError`](#cryptoerror).[`constructor`](#constructor-1)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`CryptoError`](#cryptoerror).[`cause`](#cause-1)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`code`](#code-1)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`context`](#context-1)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`CryptoError`](#cryptoerror).[`docsPath`](#docspath-1)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`CryptoError`](#cryptoerror).[`getErrorChain`](#geterrorchain-2)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`CryptoError`](#cryptoerror).[`toJSON`](#tojson-2)
***
### InvalidSignerError
Defined in: [src/primitives/errors/TransactionError.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L66)
Invalid signer error (e.g., signature doesn't match expected signer)
#### Throws
#### Extends
* [`TransactionError`](#transactionerror)
#### Constructors
##### Constructor
> **new InvalidSignerError**(`message`, `options?`): [`InvalidSignerError`](#invalidsignererror)
Defined in: [src/primitives/errors/TransactionError.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L67)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidSignerError`](#invalidsignererror)
###### Overrides
[`TransactionError`](#transactionerror).[`constructor`](#constructor-18)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`TransactionError`](#transactionerror).[`cause`](#cause-18)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`TransactionError`](#transactionerror).[`code`](#code-18)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`TransactionError`](#transactionerror).[`context`](#context-18)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`TransactionError`](#transactionerror).[`docsPath`](#docspath-18)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`TransactionError`](#transactionerror).[`getErrorChain`](#geterrorchain-36)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`TransactionError`](#transactionerror).[`toJSON`](#tojson-36)
***
### InvalidSizeError
Defined in: [src/primitives/errors/OverflowError.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L122)
Error thrown when hex/byte data has invalid size
#### Example
```typescript theme={null}
throw new InvalidSizeError(
'Address must be 20 bytes',
{
actualSize: 10,
expectedSize: 20,
value: '0x1234...',
}
)
```
#### Extends
* [`InvalidRangeError`](#invalidrangeerror)
#### Constructors
##### Constructor
> **new InvalidSizeError**(`message`, `options`): [`InvalidSizeError`](#invalidsizeerror)
Defined in: [src/primitives/errors/OverflowError.ts:128](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L128)
###### Parameters
###### message
`string`
###### options
###### actualSize
`number`
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expectedSize
`number`
###### value
`unknown`
###### Returns
[`InvalidSizeError`](#invalidsizeerror)
###### Overrides
[`InvalidRangeError`](#invalidrangeerror).[`constructor`](#constructor-11)
#### Properties
##### actualSize
> **actualSize**: `number`
Defined in: [src/primitives/errors/OverflowError.ts:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L124)
Actual size in bytes
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`cause`](#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`code`](#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`context`](#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`docsPath`](#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`expected`](#expected-5)
##### expectedSize
> **expectedSize**: `number`
Defined in: [src/primitives/errors/OverflowError.ts:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/OverflowError.ts#L126)
Expected size in bytes
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`value`](#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`getErrorChain`](#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](#invalidrangeerror).[`toJSON`](#tojson-22)
***
### InvalidTransactionTypeError
Defined in: [src/primitives/errors/TransactionError.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L41)
Invalid transaction type error (e.g., unsupported transaction type)
#### Throws
#### Extends
* [`TransactionError`](#transactionerror)
#### Constructors
##### Constructor
> **new InvalidTransactionTypeError**(`message`, `options?`): [`InvalidTransactionTypeError`](#invalidtransactiontypeerror)
Defined in: [src/primitives/errors/TransactionError.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L42)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`InvalidTransactionTypeError`](#invalidtransactiontypeerror)
###### Overrides
[`TransactionError`](#transactionerror).[`constructor`](#constructor-18)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`TransactionError`](#transactionerror).[`cause`](#cause-18)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`TransactionError`](#transactionerror).[`code`](#code-18)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`TransactionError`](#transactionerror).[`context`](#context-18)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`TransactionError`](#transactionerror).[`docsPath`](#docspath-18)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`TransactionError`](#transactionerror).[`getErrorChain`](#geterrorchain-36)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`TransactionError`](#transactionerror).[`toJSON`](#tojson-36)
***
### PrimitiveError
Defined in: [src/primitives/errors/PrimitiveError.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/PrimitiveError.ts#L15)
Base error for all primitive-related errors
#### Example
```typescript theme={null}
throw new PrimitiveError('Invalid primitive value', {
code: 'INVALID_PRIMITIVE',
context: { value: '0x123' },
docsPath: '/primitives/overview#errors'
})
```
#### Extends
* [`AbstractError`](#abstracterror)
#### Extended by
* [`NotImplementedError`](../primitives/Address.mdx#notimplementederror)
* [`ContractRevertError`](../primitives/ContractResult.mdx#contractreverterror)
* [`InvalidHexFormatError`](../primitives/EncodedData.mdx#invalidhexformaterror)
* [`InvalidValueError`](../primitives/EncodedData.mdx#invalidvalueerror)
* [`MultiTokenIdError`](../primitives/MultiTokenId.mdx#multitokeniderror)
* [`InvalidHexFormatError`](../primitives/ReturnData.mdx#invalidhexformaterror)
* [`InvalidValueError`](../primitives/ReturnData.mdx#invalidvalueerror)
* [`StealthAddressError`](../primitives/StealthAddress.mdx#stealthaddresserror)
* [`TokenBalanceError`](../primitives/TokenBalance.mdx#tokenbalanceerror)
* [`TokenIdError`](../primitives/TokenId.mdx#tokeniderror)
* [`CryptoError`](#cryptoerror)
* [`SerializationError`](#serializationerror)
* [`TransactionError`](#transactionerror)
* [`ValidationError`](#validationerror)
* [`EIP6963Error`](../provider/namespaces/provider/eip6963.mdx#eip6963error)
#### Constructors
##### Constructor
> **new PrimitiveError**(`message`, `options?`): [`PrimitiveError`](#primitiveerror)
Defined in: [src/primitives/errors/PrimitiveError.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/PrimitiveError.ts#L16)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`PrimitiveError`](#primitiveerror)
###### Overrides
[`AbstractError`](#abstracterror).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`AbstractError`](#abstracterror).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`AbstractError`](#abstracterror).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`AbstractError`](#abstracterror).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`AbstractError`](#abstracterror).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`AbstractError`](#abstracterror).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`AbstractError`](#abstracterror).[`toJSON`](#tojson)
***
### SerializationError
Defined in: [src/primitives/errors/SerializationError.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L16)
Base serialization error
#### Example
```typescript theme={null}
throw new SerializationError('Failed to serialize', {
code: 'SERIALIZATION_ERROR',
context: { data: [...] },
docsPath: '/primitives/rlp/encode#error-handling',
cause: originalError
})
```
#### Extends
* [`PrimitiveError`](#primitiveerror)
#### Extended by
* [`DecodingError`](#decodingerror)
* [`EncodingError`](#encodingerror)
#### Constructors
##### Constructor
> **new SerializationError**(`message`, `options?`): [`SerializationError`](#serializationerror)
Defined in: [src/primitives/errors/SerializationError.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/SerializationError.ts#L17)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`SerializationError`](#serializationerror)
###### Overrides
[`PrimitiveError`](#primitiveerror).[`constructor`](#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`cause`](#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`code`](#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`context`](#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`docsPath`](#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`getErrorChain`](#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`toJSON`](#tojson-32)
***
### TransactionError
Defined in: [src/primitives/errors/TransactionError.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L16)
Base transaction error
#### Example
```typescript theme={null}
throw new TransactionError('Transaction processing failed', {
code: 'TRANSACTION_ERROR',
context: { txType: '0x02' },
docsPath: '/primitives/transaction/overview#error-handling',
cause: originalError
})
```
#### Extends
* [`PrimitiveError`](#primitiveerror)
#### Extended by
* [`InvalidSignerError`](#invalidsignererror)
* [`InvalidTransactionTypeError`](#invalidtransactiontypeerror)
#### Constructors
##### Constructor
> **new TransactionError**(`message`, `options?`): [`TransactionError`](#transactionerror)
Defined in: [src/primitives/errors/TransactionError.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/TransactionError.ts#L17)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`TransactionError`](#transactionerror)
###### Overrides
[`PrimitiveError`](#primitiveerror).[`constructor`](#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`cause`](#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`code`](#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`context`](#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`docsPath`](#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`getErrorChain`](#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`toJSON`](#tojson-32)
***
### Uint
Defined in: [src/primitives/Uint/Uint.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L100)
Factory function for creating Uint instances
#### Constructors
##### Constructor
> **new Uint**(`value`): [`Uint`](#uint)
Defined in: [src/primitives/Uint/Uint.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L100)
Factory function for creating Uint instances
###### Parameters
###### value
`any`
###### Returns
[`Uint`](#uint)
#### Properties
##### bitLength()
> **bitLength**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:173](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L173)
Get number of bits required to represent value
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of bits (0-256)
###### Example
```typescript theme={null}
const a = Uint(255n);
const bits1 = Uint.bitLength(a); // 8
const bits2 = a.bitLength(); // 8
```
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:157](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L157)
Bitwise AND
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint & b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseAnd(a, b); // 0x0f
const result2 = a.bitwiseAnd(b); // 0x0f
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:160](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L160)
Bitwise NOT
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
\~uint & MAX
###### Example
```typescript theme={null}
const a = Uint(0n);
const result1 = Uint.bitwiseNot(a); // MAX
const result2 = a.bitwiseNot(); // MAX
```
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L158)
Bitwise OR
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint | b
###### Example
```typescript theme={null}
const a = Uint(0xf0n);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseOr(a, b); // 0xff
const result2 = a.bitwiseOr(b); // 0xff
```
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:159](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L159)
Bitwise XOR
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint ^ b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseXor(a, b); // 0xf0
const result2 = a.bitwiseXor(b); // 0xf0
```
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:154](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L154)
Divide Uint256 value
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Dividend
###### b
[`Type`](../primitives/Uint.mdx#type)
Divisor
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Quotient (uint / b), floor division
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(10n);
const quotient1 = Uint.dividedBy(a, b); // 10
const quotient2 = a.dividedBy(b); // 10
```
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:163](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L163)
Check equality
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint === b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const eq1 = Uint.equals(a, b); // true
const eq2 = a.equals(b); // true
```
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:167](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L167)
Check greater than
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint > b
###### Example
```typescript theme={null}
const a = Uint(200n);
const b = Uint(100n);
const isGreater1 = Uint.greaterThan(a, b); // true
const isGreater2 = a.greaterThan(b); // true
```
##### greaterThanOrEqual()
> **greaterThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:168](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L168)
Check greater than or equal
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint >= b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isGte1 = Uint.greaterThanOrEqual(a, b); // true
const isGte2 = a.greaterThanOrEqual(b); // true
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L170)
Check if value is zero
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`boolean`
true if uint === 0
###### Example
```typescript theme={null}
const a = Uint(0n);
const isZero1 = Uint.isZero(a); // true
const isZero2 = a.isZero(); // true
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L174)
Get number of leading zero bits
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of leading zeros (0-256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const zeros1 = Uint.leadingZeros(a); // 255
const zeros2 = a.leadingZeros(); // 255
```
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:165](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L165)
Check less than
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint \< b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isLess1 = Uint.lessThan(a, b); // true
const isLess2 = a.lessThan(b); // true
```
##### lessThanOrEqual()
> **lessThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L166)
Check less than or equal
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint is less than or equal to b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isLte1 = Uint.lessThanOrEqual(a, b); // true
const isLte2 = a.lessThanOrEqual(b); // true
```
##### maximum()
> **maximum**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L172)
Get maximum of two values
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
max(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const max1 = Uint.maximum(a, b); // 200
const max2 = a.maximum(b); // 200
```
##### minimum()
> **minimum**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:171](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L171)
Get minimum of two values
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
min(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const min1 = Uint.minimum(a, b); // 100
const min2 = a.minimum(b); // 100
```
##### minus()
> **minus**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L152)
Subtract Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Difference (uint - b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const diff1 = Uint.minus(a, b); // 50
const diff2 = a.minus(b); // 50
```
##### modulo()
> **modulo**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L155)
Modulo operation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Dividend
###### b
[`Type`](../primitives/Uint.mdx#type)
Divisor
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Remainder (uint % b)
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(30n);
const remainder1 = Uint.modulo(a, b); // 10
const remainder2 = a.modulo(b); // 10
```
##### notEquals()
> **notEquals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:164](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L164)
Check inequality
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint !== b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isNotEq1 = Uint.notEquals(a, b); // true
const isNotEq2 = a.notEquals(b); // true
```
##### plus()
> **plus**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:151](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L151)
Add Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Sum (uint + b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const sum1 = Uint.plus(a, b); // 150
const sum2 = a.plus(b); // 150
```
##### popCount()
> **popCount**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:175](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L175)
Count number of set bits (population count)
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of 1 bits
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const count1 = Uint.popCount(a); // 8
const count2 = a.popCount(); // 8
```
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:161](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L161)
Left shift
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to shift
###### bits
[`Type`](../primitives/Uint.mdx#type)
Number of bits to shift
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint shifted left by bits (mod 2^256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const b = Uint(8n);
const result1 = Uint.shiftLeft(a, b); // 256
const result2 = a.shiftLeft(b); // 256
```
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L162)
Right shift
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to shift
###### bits
[`Type`](../primitives/Uint.mdx#type)
Number of bits to shift
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint shifted right by bits
###### Example
```typescript theme={null}
const a = Uint(256n);
const b = Uint(8n);
const result1 = Uint.shiftRight(a, b); // 1
const result2 = a.shiftRight(b); // 1
```
##### times()
> **times**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:153](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L153)
Multiply Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Product (uint \* b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(10n);
const b = Uint(5n);
const product1 = Uint.times(a, b); // 50
const product2 = a.times(b); // 50
```
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/Uint.js:149](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L149)
Convert Uint256 to ABI-encoded bytes (32 bytes, big-endian)
This is identical to toBytes() - all Uint256 values in ABI encoding
are represented as 32-byte big-endian values.
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to encode
###### Returns
`Uint8Array`
32-byte ABI-encoded Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const encoded1 = Uint.toAbiEncoded(value);
const encoded2 = value.toAbiEncoded();
```
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
Defined in: [src/primitives/Uint/Uint.js:146](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L146)
Convert Uint256 to bigint
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`bigint`
bigint value
###### Example
```typescript theme={null}
const value = Uint(255n);
const bigint1 = Uint.toBigInt(value);
const bigint2 = value.toBigInt();
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/Uint.js:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L148)
Convert Uint256 to bytes (big-endian, 32 bytes)
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`Uint8Array`
32-byte Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const bytes1 = Uint.toBytes(value);
const bytes2 = value.toBytes();
```
##### toHex()
> **toHex**: (`uint`, `padded`) => `string`
Defined in: [src/primitives/Uint/Uint.js:145](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L145)
Convert Uint256 to hex string
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### padded
`boolean` = `true`
Whether to pad to 64 characters (32 bytes)
###### Returns
`string`
Hex string with 0x prefix
###### Example
```typescript theme={null}
const value = Uint(255n);
const hex1 = Uint.toHex(value); // "0x00...ff"
const hex2 = value.toHex(); // "0x00...ff"
const hex3 = value.toHex(false); // "0xff"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:147](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L147)
Convert Uint256 to number
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`number`
number value
###### Throws
Error if value exceeds MAX\_SAFE\_INTEGER
###### Example
```typescript theme={null}
const value = Uint(255n);
const num1 = Uint.toNumber(value);
const num2 = value.toNumber();
```
##### toPower()
> **toPower**: (`uint`, `exponent`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L156)
Exponentiation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Base value
###### exponent
[`Type`](../primitives/Uint.mdx#type)
Exponent value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint^exponent mod 2^256
###### Example
```typescript theme={null}
const base = Uint(2n);
const exp = Uint(8n);
const result1 = Uint.toPower(base, exp); // 256
const result2 = base.toPower(exp); // 256
```
##### toString()
> **toString**: (`uint`, `radix`) => `string`
Defined in: [src/primitives/Uint/Uint.js:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L150)
Convert Uint256 to string representation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### radix
`number` = `10`
Base for string conversion (2, 10, 16, etc.)
###### Returns
`string`
String representation
###### Example
```typescript theme={null}
const value = Uint(255n);
const dec1 = Uint.toString(value, 10); // "255"
const dec2 = value.toString(10); // "255"
const hex = value.toString(16); // "ff"
```
##### bitLength()
> `static` **bitLength**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L140)
Get number of bits required to represent value
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of bits (0-256)
###### Example
```typescript theme={null}
const a = Uint(255n);
const bits1 = Uint.bitLength(a); // 8
const bits2 = a.bitLength(); // 8
```
##### bitwiseAnd()
> `static` **bitwiseAnd**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L125)
Bitwise AND
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint & b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseAnd(a, b); // 0x0f
const result2 = a.bitwiseAnd(b); // 0x0f
```
##### bitwiseNot()
> `static` **bitwiseNot**: (`uint`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:128](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L128)
Bitwise NOT
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
\~uint & MAX
###### Example
```typescript theme={null}
const a = Uint(0n);
const result1 = Uint.bitwiseNot(a); // MAX
const result2 = a.bitwiseNot(); // MAX
```
##### bitwiseOr()
> `static` **bitwiseOr**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L126)
Bitwise OR
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint | b
###### Example
```typescript theme={null}
const a = Uint(0xf0n);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseOr(a, b); // 0xff
const result2 = a.bitwiseOr(b); // 0xff
```
##### bitwiseXor()
> `static` **bitwiseXor**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:127](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L127)
Bitwise XOR
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint ^ b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseXor(a, b); // 0xf0
const result2 = a.bitwiseXor(b); // 0xf0
```
##### dividedBy()
> `static` **dividedBy**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L122)
Divide Uint256 value
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Dividend
###### b
[`Type`](../primitives/Uint.mdx#type)
Divisor
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Quotient (uint / b), floor division
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(10n);
const quotient1 = Uint.dividedBy(a, b); // 10
const quotient2 = a.dividedBy(b); // 10
```
##### equals()
> `static` **equals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:131](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L131)
Check equality
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint === b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const eq1 = Uint.equals(a, b); // true
const eq2 = a.equals(b); // true
```
##### greaterThan()
> `static` **greaterThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:135](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L135)
Check greater than
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint > b
###### Example
```typescript theme={null}
const a = Uint(200n);
const b = Uint(100n);
const isGreater1 = Uint.greaterThan(a, b); // true
const isGreater2 = a.greaterThan(b); // true
```
##### greaterThanOrEqual()
> `static` **greaterThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:136](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L136)
Check greater than or equal
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint >= b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isGte1 = Uint.greaterThanOrEqual(a, b); // true
const isGte2 = a.greaterThanOrEqual(b); // true
```
##### isValid()
> `static` **isValid**: (`value`) => `value is Type`
Defined in: [src/primitives/Uint/Uint.js:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L112)
Check if value is a valid Uint256
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Type`
true if value is valid Uint256
###### Example
```typescript theme={null}
const isValid = Uint.isValid(100n); // true
const isInvalid = Uint.isValid(-1n); // false
```
##### isZero()
> `static` **isZero**: (`uint`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:137](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L137)
Check if value is zero
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`boolean`
true if uint === 0
###### Example
```typescript theme={null}
const a = Uint(0n);
const isZero1 = Uint.isZero(a); // true
const isZero2 = a.isZero(); // true
```
##### leadingZeros()
> `static` **leadingZeros**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:141](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L141)
Get number of leading zero bits
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of leading zeros (0-256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const zeros1 = Uint.leadingZeros(a); // 255
const zeros2 = a.leadingZeros(); // 255
```
##### lessThan()
> `static` **lessThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L133)
Check less than
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint \< b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isLess1 = Uint.lessThan(a, b); // true
const isLess2 = a.lessThan(b); // true
```
##### lessThanOrEqual()
> `static` **lessThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L134)
Check less than or equal
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint is less than or equal to b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isLte1 = Uint.lessThanOrEqual(a, b); // true
const isLte2 = a.lessThanOrEqual(b); // true
```
##### MAX
> `static` **MAX**: [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L178)
##### maximum()
> `static` **maximum**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:139](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L139)
Get maximum of two values
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
max(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const max1 = Uint.maximum(a, b); // 200
const max2 = a.maximum(b); // 200
```
##### MIN
> `static` **MIN**: [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:179](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L179)
##### minimum()
> `static` **minimum**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L138)
Get minimum of two values
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
min(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const min1 = Uint.minimum(a, b); // 100
const min2 = a.minimum(b); // 100
```
##### minus()
> `static` **minus**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:120](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L120)
Subtract Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Difference (uint - b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const diff1 = Uint.minus(a, b); // 50
const diff2 = a.minus(b); // 50
```
##### modulo()
> `static` **modulo**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L123)
Modulo operation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Dividend
###### b
[`Type`](../primitives/Uint.mdx#type)
Divisor
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Remainder (uint % b)
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(30n);
const remainder1 = Uint.modulo(a, b); // 10
const remainder2 = a.modulo(b); // 10
```
##### notEquals()
> `static` **notEquals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/Uint.js:132](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L132)
Check inequality
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First value
###### b
[`Type`](../primitives/Uint.mdx#type)
Second value
###### Returns
`boolean`
true if uint !== b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isNotEq1 = Uint.notEquals(a, b); // true
const isNotEq2 = a.notEquals(b); // true
```
##### ONE
> `static` **ONE**: [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:181](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L181)
##### plus()
> `static` **plus**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L119)
Add Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Sum (uint + b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const sum1 = Uint.plus(a, b); // 150
const sum2 = a.plus(b); // 150
```
##### popCount()
> `static` **popCount**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L142)
Count number of set bits (population count)
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to check
###### Returns
`number`
Number of 1 bits
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const count1 = Uint.popCount(a); // 8
const count2 = a.popCount(); // 8
```
##### shiftLeft()
> `static` **shiftLeft**: (`uint`, `bits`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:129](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L129)
Left shift
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to shift
###### bits
[`Type`](../primitives/Uint.mdx#type)
Number of bits to shift
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint shifted left by bits (mod 2^256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const b = Uint(8n);
const result1 = Uint.shiftLeft(a, b); // 256
const result2 = a.shiftLeft(b); // 256
```
##### shiftRight()
> `static` **shiftRight**: (`uint`, `bits`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L130)
Right shift
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Value to shift
###### bits
[`Type`](../primitives/Uint.mdx#type)
Number of bits to shift
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint shifted right by bits
###### Example
```typescript theme={null}
const a = Uint(256n);
const b = Uint(8n);
const result1 = Uint.shiftRight(a, b); // 1
const result2 = a.shiftRight(b); // 1
```
##### SIZE
> `static` **SIZE**: `number`
Defined in: [src/primitives/Uint/Uint.js:143](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L143)
##### times()
> `static` **times**: (`uint`, `b`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L121)
Multiply Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
First operand
###### b
[`Type`](../primitives/Uint.mdx#type)
Second operand
###### Returns
[`Type`](../primitives/Uint.mdx#type)
Product (uint \* b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(10n);
const b = Uint(5n);
const product1 = Uint.times(a, b); // 50
const product2 = a.times(b); // 50
```
##### toAbiEncoded()
> `static` **toAbiEncoded**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/Uint.js:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L117)
Convert Uint256 to ABI-encoded bytes (32 bytes, big-endian)
This is identical to toBytes() - all Uint256 values in ABI encoding
are represented as 32-byte big-endian values.
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to encode
###### Returns
`Uint8Array`
32-byte ABI-encoded Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const encoded1 = Uint.toAbiEncoded(value);
const encoded2 = value.toAbiEncoded();
```
##### toBigInt()
> `static` **toBigInt**: (`uint`) => `bigint`
Defined in: [src/primitives/Uint/Uint.js:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L114)
Convert Uint256 to bigint
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`bigint`
bigint value
###### Example
```typescript theme={null}
const value = Uint(255n);
const bigint1 = Uint.toBigInt(value);
const bigint2 = value.toBigInt();
```
##### toBytes()
> `static` **toBytes**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/Uint.js:116](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L116)
Convert Uint256 to bytes (big-endian, 32 bytes)
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`Uint8Array`
32-byte Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const bytes1 = Uint.toBytes(value);
const bytes2 = value.toBytes();
```
##### toHex()
> `static` **toHex**: (`uint`, `padded`) => `string`
Defined in: [src/primitives/Uint/Uint.js:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L113)
Convert Uint256 to hex string
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### padded
`boolean` = `true`
Whether to pad to 64 characters (32 bytes)
###### Returns
`string`
Hex string with 0x prefix
###### Example
```typescript theme={null}
const value = Uint(255n);
const hex1 = Uint.toHex(value); // "0x00...ff"
const hex2 = value.toHex(); // "0x00...ff"
const hex3 = value.toHex(false); // "0xff"
```
##### toNumber()
> `static` **toNumber**: (`uint`) => `number`
Defined in: [src/primitives/Uint/Uint.js:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L115)
Convert Uint256 to number
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### Returns
`number`
number value
###### Throws
Error if value exceeds MAX\_SAFE\_INTEGER
###### Example
```typescript theme={null}
const value = Uint(255n);
const num1 = Uint.toNumber(value);
const num2 = value.toNumber();
```
##### toPower()
> `static` **toPower**: (`uint`, `exponent`) => [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L124)
Exponentiation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Base value
###### exponent
[`Type`](../primitives/Uint.mdx#type)
Exponent value
###### Returns
[`Type`](../primitives/Uint.mdx#type)
uint^exponent mod 2^256
###### Example
```typescript theme={null}
const base = Uint(2n);
const exp = Uint(8n);
const result1 = Uint.toPower(base, exp); // 256
const result2 = base.toPower(exp); // 256
```
##### toString()
> `static` **toString**: (`uint`, `radix`) => `string`
Defined in: [src/primitives/Uint/Uint.js:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L118)
Convert Uint256 to string representation
###### Parameters
###### uint
[`Type`](../primitives/Uint.mdx#type)
Uint256 value to convert
###### radix
`number` = `10`
Base for string conversion (2, 10, 16, etc.)
###### Returns
`string`
String representation
###### Example
```typescript theme={null}
const value = Uint(255n);
const dec1 = Uint.toString(value, 10); // "255"
const dec2 = value.toString(10); // "255"
const hex = value.toString(16); // "ff"
```
##### tryFrom()
> `static` **tryFrom**: (`value`) => [`Type`](../primitives/Uint.mdx#type) | `undefined`
Defined in: [src/primitives/Uint/Uint.js:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L111)
Try to create Uint256, returns undefined if invalid (standard form)
###### Parameters
###### value
bigint, number, or string
`string` | `number` | `bigint`
###### Returns
[`Type`](../primitives/Uint.mdx#type) | `undefined`
Uint256 value or undefined
###### Example
```typescript theme={null}
const a = Uint.tryFrom(100n); // Uint256
const b = Uint.tryFrom(-1n); // undefined
const c = Uint.tryFrom("invalid"); // undefined
```
##### ZERO
> `static` **ZERO**: [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:180](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L180)
#### Methods
##### from()
> `static` **from**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L104)
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
[`Type`](../primitives/Uint.mdx#type)
##### fromAbiEncoded()
> `static` **fromAbiEncoded**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L109)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Type`](../primitives/Uint.mdx#type)
##### fromBigInt()
> `static` **fromBigInt**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L106)
###### Parameters
###### value
`bigint`
###### Returns
[`Type`](../primitives/Uint.mdx#type)
##### fromBytes()
> `static` **fromBytes**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L108)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Type`](../primitives/Uint.mdx#type)
##### fromHex()
> `static` **fromHex**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L105)
###### Parameters
###### value
`string`
###### Returns
[`Type`](../primitives/Uint.mdx#type)
##### fromNumber()
> `static` **fromNumber**(`value`): [`Type`](../primitives/Uint.mdx#type)
Defined in: [src/primitives/Uint/Uint.js:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint.js#L107)
###### Parameters
###### value
`number` | `bigint`
###### Returns
[`Type`](../primitives/Uint.mdx#type)
***
### ValidationError
Defined in: [src/primitives/errors/ValidationError.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L17)
Base validation error
#### Example
```typescript theme={null}
throw new ValidationError('Invalid value', {
value: '0x123',
expected: '20 bytes',
code: 'VALIDATION_ERROR',
docsPath: '/primitives/address/from-hex#error-handling',
cause: originalError
})
```
#### Extends
* [`PrimitiveError`](#primitiveerror)
#### Extended by
* [`InvalidValueError`](../primitives/Address.mdx#invalidvalueerror)
* [`InvalidAddressError`](../primitives/Address.mdx#invalidaddresserror)
* [`InvalidChecksumError`](../primitives/Address.mdx#invalidchecksumerror)
* [`InvalidTreeStateError`](../primitives/BinaryTree.mdx#invalidtreestateerror)
* [`InvalidBytes32ValueError`](../primitives/Bytes32.mdx#invalidbytes32valueerror)
* [`InvalidMultiTokenIdError`](../primitives/MultiTokenId.mdx#invalidmultitokeniderror)
* [`InvalidTokenBalanceError`](../primitives/TokenBalance.mdx#invalidtokenbalanceerror)
* [`TokenBalanceOverflowError`](../primitives/TokenBalance.mdx#tokenbalanceoverflowerror)
* [`InvalidTokenIdError`](../primitives/TokenId.mdx#invalidtokeniderror)
* [`InvalidChecksumError`](#invalidchecksumerror)
* [`InvalidFormatError`](#invalidformaterror)
* [`InvalidLengthError`](#invalidlengtherror)
* [`InvalidRangeError`](#invalidrangeerror)
#### Constructors
##### Constructor
> **new ValidationError**(`message`, `options`): [`ValidationError`](#validationerror)
Defined in: [src/primitives/errors/ValidationError.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L21)
###### Parameters
###### message
`string`
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected
`string`
###### value
`unknown`
###### Returns
[`ValidationError`](#validationerror)
###### Overrides
[`PrimitiveError`](#primitiveerror).[`constructor`](#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`cause`](#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`code`](#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`context`](#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`docsPath`](#docspath-16)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`getErrorChain`](#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](#primitiveerror).[`toJSON`](#tojson-32)
## Type Aliases
### Blake2Hash
> **Blake2Hash** = `Uint8Array` & `object`
Defined in: [src/crypto/Blake2/Blake2HashType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/Blake2HashType.ts#L19)
Blake2Hash - 64-byte (default) branded Uint8Array type
Type-safe wrapper around Uint8Array representing a BLAKE2b hash.
Zero runtime overhead - just compile-time type checking.
Supports variable output lengths (1-64 bytes).
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Blake2Hash"`
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { Blake2Hash } from './crypto/Blake2/index.js';
const hash: Blake2Hash = Blake2Hash.from("hello");
// Uint8Array(64) with type branding
```
***
### Bls12381Fp2Type
> **Bls12381Fp2Type** = `object`
Defined in: [src/crypto/Bls12381/Fp2Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2Type.ts#L11)
BLS12-381 Fp2 extension field element type
Fp2 = Fp\[i] / (i^2 + 1), where i^2 = -1
Elements are represented as c0 + c1\*i where c0, c1 are in Fp
#### Since
0.0.0
#### Properties
##### \[brand]?
> `readonly` `optional` **\[brand]**: `"Bls12381Fp2"`
Defined in: [src/crypto/Bls12381/Fp2Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2Type.ts#L16)
##### c0
> **c0**: `bigint`
Defined in: [src/crypto/Bls12381/Fp2Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2Type.ts#L13)
Real component (c0)
##### c1
> **c1**: `bigint`
Defined in: [src/crypto/Bls12381/Fp2Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/Fp2Type.ts#L15)
Imaginary component (c1)
***
### Bls12381G1PointType
> **Bls12381G1PointType** = `object`
Defined in: [src/crypto/Bls12381/G1PointType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1PointType.ts#L14)
BLS12-381 G1 point type in projective coordinates
G1 is the base field elliptic curve group over Fp.
Points are stored in Jacobian projective coordinates (x, y, z)
where the affine point is (x/z^2, y/z^3).
Curve equation: y^2 = x^3 + 4 over Fp
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Bls12381G1Point"`
Defined in: [src/crypto/Bls12381/G1PointType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1PointType.ts#L21)
##### x
> **x**: `bigint`
Defined in: [src/crypto/Bls12381/G1PointType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1PointType.ts#L16)
x-coordinate in projective form
##### y
> **y**: `bigint`
Defined in: [src/crypto/Bls12381/G1PointType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1PointType.ts#L18)
y-coordinate in projective form
##### z
> **z**: `bigint`
Defined in: [src/crypto/Bls12381/G1PointType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G1PointType.ts#L20)
z-coordinate (projective scaling factor)
***
### Bls12381G2PointType
> **Bls12381G2PointType** = `object`
Defined in: [src/crypto/Bls12381/G2PointType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2PointType.ts#L15)
BLS12-381 G2 point type in projective coordinates
G2 is the extension field elliptic curve group over Fp2.
Points are stored in Jacobian projective coordinates (x, y, z)
where x, y, z are Fp2 elements.
Curve equation: y^2 = x^3 + 4(1+i) over Fp2
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Bls12381G2Point"`
Defined in: [src/crypto/Bls12381/G2PointType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2PointType.ts#L22)
##### x
> **x**: [`Bls12381Fp2Type`](#bls12381fp2type)
Defined in: [src/crypto/Bls12381/G2PointType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2PointType.ts#L17)
x-coordinate in projective form (Fp2 element)
##### y
> **y**: [`Bls12381Fp2Type`](#bls12381fp2type)
Defined in: [src/crypto/Bls12381/G2PointType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2PointType.ts#L19)
y-coordinate in projective form (Fp2 element)
##### z
> **z**: [`Bls12381Fp2Type`](#bls12381fp2type)
Defined in: [src/crypto/Bls12381/G2PointType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Bls12381/G2PointType.ts#L21)
z-coordinate (projective scaling factor, Fp2 element)
***
### Ether
> **Ether** = [`EtherType`](namespaces/BrandedEther.mdx#ethertype)
Defined in: [src/primitives/Denomination/index.d.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L42)
***
### Gwei
> **Gwei** = [`GweiType`](namespaces/BrandedGwei.mdx#gweitype)
Defined in: [src/primitives/Denomination/index.d.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L29)
***
### Keccak256Hash
> **Keccak256Hash** = `Uint8Array` & `object`
Defined in: [src/crypto/Keccak256/Keccak256HashType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/Keccak256HashType.ts#L18)
Keccak256Hash - 32-byte branded Uint8Array type
Type-safe wrapper around Uint8Array representing a Keccak256 hash.
Zero runtime overhead - just compile-time type checking.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Keccak256Hash"`
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash: Keccak256Hash = Keccak256Hash.from("hello");
// Uint8Array(32) with type branding
```
***
### Ripemd160Hash
> **Ripemd160Hash** = `Uint8Array` & `object`
Defined in: [src/crypto/Ripemd160/Ripemd160HashType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Ripemd160/Ripemd160HashType.ts#L18)
Ripemd160Hash - 20-byte branded Uint8Array type
Type-safe wrapper around Uint8Array representing a RIPEMD160 hash.
Zero runtime overhead - just compile-time type checking.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Ripemd160Hash"`
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash: Ripemd160Hash = Ripemd160Hash.from("hello");
// Uint8Array(20) with type branding
```
***
### SHA256Hash
> **SHA256Hash** = `Uint8Array` & `object`
Defined in: [src/crypto/SHA256/SHA256HashType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/SHA256/SHA256HashType.ts#L18)
SHA256Hash - 32-byte branded Uint8Array type
Type-safe wrapper around Uint8Array representing a SHA256 hash.
Zero runtime overhead - just compile-time type checking.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"SHA256Hash"`
#### Since
0.0.0
#### Example
```typescript theme={null}
import type { SHA256Hash } from './crypto/SHA256/index.js';
const hash: SHA256Hash = SHA256Hash.from("hello");
// Uint8Array(32) with type branding
```
***
### Wei
> **Wei** = [`WeiType`](namespaces/BrandedWei.mdx#weitype)
Defined in: [src/primitives/Denomination/index.d.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L16)
## Variables
### BN254
> `const` **BN254**: `object`
Defined in: [src/crypto/bn254/BN254.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254/BN254.js#L53)
BN254 main export
#### Type Declaration
##### deserializeG1()
> **deserializeG1**: (`bytes`) => `G1PointType`
Deserialize G1 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### Returns
`G1PointType`
G1 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 64 bytes)
###### Example
```javascript theme={null}
import { deserializeG1 } from './crypto/bn254/deserializeG1.js';
const bytes = new Uint8Array(64);
const point = deserializeG1(bytes);
```
##### deserializeG2()
> **deserializeG2**: (`bytes`) => `G2PointType`
Deserialize G2 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### Returns
`G2PointType`
G2 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 128 bytes)
###### Example
```javascript theme={null}
import { deserializeG2 } from './crypto/bn254/deserializeG2.js';
const bytes = new Uint8Array(128);
const point = deserializeG2(bytes);
```
##### Fp
> **Fp**: `__module`
##### Fp2
> **Fp2**: `__module`
##### Fr
> **Fr**: `__module`
##### G1
> **G1**: `__module`
##### G2
> **G2**: `__module`
##### Pairing
> **Pairing**: `__module`
##### serializeG1()
> **serializeG1**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G1 point to bytes (64 bytes: x || y)
###### Parameters
###### point
`G1PointType`
G1 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG1 } from './crypto/bn254/serializeG1.js';
import * as G1 from './crypto/bn254/G1/index.js';
const point = G1.generator();
const bytes = serializeG1(point);
```
##### serializeG2()
> **serializeG2**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G2 point to bytes (128 bytes: x.c0 || x.c1 || y.c0 || y.c1)
###### Parameters
###### point
`G2PointType`
G2 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG2 } from './crypto/bn254/serializeG2.js';
import * as G2 from './crypto/bn254/G2/index.js';
const point = G2.generator();
const bytes = serializeG2(point);
```
***
### Ether
> **Ether**: `EtherConstructor`
Defined in: [src/primitives/Denomination/index.d.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L42)
***
### Gwei
> **Gwei**: `GweiConstructor`
Defined in: [src/primitives/Denomination/index.d.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L29)
***
### Hash
> `const` **Hash**: `HashConstructor`
Defined in: [src/primitives/Hash/Hash.d.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.d.ts#L3)
***
### Wei
> **Wei**: `WeiConstructor`
Defined in: [src/primitives/Denomination/index.d.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/index.d.ts#L16)
## Functions
### Bytes()
> **Bytes**(`value`): [`BytesType`](../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes.ts#L19)
Create Bytes from various input types (callable constructor)
#### Parameters
##### value
Uint8Array, hex string, UTF-8 string, or number array
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`BytesType`](../primitives/Bytes.mdx#bytestype)
Bytes
#### Example
```typescript theme={null}
import { Bytes } from '@tevm/voltaire';
const b1 = Bytes([0x01, 0x02, 0x03]);
const b2 = Bytes(new Uint8Array([0x01, 0x02]));
const b3 = Bytes("0x1234");
```
***
### Bytes2()
> **Bytes2**(`value`): [`Bytes2Type`](../primitives/Bytes.mdx#bytes2type)
Defined in: [src/primitives/Bytes/Bytes2/Bytes2.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/Bytes2.js#L21)
Create Bytes2 from various input types (callable constructor)
#### Parameters
##### value
Input value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes2Type`](../primitives/Bytes.mdx#bytes2type)
***
### Bytes3()
> **Bytes3**(`value`): [`Bytes3Type`](../primitives/Bytes.mdx#bytes3type)
Defined in: [src/primitives/Bytes/Bytes3/Bytes3.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/Bytes3.js#L21)
Create Bytes3 from various input types (callable constructor)
#### Parameters
##### value
Input value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes3Type`](../primitives/Bytes.mdx#bytes3type)
***
### Bytes5()
> **Bytes5**(`value`): [`Bytes5Type`](../primitives/Bytes.mdx#bytes5type)
Defined in: [src/primitives/Bytes/Bytes5/Bytes5.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/Bytes5.js#L21)
Create Bytes5 from various input types (callable constructor)
#### Parameters
##### value
Input value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes5Type`](../primitives/Bytes.mdx#bytes5type)
***
### Bytes6()
> **Bytes6**(`value`): [`Bytes6Type`](../primitives/Bytes.mdx#bytes6type)
Defined in: [src/primitives/Bytes/Bytes6/Bytes6.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/Bytes6.js#L21)
Create Bytes6 from various input types (callable constructor)
#### Parameters
##### value
Input value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes6Type`](../primitives/Bytes.mdx#bytes6type)
***
### Bytes7()
> **Bytes7**(`value`): [`Bytes7Type`](../primitives/Bytes.mdx#bytes7type)
Defined in: [src/primitives/Bytes/Bytes7/Bytes7.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/Bytes7.js#L21)
Create Bytes7 from various input types (callable constructor)
#### Parameters
##### value
Input value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes7Type`](../primitives/Bytes.mdx#bytes7type)
***
### Hex()
> **Hex**(`value`): [`HexType`](../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/Hex.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/Hex.ts#L22)
Factory function for creating Hex instances (canonical constructor)
#### Parameters
##### value
Hex string or bytes
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`HexType`](../primitives/Hex.mdx#hextype)
Hex value
#### Example
```ts theme={null}
import { Hex } from '@voltaire/primitives/Hex';
const hex = Hex('0x1234');
```
***
### Int128()
> **Int128**(`value`): [`BrandedInt128`](../primitives/Int128.mdx#brandedint128)
Defined in: [src/primitives/Int128/Int128.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/Int128.js#L68)
Create Int128 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt128`](../primitives/Int128.mdx#brandedint128)
#### Example
```javascript theme={null}
import { Int128 } from '@tevm/voltaire';
const a = Int128(-1000000000000000000000n);
const b = Int128("0xffffffffffffffffffc9f2c9cd04674edbb00000");
```
***
### Int16()
> **Int16**(`value`): [`BrandedInt16`](../primitives/Int16.mdx#brandedint16)
Defined in: [src/primitives/Int16/Int16.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/Int16.js#L28)
Create Int16 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt16`](../primitives/Int16.mdx#brandedint16)
#### Example
```javascript theme={null}
import { Int16 } from '@tevm/voltaire';
const a = Int16(-1000);
const b = Int16("0xfc18");
```
***
### Int256()
> **Int256**(`value`): [`BrandedInt256`](../primitives/Int256.mdx#brandedint256)
Defined in: [src/primitives/Int256/Int256.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/Int256.js#L68)
Create Int256 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt256`](../primitives/Int256.mdx#brandedint256)
#### Example
```javascript theme={null}
import { Int256 } from '@tevm/voltaire';
const a = Int256(-1000000000000000000000000000000n);
const b = Int256("0xff..."); // 256-bit hex
```
***
### Int32()
> **Int32**(`value`): [`BrandedInt32`](../primitives/Int32.mdx#brandedint32)
Defined in: [src/primitives/Int32/Int32.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/Int32.js#L57)
Create Int32 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt32`](../primitives/Int32.mdx#brandedint32)
#### Example
```javascript theme={null}
import { Int32 } from '@tevm/voltaire';
const a = Int32(-100000);
const b = Int32("0xfffe7960");
```
***
### Int64()
> **Int64**(`value`): [`BrandedInt64`](../primitives/Int64.mdx#brandedint64)
Defined in: [src/primitives/Int64/Int64.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/Int64.js#L57)
Create Int64 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt64`](../primitives/Int64.mdx#brandedint64)
#### Example
```javascript theme={null}
import { Int64 } from '@tevm/voltaire';
const a = Int64(-1000000000000n);
const b = Int64("0xffffff172b5af000");
```
***
### Int8()
> **Int8**(`value`): [`BrandedInt8`](../primitives/Int8.mdx#brandedint8)
Defined in: [src/primitives/Int8/Int8.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/Int8.js#L28)
Create Int8 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt8`](../primitives/Int8.mdx#brandedint8)
#### Example
```javascript theme={null}
import { Int8 } from '@tevm/voltaire';
const a = Int8(-42);
const b = Int8("0xd6");
```
***
### KZG()
> **KZG**(): `void`
Defined in: [src/crypto/KZG/KZG.js:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/KZG/KZG.js#L121)
KZG Commitments for EIP-4844
Available in both native FFI and WASM environments.
#### Returns
`void`
#### See
[https://voltaire.tevm.sh/crypto/kzg](https://voltaire.tevm.sh/crypto/kzg)
#### Since
0.0.0
#### Throws
Always throws - use static methods instead
***
### Opcode()
> **Opcode**(`value`): [`BrandedOpcode`](../primitives/Opcode.mdx#brandedopcode)
Defined in: [src/primitives/Opcode/Opcode.js:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/Opcode.js#L119)
Identity function for type branding
#### Parameters
##### value
`number`
Opcode byte value
#### Returns
[`BrandedOpcode`](../primitives/Opcode.mdx#brandedopcode)
Branded opcode
***
### Uint128()
> **Uint128**(`value`): [`Uint128Type`](../primitives/Uint128.mdx#uint128type)
Defined in: [src/primitives/Uint128/Uint128.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/Uint128.js#L69)
Create Uint128 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`Uint128Type`](../primitives/Uint128.mdx#uint128type)
#### Example
```javascript theme={null}
import { Uint128 } from '@tevm/voltaire';
const a = Uint128(1000000000000000000000000n);
const b = Uint128("0xd3c21bcecceda1000000");
```
***
### Uint16()
> **Uint16**(`value`): `Uint16Type`
Defined in: [src/primitives/Uint16/Uint16.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/Uint16.js#L54)
Create Uint16 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
`Uint16Type`
#### Example
```javascript theme={null}
import { Uint16 } from '@tevm/voltaire';
const a = Uint16(1000);
const b = Uint16("0x03e8");
```
***
### Uint32()
> **Uint32**(`value`): [`Uint32Type`](../primitives/Uint32.mdx#uint32type)
Defined in: [src/primitives/Uint32/Uint32.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/Uint32.js#L59)
Create Uint32 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`Uint32Type`](../primitives/Uint32.mdx#uint32type)
#### Example
```javascript theme={null}
import { Uint32 } from '@tevm/voltaire';
const a = Uint32(100000);
const b = Uint32("0x186a0");
```
***
### Uint64()
> **Uint64**(`value`): [`Uint64Type`](../primitives/Uint64.mdx#uint64type)
Defined in: [src/primitives/Uint64/Uint64.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/Uint64.js#L59)
Create Uint64 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
[`Uint64Type`](../primitives/Uint64.mdx#uint64type)
#### Example
```javascript theme={null}
import { Uint64 } from '@tevm/voltaire';
const a = Uint64(1000000000000n);
const b = Uint64("0xe8d4a51000");
```
***
### Uint8()
> **Uint8**(`value`): `Uint8Type`
Defined in: [src/primitives/Uint8/Uint8.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/Uint8.js#L55)
Create Uint8 from various input types (callable constructor)
#### Parameters
##### value
Number, BigInt, or hex string
`string` | `number` | `bigint`
#### Returns
`Uint8Type`
#### Example
```javascript theme={null}
import { Uint8 } from '@tevm/voltaire';
const a = Uint8(42);
const b = Uint8("0x2a");
const c = Uint8(42n);
```
## References
### Abi
Re-exports [Abi](../primitives/Abi/index.mdx#abi)
***
### AccessList
Re-exports [AccessList](../primitives/AccessList.mdx#accesslist)
***
### Address
Re-exports [Address](../primitives/Address.mdx#address)
***
### AesGcm
Re-exports [AesGcm](../crypto/AesGcm.mdx#aesgcm)
***
### Authorization
Renames and re-exports [primitives/Authorization](../primitives/Authorization.mdx)
***
### Base64
Renames and re-exports [primitives/Base64](../primitives/Base64.mdx)
***
### BeaconBlockRoot
Renames and re-exports [primitives/BeaconBlockRoot](../primitives/BeaconBlockRoot.mdx)
***
### BinaryTree
Renames and re-exports [primitives/BinaryTree](../primitives/BinaryTree.mdx)
***
### Bip39
Re-exports [Bip39](../crypto/Bip39.mdx#bip39)
***
### Blake2
Re-exports [Blake2](../crypto/Blake2.mdx#blake2)
***
### Blake2HashType
Renames and re-exports [Blake2Hash](#blake2hash)
***
### Blob
Re-exports [Blob](../primitives/Blob.mdx#blob)
***
### Block
Renames and re-exports [primitives/Block](../primitives/Block.mdx)
***
### BlockBody
Renames and re-exports [primitives/BlockBody](../primitives/BlockBody.mdx)
***
### BlockFilter
Renames and re-exports [primitives/BlockFilter](../primitives/BlockFilter.mdx)
***
### BlockHash
Renames and re-exports [primitives/BlockHash](../primitives/BlockHash.mdx)
***
### BlockHeader
Renames and re-exports [primitives/BlockHeader](../primitives/BlockHeader.mdx)
***
### BlockNumber
Renames and re-exports [primitives/BlockNumber](../primitives/BlockNumber.mdx)
***
### BloomFilter
Re-exports [BloomFilter](../primitives/BloomFilter.mdx#bloomfilter)
***
### Bls12381
Re-exports [Bls12381](../crypto/Bls12381/index.mdx#bls12381)
***
### BrandedAbi
Renames and re-exports [primitives/Abi](../primitives/Abi/index.mdx)
***
### BrandedAccessList
Renames and re-exports [primitives/AccessList](../primitives/AccessList.mdx)
***
### BrandedAuthorization
Renames and re-exports [primitives/Authorization](../primitives/Authorization.mdx)
***
### BrandedBinaryTree
Renames and re-exports [primitives/BinaryTree](../primitives/BinaryTree.mdx)
***
### BrandedBlob
Renames and re-exports [primitives/Blob](../primitives/Blob.mdx)
***
### BrandedBloomFilter
Renames and re-exports [primitives/BloomFilter](../primitives/BloomFilter.mdx)
***
### BrandedBytecode
Renames and re-exports [primitives/Bytecode](../primitives/Bytecode.mdx)
***
### BrandedEventLog
Renames and re-exports [primitives/EventLog](../primitives/EventLog.mdx)
***
### BrandedHash
Renames and re-exports [primitives/Hash](../primitives/Hash.mdx)
***
### BrandedInt128
Renames and re-exports [primitives/Int128](../primitives/Int128.mdx)
***
### BrandedInt16
Renames and re-exports [primitives/Int16](../primitives/Int16.mdx)
***
### BrandedInt256
Renames and re-exports [primitives/Int256](../primitives/Int256.mdx)
***
### BrandedInt32
Renames and re-exports [primitives/Int32](../primitives/Int32.mdx)
***
### BrandedInt64
Renames and re-exports [primitives/Int64](../primitives/Int64.mdx)
***
### BrandedInt8
Renames and re-exports [primitives/Int8](../primitives/Int8.mdx)
***
### BrandedSiwe
Renames and re-exports [primitives/Siwe](../primitives/Siwe.mdx)
***
### BrandedStorageKey
Renames and re-exports [primitives/State](../primitives/State.mdx)
***
### BrandedUint
Renames and re-exports [primitives/Uint](../primitives/Uint.mdx)
***
### BrandedUint128
Renames and re-exports [primitives/Uint128](../primitives/Uint128.mdx)
***
### BrandedUint16
Renames and re-exports [primitives/Uint16](../primitives/Uint16.mdx)
***
### BrandedUint32
Renames and re-exports [primitives/Uint32](../primitives/Uint32.mdx)
***
### BrandedUint64
Renames and re-exports [primitives/Uint64](../primitives/Uint64.mdx)
***
### BrandedUint8
Renames and re-exports [primitives/Uint8](../primitives/Uint8.mdx)
***
### Bytecode
Re-exports [Bytecode](../primitives/Bytecode.mdx#bytecode)
***
### Bytes1
Re-exports [Bytes1](namespaces/BrandedBytes1.mdx#bytes1)
***
### Bytes16
Re-exports [Bytes16](namespaces/BrandedBytes16.mdx#bytes16)
***
### Bytes32
Re-exports [Bytes32](namespaces/BrandedBytes32.mdx#bytes32)
***
### Bytes4
Re-exports [Bytes4](namespaces/BrandedBytes4.mdx#bytes4)
***
### Bytes64
Re-exports [Bytes64](namespaces/BrandedBytes64.mdx#bytes64)
***
### Bytes8
Re-exports [Bytes8](namespaces/BrandedBytes8.mdx#bytes8)
***
### CallTrace
Renames and re-exports [primitives/CallTrace](../primitives/CallTrace.mdx)
***
### ChaCha20Poly1305
Re-exports [ChaCha20Poly1305](../crypto/ChaCha20Poly1305.mdx#chacha20poly1305)
***
### Chain
Re-exports [Chain](namespaces/BrandedChain.mdx#chain-1)
***
### ChainHead
Renames and re-exports [primitives/ChainHead](../primitives/ChainHead.mdx)
***
### CompilerVersion
Renames and re-exports [primitives/CompilerVersion](../primitives/CompilerVersion.mdx)
***
### ContractCode
Renames and re-exports [primitives/ContractCode](../primitives/ContractCode.mdx)
***
### ContractResult
Renames and re-exports [primitives/ContractResult](../primitives/ContractResult.mdx)
***
### ContractSignature
Renames and re-exports [primitives/ContractSignature](../primitives/ContractSignature.mdx)
***
### DecodedData
Renames and re-exports [primitives/DecodedData](../primitives/DecodedData.mdx)
***
### Domain
Renames and re-exports [primitives/Domain](../primitives/Domain.mdx)
***
### DomainSeparator
Renames and re-exports [primitives/DomainSeparator](../primitives/DomainSeparator.mdx)
***
### Ed25519
Re-exports [Ed25519](../crypto/Ed25519.mdx#ed25519)
***
### EIP712
Re-exports [EIP712](../crypto/EIP712.mdx#eip712)
***
### EncodedData
Renames and re-exports [primitives/EncodedData](../primitives/EncodedData.mdx)
***
### Ens
Renames and re-exports [primitives/Ens](../primitives/Ens.mdx)
***
### Epoch
Renames and re-exports [primitives/Epoch](../primitives/Epoch.mdx)
***
### ErrorSignature
Renames and re-exports [primitives/ErrorSignature](../primitives/ErrorSignature.mdx)
***
### EventLog
Renames and re-exports [primitives/EventLog](../primitives/EventLog.mdx)
***
### EventSignature
Renames and re-exports [primitives/EventSignature](../primitives/EventSignature.mdx)
***
### evm
Re-exports [evm](../evm/index.mdx)
***
### FilterId
Renames and re-exports [primitives/FilterId](../primitives/FilterId.mdx)
***
### ForkId
Renames and re-exports [primitives/ForkId](../primitives/ForkId.mdx)
***
### FunctionSignature
Renames and re-exports [primitives/FunctionSignature](../primitives/FunctionSignature.mdx)
***
### Gas
Renames and re-exports [primitives/Gas](../primitives/Gas.mdx)
***
### GasConstants
Renames and re-exports [primitives/GasConstants](../primitives/GasConstants/index.mdx)
***
### GasCosts
Re-exports [GasCosts](../GasCosts.mdx)
***
### GasEstimate
Renames and re-exports [primitives/GasEstimate](../primitives/GasEstimate.mdx)
***
### GasRefund
Renames and re-exports [primitives/GasRefund](../primitives/GasRefund.mdx)
***
### GasUsed
Renames and re-exports [primitives/GasUsed](../primitives/GasUsed.mdx)
***
### Hardfork
Renames and re-exports [primitives/Hardfork](../primitives/Hardfork.mdx)
***
### HDWallet
Re-exports [HDWallet](../HDWallet.mdx)
***
### InitCode
Renames and re-exports [primitives/InitCode](../primitives/InitCode.mdx)
***
### Keccak256
Re-exports [Keccak256](../crypto/Keccak256.mdx#keccak256)
***
### Keccak256HashType
Renames and re-exports [Keccak256Hash](#keccak256hash)
***
### Keystore
Renames and re-exports [crypto/Keystore](../crypto/Keystore.mdx)
***
### KzgBlobType
Renames and re-exports [BlobType](../crypto/KZG.mdx#blobtype)
***
### KzgCommitmentType
Re-exports [KzgCommitmentType](../crypto/KZG.mdx#kzgcommitmenttype)
***
### KzgProofType
Re-exports [KzgProofType](../crypto/KZG.mdx#kzgprooftype)
***
### License
Renames and re-exports [primitives/License](../primitives/License.mdx)
***
### LogFilter
Renames and re-exports [primitives/LogFilter](../primitives/LogFilter.mdx)
***
### LogIndex
Renames and re-exports [primitives/LogIndex](../primitives/LogIndex.mdx)
***
### MemoryDump
Renames and re-exports [primitives/MemoryDump](../primitives/MemoryDump.mdx)
***
### Metadata
Renames and re-exports [primitives/Metadata](../primitives/Metadata.mdx)
***
### ModExp
Re-exports [ModExp](../crypto/ModExp.mdx#modexp)
***
### NetworkId
Renames and re-exports [primitives/NetworkId](../primitives/NetworkId.mdx)
***
### NodeInfo
Renames and re-exports [primitives/NodeInfo](../primitives/NodeInfo.mdx)
***
### OpStep
Renames and re-exports [primitives/OpStep](../primitives/OpStep.mdx)
***
### P256
Re-exports [P256](../crypto/P256.mdx#p256)
***
### PeerId
Renames and re-exports [primitives/PeerId](../primitives/PeerId.mdx)
***
### PeerInfo
Renames and re-exports [primitives/PeerInfo](../primitives/PeerInfo.mdx)
***
### PendingTransactionFilter
Renames and re-exports [primitives/PendingTransactionFilter](../primitives/PendingTransactionFilter.mdx)
***
### Permit
Renames and re-exports [primitives/Permit](../primitives/Permit/index.mdx)
***
### ProtocolVersion
Renames and re-exports [primitives/ProtocolVersion](../primitives/ProtocolVersion.mdx)
***
### Proxy
Re-exports [Proxy](../Proxy.mdx)
***
### Receipt
Renames and re-exports [primitives/Receipt](../primitives/Receipt.mdx)
***
### ReturnData
Renames and re-exports [primitives/ReturnData](../primitives/ReturnData.mdx)
***
### RevertReason
Renames and re-exports [primitives/RevertReason](../primitives/RevertReason.mdx)
***
### Ripemd160
Re-exports [Ripemd160](../crypto/Ripemd160.mdx#ripemd160)
***
### Ripemd160HashType
Renames and re-exports [Ripemd160Hash](#ripemd160hash)
***
### Rlp
Re-exports [Rlp](../primitives/Rlp.mdx#rlp)
***
### RuntimeCode
Renames and re-exports [primitives/RuntimeCode](../primitives/RuntimeCode.mdx)
***
### Secp256k1
Re-exports [Secp256k1](../crypto/Secp256k1.mdx#secp256k1)
***
### Selector
Renames and re-exports [primitives/Selector](../primitives/Selector.mdx)
***
### SHA256
Re-exports [SHA256](../crypto/SHA256.mdx#sha256)
***
### SHA256HashType
Renames and re-exports [SHA256Hash](#sha256hash)
***
### SignedData
Renames and re-exports [primitives/SignedData](../primitives/SignedData.mdx)
***
### Siwe
Re-exports [Siwe](../primitives/Siwe.mdx#siwe)
***
### Slot
Renames and re-exports [primitives/Slot](../primitives/Slot.mdx)
***
### SourceMap
Renames and re-exports [primitives/SourceMap](../primitives/SourceMap.mdx)
***
### Ssz
Re-exports [Ssz](../Ssz.mdx)
***
### State
Renames and re-exports [primitives/State](../primitives/State.mdx)
***
### StateDiff
Renames and re-exports [primitives/StateDiff](../primitives/StateDiff.mdx)
***
### StealthAddress
Renames and re-exports [primitives/StealthAddress](../primitives/StealthAddress.mdx)
***
### Storage
Re-exports [Storage](../Storage.mdx)
***
### StorageDiff
Renames and re-exports [primitives/StorageDiff](../primitives/StorageDiff.mdx)
***
### StorageKey
Re-exports [StorageKey](../primitives/State.mdx#storagekey)
***
### StructLog
Renames and re-exports [primitives/StructLog](../primitives/StructLog.mdx)
***
### SyncStatus
Renames and re-exports [primitives/SyncStatus](../primitives/SyncStatus.mdx)
***
### TopicFilter
Renames and re-exports [primitives/TopicFilter](../primitives/TopicFilter.mdx)
***
### TraceConfig
Renames and re-exports [primitives/TraceConfig](../primitives/TraceConfig.mdx)
***
### TraceResult
Renames and re-exports [primitives/TraceResult](../primitives/TraceResult.mdx)
***
### Transaction
Renames and re-exports [primitives/Transaction](../primitives/Transaction/index.mdx)
***
### TransactionHash
Renames and re-exports [primitives/TransactionHash](../primitives/TransactionHash.mdx)
***
### TransactionIndex
Renames and re-exports [primitives/TransactionIndex](../primitives/TransactionIndex.mdx)
***
### TransactionStatus
Renames and re-exports [primitives/TransactionStatus](../primitives/TransactionStatus.mdx)
***
### TransactionUrl
Re-exports [TransactionUrl](../TransactionUrl.mdx)
***
### TypedData
Renames and re-exports [primitives/TypedData](../primitives/TypedData.mdx)
***
### Uint256
Renames and re-exports [primitives/Uint](../primitives/Uint.mdx)
***
### Uncle
Renames and re-exports [primitives/Uncle](../primitives/Uncle.mdx)
***
### ValidatorIndex
Renames and re-exports [primitives/ValidatorIndex](../primitives/ValidatorIndex.mdx)
***
### Withdrawal
Renames and re-exports [primitives/Withdrawal](../primitives/Withdrawal.mdx)
***
### WithdrawalIndex
Renames and re-exports [primitives/WithdrawalIndex](../primitives/WithdrawalIndex.mdx)
***
### X25519
Re-exports [X25519](../crypto/X25519.mdx#x25519)
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedAddress/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [index](../../index.mdx) / BrandedAddress
# BrandedAddress
## Namespaces
* [Checksummed](namespaces/Checksummed.mdx)
* [Lowercase](namespaces/Lowercase.mdx)
* [Uppercase](namespaces/Uppercase.mdx)
## Variables
### BrandedAddress
> `const` **BrandedAddress**: `object`
Defined in: [src/primitives/Address/internal-index.ts:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L156)
#### Type Declaration
##### assert()
> **assert**: (`value`, `options?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype) = `assertWithKeccak`
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### options?
###### strict?
`boolean`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Assert()
> **Assert**: (`deps`) => (`value`, `options?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Factory: Create assert function with keccak256 injected
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
###### Returns
> (`value`, `options?`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### options?
###### strict?
`boolean`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### calculateCreate2Address()
> **calculateCreate2Address**: (`arg0`, `arg1`, `arg2`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Calculate CREATE2 contract address (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `CalculateCreate2Address({ keccak256 })` factory
###### Parameters
###### arg0
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### arg1
[`HashType`](../HashType.mdx#hashtype)
###### arg2
`BrandedBytecode`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### CalculateCreate2Address()
> **CalculateCreate2Address**: (`deps`) => (`arg0`, `arg1`, `arg2`) => [`AddressType`](../../../primitives/Address.mdx#addresstype) = `CalculateCreate2AddressFactory`
Factory function to create calculateCreate2Address with injected keccak256 dependency
###### Parameters
###### deps
Dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
> (`arg0`, `arg1`, `arg2`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### arg0
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### arg1
[`HashType`](../HashType.mdx#hashtype)
###### arg2
`BrandedBytecode`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### calculateCreateAddress()
> **calculateCreateAddress**: (`address`, `nonce`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Calculate CREATE contract address (with auto-injected keccak256 and rlpEncode)
For tree-shakeable version without auto-injected crypto, use `CalculateCreateAddress({ keccak256, rlpEncode })` factory
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### nonce
`bigint`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### CalculateCreateAddress()
> **CalculateCreateAddress**: (`deps`) => (`address`, `nonce`) => [`AddressType`](../../../primitives/Address.mdx#addresstype) = `CalculateCreateAddressFactory`
Factory for CREATE contract address calculation with injected dependencies
###### Parameters
###### deps
Dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`items`) => `Uint8Array`
RLP encode function
###### Returns
> (`address`, `nonce`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### nonce
`bigint`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Example
```typescript theme={null}
import { hash } from '../../../crypto/Keccak256/hash.js'
import { encode } from '../../Rlp/encode.js'
const calculateCreateAddress = CalculateCreateAddress({
keccak256: hash,
rlpEncode: encode
})
const contractAddr = calculateCreateAddress(deployerAddr, 5n);
```
##### Checksummed
> **Checksummed**: [`Checksummed`](namespaces/Checksummed.mdx)
##### clone()
> **clone**: (`address`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create a deep copy of an Address
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to clone
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Deep copy
###### Example
```typescript theme={null}
const addr1 = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const addr2 = Address.clone(addr1);
console.log(Address.equals(addr1, addr2)); // true
console.log(addr1 === addr2); // false
```
##### compare()
> **compare**: (`address`, `other`) => `number`
Compare two addresses lexicographically
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
###### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
###### Returns
`number`
-1 if address \< other, 0 if equal, 1 if address > other
###### Example
```typescript theme={null}
const sorted = addresses.sort((a, b) => Address.compare(a, b));
```
##### deduplicateAddresses()
> **deduplicateAddresses**: (`addresses`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Remove duplicate addresses from array
Preserves first occurrence of each unique address
###### Parameters
###### addresses
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Addresses to deduplicate
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Deduplicated addresses (new array)
###### Example
```typescript theme={null}
const unique = Address.deduplicateAddresses([addr1, addr2, addr1, addr3]);
// Returns [addr1, addr2, addr3]
```
##### equals()
> **equals**: (`address`, `other`) => `boolean`
Check if two addresses are equal
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
###### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
###### Returns
`boolean`
True if addresses are identical
###### Example
```typescript theme={null}
if (Address.equals(addr1, addr2)) {
console.log("Addresses match");
}
```
##### from()
> **from**: (`value`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from various input types (universal constructor)
###### Parameters
###### value
Number, bigint, hex string, Uint8Array, or number array
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
###### Throws
If value type is unsupported or invalid
###### Throws
If hex string is invalid
###### Throws
If bytes length is not 20
###### Example
```typescript theme={null}
const addr1 = Address.from(0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n);
const addr2 = Address.from(12345);
const _addr3 = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const addr4 = Address.from(new Uint8Array(20));
const addr5 = Address.from([0x74, 0x2d, 0x35, ...]);
```
##### fromAbiEncoded()
> **fromAbiEncoded**: (`bytes`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Decode Address from ABI-encoded bytes (32 bytes)
Extracts the last 20 bytes from 32-byte ABI-encoded address data.
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
32-byte ABI-encoded data
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Decoded Address
###### Throws
If bytes length is not 32
###### Example
```typescript theme={null}
const encoded = new Uint8Array(32);
// ... set encoded[12:32] to address bytes ...
const addr = Address.fromAbiEncoded(encoded);
```
##### fromBase64()
> **fromBase64**: (`b64`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from base64 string
###### Parameters
###### b64
`string`
Base64 encoded string
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
###### Throws
If decoded length is not 20 bytes
###### Example
```typescript theme={null}
const addr = Address.fromBase64("dC01zGY0wFMpJaO4RLyedZXyUeM=");
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from raw bytes (standard form)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw 20-byte array
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
###### Throws
If length is not 20 bytes
###### Example
```typescript theme={null}
const bytes = new Uint8Array(20);
const addr = Address.fromBytes(bytes);
```
##### fromHex()
> **fromHex**: (`hex`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Parse hex string to Address (standard form)
###### Parameters
###### hex
`string`
Hex string with 0x prefix
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address bytes
###### Throws
If invalid format or length
###### Throws
If hex contains invalid characters
###### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
##### fromNumber()
> **fromNumber**: (`value`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from number value (takes lower 160 bits) (standard form)
###### Parameters
###### value
Number or bigint value
`number` | `bigint`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address from lower 160 bits
###### Throws
If value is negative
###### Example
```typescript theme={null}
const addr = Address.fromNumber(0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n);
const addr2 = Address.fromNumber(12345);
```
##### fromPrivateKey()
> **fromPrivateKey**: (`privateKey`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from secp256k1 private key (with auto-injected crypto)
For tree-shakeable version without auto-injected crypto, use `FromPrivateKey({ keccak256, derivePublicKey })` factory
###### Parameters
###### privateKey
`any`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### FromPrivateKey()
> **FromPrivateKey**: (`deps`) => (`privateKey`) => [`AddressType`](../../../primitives/Address.mdx#addresstype) = `FromPrivateKeyFactory`
Factory: Create Address from secp256k1 private key
###### Parameters
###### deps
Crypto dependencies
###### derivePublicKey
(`privateKey`) => `Uint8Array`
Secp256k1 public key derivation function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that creates Address from private key
> (`privateKey`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### privateKey
`any`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Example
```typescript theme={null}
import { FromPrivateKey } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
import { derivePublicKey } from '@tevm/voltaire/crypto/Secp256k1'
const fromPrivateKey = FromPrivateKey({ keccak256, derivePublicKey })
const addr = fromPrivateKey(privateKey)
```
##### fromPublicKey()
> **fromPublicKey**: (`xOrPublicKey`, `y?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create Address from secp256k1 public key coordinates (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `FromPublicKey({ keccak256 })` factory
###### Parameters
###### xOrPublicKey
`bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### y?
`bigint`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### FromPublicKey()
> **FromPublicKey**: (`deps`) => (`xOrPublicKey`, `y?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype) = `FromPublicKeyFactory`
Factory: Create Address from secp256k1 public key
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that creates Address from public key
> (`xOrPublicKey`, `y?`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### xOrPublicKey
`bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### y?
`bigint`
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Example
```typescript theme={null}
import { FromPublicKey } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const fromPublicKey = FromPublicKey({ keccak256 })
// From coordinates
const addr1 = fromPublicKey(xCoord, yCoord)
// From 64-byte public key
const addr2 = fromPublicKey(publicKeyBytes)
```
##### greaterThan()
> **greaterThan**: (`address`, `other`) => `boolean`
Check if this address is greater than other
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
###### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
###### Returns
`boolean`
True if address > other
##### is()
> **is**: (`value`) => `value is AddressType`
Type guard for Address (standard form)
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is AddressType`
True if value is an Address
###### Example
```typescript theme={null}
if (Address.is(value)) {
const hex = Address.toHex(value);
}
```
##### isValid()
> **isValid**: (`value`) => `boolean`
Check if value is a valid address (accepts string, Uint8Array, or Address instance)
###### Parameters
###### value
Value to validate
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`boolean`
True if valid address format
###### Example
```typescript theme={null}
// Validate hex string
Address.isValid("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"); // true
// Validate Uint8Array (including Address instances)
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
Address.isValid(addr); // true
// Invalid cases
Address.isValid("0xinvalid"); // false
Address.isValid(new Uint8Array(10)); // false (wrong length)
```
##### isValidChecksum()
> **isValidChecksum**: (`str`) => `boolean`
Check if string has valid EIP-55 checksum (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `IsValidChecksum({ keccak256 })` factory
###### Parameters
###### str
`string`
###### Returns
`boolean`
##### IsValidChecksum()
> **IsValidChecksum**: (`deps`) => (`str`) => `boolean` = `IsValidChecksumFactory`
Factory: Check if string has valid EIP-55 checksum
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that validates EIP-55 checksum
> (`str`): `boolean`
###### Parameters
###### str
`string`
###### Returns
`boolean`
###### Example
```typescript theme={null}
import { IsValidChecksum } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const isValidChecksum = IsValidChecksum({ keccak256 })
if (isValidChecksum("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")) {
console.log("Valid checksum")
}
```
##### isZero()
> **isZero**: (`address`) => `boolean`
Check if address is zero address
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to check
###### Returns
`boolean`
True if all bytes are zero
###### Example
```typescript theme={null}
if (Address.isZero(addr)) {
console.log("Zero address");
}
```
##### lessThan()
> **lessThan**: (`address`, `other`) => `boolean`
Check if this address is less than other
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
###### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
###### Returns
`boolean`
True if address \< other
##### Lowercase
> **Lowercase**: [`Lowercase`](namespaces/Lowercase.mdx)
##### SIZE
> **SIZE**: `20`
Address size in bytes
##### sortAddresses()
> **sortAddresses**: (`addresses`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Sort addresses lexicographically
###### Parameters
###### addresses
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Addresses to sort
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Sorted addresses (new array)
###### Example
```typescript theme={null}
const sorted = Address.sortAddresses([addr3, addr1, addr2]);
```
##### toAbiEncoded()
> **toAbiEncoded**: (`address`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Address to ABI-encoded bytes (32 bytes, left-padded)
Ethereum ABI encoding pads addresses to 32 bytes by prepending 12 zero bytes.
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte ABI-encoded Uint8Array
###### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const encoded = Address.toAbiEncoded(addr);
// encoded.length === 32
```
##### toBytes()
> **toBytes**: (`address`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Address to Uint8Array
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Underlying Uint8Array
###### Example
```typescript theme={null}
const addr = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const bytes = Address.toBytes(addr);
console.log(bytes); // Uint8Array(20) [...]
```
##### toChecksummed()
> **toChecksummed**: (`address`) => [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
Convert Address to EIP-55 checksummed hex string (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `ToChecksummed({ keccak256 })` factory
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
[`Checksummed`](namespaces/Checksummed.mdx#checksummed)
##### ToChecksummed()
> **ToChecksummed**: (`deps`) => (`address`) => [`Checksummed`](namespaces/Checksummed.mdx#checksummed) = `ToChecksummedFactory`
Factory: Convert Address to EIP-55 checksummed hex string
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that converts Address to checksummed hex string
> (`address`): [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
[`Checksummed`](namespaces/Checksummed.mdx#checksummed)
###### Example
```typescript theme={null}
import { ToChecksummed } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const toChecksummed = ToChecksummed({ keccak256 })
const checksummed = toChecksummed(addr)
// "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
```
##### toHex()
> **toHex**: (`address`) => [`HexType`](../../../primitives/Hex.mdx#hextype)
Convert Address to hex string
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
###### Returns
[`HexType`](../../../primitives/Hex.mdx#hextype)
Lowercase hex string with 0x prefix
###### Example
```typescript theme={null}
const hex = Address.toHex(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
##### toLowercase()
> **toLowercase**: (`address`) => [`Lowercase`](namespaces/Lowercase.mdx#lowercase)
Convert Address to lowercase hex string
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
###### Returns
[`Lowercase`](namespaces/Lowercase.mdx#lowercase)
Lowercase hex string
###### Example
```typescript theme={null}
const lower = Address.toLowercase(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
##### toShortHex()
> **toShortHex**: (`address`, `prefixLength?`, `suffixLength?`) => `string`
Format address with shortened display
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to format
###### prefixLength?
`number`
Number of chars to show at start
###### suffixLength?
`number`
Number of chars to show at end
###### Returns
`string`
Shortened address like "0x742d...51e3"
###### Example
```typescript theme={null}
const short = Address.toShortHex(addr);
// "0x742d...51e3"
const custom = Address.toShortHex(addr, 8, 6);
// "0x742d35...251e3"
```
##### toU256()
> **toU256**: (`address`) => `bigint`
Convert Address to uint256
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
###### Returns
`bigint`
Bigint representation
###### Example
```typescript theme={null}
const value = Address.toU256(addr);
```
##### toUppercase()
> **toUppercase**: (`address`) => [`Uppercase`](namespaces/Uppercase.mdx#uppercase)
Convert Address to uppercase hex string
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
###### Returns
[`Uppercase`](namespaces/Uppercase.mdx#uppercase)
Uppercase hex string
###### Example
```typescript theme={null}
const upper = Address.toUppercase(addr);
// "0x742D35CC6634C0532925A3B844BC9E7595F251E3"
```
##### Uppercase
> **Uppercase**: [`Uppercase`](namespaces/Uppercase.mdx)
##### zero()
> **zero**: () => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Create zero address (standard form)
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Zero address (0x0000...0000)
###### Example
```typescript theme={null}
const zero = Address.zero();
```
***
### calculateCreate2Address()
> `const` **calculateCreate2Address**: (`arg0`, `arg1`, `arg2`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/internal-index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L61)
Calculate CREATE2 contract address (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `CalculateCreate2Address({ keccak256 })` factory
#### Parameters
##### arg0
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### arg1
[`HashType`](../HashType.mdx#hashtype)
##### arg2
`BrandedBytecode`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### calculateCreateAddress()
> `const` **calculateCreateAddress**: (`address`, `nonce`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/internal-index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L51)
Calculate CREATE contract address (with auto-injected keccak256 and rlpEncode)
For tree-shakeable version without auto-injected crypto, use `CalculateCreateAddress({ keccak256, rlpEncode })` factory
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### nonce
`bigint`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### fromPrivateKey()
> `const` **fromPrivateKey**: (`privateKey`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/internal-index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L77)
Create Address from secp256k1 private key (with auto-injected crypto)
For tree-shakeable version without auto-injected crypto, use `FromPrivateKey({ keccak256, derivePublicKey })` factory
#### Parameters
##### privateKey
`any`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### fromPublicKey()
> `const` **fromPublicKey**: (`xOrPublicKey`, `y?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/internal-index.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L70)
Create Address from secp256k1 public key coordinates (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `FromPublicKey({ keccak256 })` factory
#### Parameters
##### xOrPublicKey
`bigint` | `Uint8Array`\<`ArrayBufferLike`>
##### y?
`bigint`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### isValidChecksum()
> `const` **isValidChecksum**: (`str`) => `boolean`
Defined in: [src/primitives/Address/internal-index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L44)
Check if string has valid EIP-55 checksum (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `IsValidChecksum({ keccak256 })` factory
#### Parameters
##### str
`string`
#### Returns
`boolean`
***
### toChecksummed()
> `const` **toChecksummed**: (`address`) => [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
Defined in: [src/primitives/Address/internal-index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L37)
Convert Address to EIP-55 checksummed hex string (with auto-injected keccak256)
For tree-shakeable version without auto-injected crypto, use `ToChecksummed({ keccak256 })` factory
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
#### Returns
[`Checksummed`](namespaces/Checksummed.mdx#checksummed)
## Functions
### assert()
> **assert**(`value`, `options?`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/internal-index.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/internal-index.ts#L118)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### options?
###### strict?
`boolean`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### Assert()
> **Assert**(`deps`): (`value`, `options?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/assert.js:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/assert.js#L106)
Factory: Create assert function with keccak256 injected
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
#### Returns
> (`value`, `options?`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### options?
###### strict?
`boolean`
##### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### CalculateCreate2Address()
> **CalculateCreate2Address**(`deps`): (`arg0`, `arg1`, `arg2`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/calculateCreate2Address.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/calculateCreate2Address.js#L8)
Factory function to create calculateCreate2Address with injected keccak256 dependency
#### Parameters
##### deps
Dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
> (`arg0`, `arg1`, `arg2`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Parameters
###### arg0
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### arg1
[`HashType`](../HashType.mdx#hashtype)
###### arg2
`BrandedBytecode`
##### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
***
### CalculateCreateAddress()
> **CalculateCreateAddress**(`deps`): (`address`, `nonce`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/calculateCreateAddress.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/calculateCreateAddress.js#L51)
Factory for CREATE contract address calculation with injected dependencies
#### Parameters
##### deps
Dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`items`) => `Uint8Array`
RLP encode function
#### Returns
> (`address`, `nonce`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### nonce
`bigint`
##### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
#### Example
```typescript theme={null}
import { hash } from '../../../crypto/Keccak256/hash.js'
import { encode } from '../../Rlp/encode.js'
const calculateCreateAddress = CalculateCreateAddress({
keccak256: hash,
rlpEncode: encode
})
const contractAddr = calculateCreateAddress(deployerAddr, 5n);
```
***
### clone()
> **clone**(`address`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/clone.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/clone.js#L17)
Create a deep copy of an Address
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to clone
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Deep copy
#### Example
```typescript theme={null}
const addr1 = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const addr2 = Address.clone(addr1);
console.log(Address.equals(addr1, addr2)); // true
console.log(addr1 === addr2); // false
```
***
### compare()
> **compare**(`address`, `other`): `number`
Defined in: [src/primitives/Address/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/compare.js#L15)
Compare two addresses lexicographically
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
##### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
#### Returns
`number`
-1 if address \< other, 0 if equal, 1 if address > other
#### Example
```typescript theme={null}
const sorted = addresses.sort((a, b) => Address.compare(a, b));
```
***
### deduplicateAddresses()
> **deduplicateAddresses**(`addresses`): [`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Defined in: [src/primitives/Address/deduplicateAddresses.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/deduplicateAddresses.js#L16)
Remove duplicate addresses from array
Preserves first occurrence of each unique address
#### Parameters
##### addresses
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Addresses to deduplicate
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Deduplicated addresses (new array)
#### Example
```typescript theme={null}
const unique = Address.deduplicateAddresses([addr1, addr2, addr1, addr3]);
// Returns [addr1, addr2, addr3]
```
***
### equals()
> **equals**(`address`, `other`): `boolean`
Defined in: [src/primitives/Address/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/equals.js#L15)
Check if two addresses are equal
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
##### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
#### Returns
`boolean`
True if addresses are identical
#### Example
```typescript theme={null}
if (Address.equals(addr1, addr2)) {
console.log("Addresses match");
}
```
***
### from()
> **from**(`value`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/from.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/from.js#L24)
Create Address from various input types (universal constructor)
#### Parameters
##### value
Number, bigint, hex string, Uint8Array, or number array
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
#### Throws
If value type is unsupported or invalid
#### Throws
If hex string is invalid
#### Throws
If bytes length is not 20
#### Example
```typescript theme={null}
const addr1 = Address.from(0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n);
const addr2 = Address.from(12345);
const _addr3 = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const addr4 = Address.from(new Uint8Array(20));
const addr5 = Address.from([0x74, 0x2d, 0x35, ...]);
```
***
### From()
> **From**(`deps`): (`value`) => [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
Defined in: [src/primitives/Address/ChecksumAddress.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/ChecksumAddress.js#L27)
Factory: Create checksummed address from any input
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that converts to checksummed address
> (`value`): [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
##### Parameters
###### value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
##### Returns
[`Checksummed`](namespaces/Checksummed.mdx#checksummed)
#### Example
```typescript theme={null}
import { From } from '@tevm/voltaire/Address/ChecksumAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const from = From({ keccak256 })
const checksummed = from("0x742d35cc6634c0532925a3b844bc9e7595f251e3")
// "0x742d35Cc6634c0532925a3b844bc9e7595F251E3"
```
***
### fromAbiEncoded()
> **fromAbiEncoded**(`bytes`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromAbiEncoded.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromAbiEncoded.js#L17)
Decode Address from ABI-encoded bytes (32 bytes)
Extracts the last 20 bytes from 32-byte ABI-encoded address data.
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
32-byte ABI-encoded data
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Decoded Address
#### Throws
If bytes length is not 32
#### Example
```typescript theme={null}
const encoded = new Uint8Array(32);
// ... set encoded[12:32] to address bytes ...
const addr = Address.fromAbiEncoded(encoded);
```
***
### fromBase64()
> **fromBase64**(`b64`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromBase64.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromBase64.js#L16)
Create Address from base64 string
#### Parameters
##### b64
`string`
Base64 encoded string
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
#### Throws
If decoded length is not 20 bytes
#### Example
```typescript theme={null}
const addr = Address.fromBase64("dC01zGY0wFMpJaO4RLyedZXyUeM=");
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromBytes.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromBytes.js#L17)
Create Address from raw bytes (standard form)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw 20-byte array
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address
#### Throws
If length is not 20 bytes
#### Example
```typescript theme={null}
const bytes = new Uint8Array(20);
const addr = Address.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromHex.js#L19)
Parse hex string to Address (standard form)
#### Parameters
##### hex
`string`
Hex string with 0x prefix
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address bytes
#### Throws
If invalid format or length
#### Throws
If hex contains invalid characters
#### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
***
### fromNumber()
> **fromNumber**(`value`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromNumber.js#L17)
Create Address from number value (takes lower 160 bits) (standard form)
#### Parameters
##### value
Number or bigint value
`number` | `bigint`
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address from lower 160 bits
#### Throws
If value is negative
#### Example
```typescript theme={null}
const addr = Address.fromNumber(0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n);
const addr2 = Address.fromNumber(12345);
```
***
### FromPrivateKey()
> **FromPrivateKey**(`deps`): (`privateKey`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromPrivateKey.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromPrivateKey.js#L23)
Factory: Create Address from secp256k1 private key
#### Parameters
##### deps
Crypto dependencies
###### derivePublicKey
(`privateKey`) => `Uint8Array`
Secp256k1 public key derivation function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that creates Address from private key
> (`privateKey`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Parameters
###### privateKey
`any`
##### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
#### Example
```typescript theme={null}
import { FromPrivateKey } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
import { derivePublicKey } from '@tevm/voltaire/crypto/Secp256k1'
const fromPrivateKey = FromPrivateKey({ keccak256, derivePublicKey })
const addr = fromPrivateKey(privateKey)
```
***
### FromPublicKey()
> **FromPublicKey**(`deps`): (`xOrPublicKey`, `y?`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/fromPublicKey.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/fromPublicKey.js#L20)
Factory: Create Address from secp256k1 public key
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that creates Address from public key
> (`xOrPublicKey`, `y?`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Parameters
###### xOrPublicKey
`bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### y?
`bigint`
##### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
#### Example
```typescript theme={null}
import { FromPublicKey } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const fromPublicKey = FromPublicKey({ keccak256 })
// From coordinates
const addr1 = fromPublicKey(xCoord, yCoord)
// From 64-byte public key
const addr2 = fromPublicKey(publicKeyBytes)
```
***
### greaterThan()
> **greaterThan**(`address`, `other`): `boolean`
Defined in: [src/primitives/Address/greaterThan.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/greaterThan.js#L10)
Check if this address is greater than other
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
##### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
#### Returns
`boolean`
True if address > other
***
### is()
> **is**(`value`): `value is AddressType`
Defined in: [src/primitives/Address/is.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/is.js#L16)
Type guard for Address (standard form)
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is AddressType`
True if value is an Address
#### Example
```typescript theme={null}
if (Address.is(value)) {
const hex = Address.toHex(value);
}
```
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Address/isValid.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/isValid.js#L21)
Check if value is a valid address (accepts string, Uint8Array, or Address instance)
#### Parameters
##### value
Value to validate
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
True if valid address format
#### Example
```typescript theme={null}
// Validate hex string
Address.isValid("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"); // true
// Validate Uint8Array (including Address instances)
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
Address.isValid(addr); // true
// Invalid cases
Address.isValid("0xinvalid"); // false
Address.isValid(new Uint8Array(10)); // false (wrong length)
```
***
### IsValid()
> **IsValid**(`deps`): (`str`) => `boolean`
Defined in: [src/primitives/Address/ChecksumAddress.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/ChecksumAddress.js#L74)
Factory: Check if string has valid EIP-55 checksum
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that validates EIP-55 checksum
> (`str`): `boolean`
##### Parameters
###### str
`string`
##### Returns
`boolean`
#### Example
```typescript theme={null}
import { IsValid } from '@tevm/voltaire/Address/ChecksumAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const isValid = IsValid({ keccak256 })
if (isValid("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")) {
console.log("Valid checksum")
}
```
***
### IsValidChecksum()
> **IsValidChecksum**(`deps`): (`str`) => `boolean`
Defined in: [src/primitives/Address/isValidChecksum.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/isValidChecksum.js#L21)
Factory: Check if string has valid EIP-55 checksum
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that validates EIP-55 checksum
> (`str`): `boolean`
##### Parameters
###### str
`string`
##### Returns
`boolean`
#### Example
```typescript theme={null}
import { IsValidChecksum } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const isValidChecksum = IsValidChecksum({ keccak256 })
if (isValidChecksum("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")) {
console.log("Valid checksum")
}
```
***
### isZero()
> **isZero**(`address`): `boolean`
Defined in: [src/primitives/Address/isZero.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/isZero.js#L14)
Check if address is zero address
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to check
#### Returns
`boolean`
True if all bytes are zero
#### Example
```typescript theme={null}
if (Address.isZero(addr)) {
console.log("Zero address");
}
```
***
### lessThan()
> **lessThan**(`address`, `other`): `boolean`
Defined in: [src/primitives/Address/lessThan.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/lessThan.js#L10)
Check if this address is less than other
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
First address
##### other
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to compare with
#### Returns
`boolean`
True if address \< other
***
### sortAddresses()
> **sortAddresses**(`addresses`): [`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Defined in: [src/primitives/Address/sortAddresses.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/sortAddresses.js#L14)
Sort addresses lexicographically
#### Parameters
##### addresses
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Addresses to sort
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)\[]
Sorted addresses (new array)
#### Example
```typescript theme={null}
const sorted = Address.sortAddresses([addr3, addr1, addr2]);
```
***
### toAbiEncoded()
> **toAbiEncoded**(`address`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Address/toAbiEncoded.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toAbiEncoded.js#L16)
Convert Address to ABI-encoded bytes (32 bytes, left-padded)
Ethereum ABI encoding pads addresses to 32 bytes by prepending 12 zero bytes.
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte ABI-encoded Uint8Array
#### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const encoded = Address.toAbiEncoded(addr);
// encoded.length === 32
```
***
### toBytes()
> **toBytes**(`address`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Address/toBytes.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toBytes.js#L14)
Convert Address to Uint8Array
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Underlying Uint8Array
#### Example
```typescript theme={null}
const addr = Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const bytes = Address.toBytes(addr);
console.log(bytes); // Uint8Array(20) [...]
```
***
### ToChecksummed()
> **ToChecksummed**(`deps`): (`address`) => [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
Defined in: [src/primitives/Address/toChecksummed.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toChecksummed.js#L20)
Factory: Convert Address to EIP-55 checksummed hex string
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that converts Address to checksummed hex string
> (`address`): [`Checksummed`](namespaces/Checksummed.mdx#checksummed)
##### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### Returns
[`Checksummed`](namespaces/Checksummed.mdx#checksummed)
#### Example
```typescript theme={null}
import { ToChecksummed } from '@tevm/voltaire/Address/BrandedAddress'
import { hash as keccak256 } from '@tevm/voltaire/crypto/Keccak256'
const toChecksummed = ToChecksummed({ keccak256 })
const checksummed = toChecksummed(addr)
// "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
```
***
### toHex()
> **toHex**(`address`): [`HexType`](../../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Address/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toHex.js#L13)
Convert Address to hex string
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
#### Returns
[`HexType`](../../../primitives/Hex.mdx#hextype)
Lowercase hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = Address.toHex(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
***
### toLowercase()
> **toLowercase**(`address`): [`Lowercase`](namespaces/Lowercase.mdx#lowercase)
Defined in: [src/primitives/Address/toLowercase.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toLowercase.js#L15)
Convert Address to lowercase hex string
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
#### Returns
[`Lowercase`](namespaces/Lowercase.mdx#lowercase)
Lowercase hex string
#### Example
```typescript theme={null}
const lower = Address.toLowercase(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
***
### toShortHex()
> **toShortHex**(`address`, `prefixLength?`, `suffixLength?`): `string`
Defined in: [src/primitives/Address/toShortHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toShortHex.js#L19)
Format address with shortened display
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to format
##### prefixLength?
`number`
Number of chars to show at start
##### suffixLength?
`number`
Number of chars to show at end
#### Returns
`string`
Shortened address like "0x742d...51e3"
#### Example
```typescript theme={null}
const short = Address.toShortHex(addr);
// "0x742d...51e3"
const custom = Address.toShortHex(addr, 8, 6);
// "0x742d35...251e3"
```
***
### toU256()
> **toU256**(`address`): `bigint`
Defined in: [src/primitives/Address/toU256.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toU256.js#L14)
Convert Address to uint256
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
#### Returns
`bigint`
Bigint representation
#### Example
```typescript theme={null}
const value = Address.toU256(addr);
```
***
### toUppercase()
> **toUppercase**(`address`): [`Uppercase`](namespaces/Uppercase.mdx#uppercase)
Defined in: [src/primitives/Address/toUppercase.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/toUppercase.js#L15)
Convert Address to uppercase hex string
#### Parameters
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to convert
#### Returns
[`Uppercase`](namespaces/Uppercase.mdx#uppercase)
Uppercase hex string
#### Example
```typescript theme={null}
const upper = Address.toUppercase(addr);
// "0x742D35CC6634C0532925A3B844BC9E7595F251E3"
```
***
### zero()
> **zero**(): [`AddressType`](../../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Address/zero.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/zero.js#L13)
Create zero address (standard form)
#### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Zero address (0x0000...0000)
#### Example
```typescript theme={null}
const zero = Address.zero();
```
## References
### AddressType
Re-exports [AddressType](../../../primitives/Address.mdx#addresstype)
***
### BrandedAddressType
Renames and re-exports [AddressType](../../../primitives/Address.mdx#addresstype)
***
### HEX\_SIZE
Re-exports [HEX\_SIZE](../../../primitives/Address.mdx#hex_size)
***
### InvalidAddressError
Re-exports [InvalidAddressError](../../../primitives/Address.mdx#invalidaddresserror)
***
### InvalidAddressLengthError
Re-exports [InvalidAddressLengthError](../../../primitives/Address.mdx#invalidaddresslengtherror)
***
### InvalidChecksumError
Re-exports [InvalidChecksumError](../../../primitives/Address.mdx#invalidchecksumerror)
***
### InvalidHexFormatError
Re-exports [InvalidHexFormatError](../../../primitives/Address.mdx#invalidhexformaterror)
***
### InvalidHexStringError
Re-exports [InvalidHexStringError](../../../primitives/Address.mdx#invalidhexstringerror)
***
### InvalidValueError
Re-exports [InvalidValueError](../../../primitives/Address.mdx#invalidvalueerror)
***
### NATIVE\_ASSET\_ADDRESS
Re-exports [NATIVE\_ASSET\_ADDRESS](../../../primitives/Address.mdx#native_asset_address)
***
### NotImplementedError
Re-exports [NotImplementedError](../../../primitives/Address.mdx#notimplementederror)
***
### SIZE
Re-exports [SIZE](../../../primitives/Address.mdx#size)
# Checksummed
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedAddress/namespaces/Checksummed
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [BrandedAddress](../index.mdx) / Checksummed
# Checksummed
## Type Aliases
### Checksummed
> **Checksummed**\<> = [`HexType`](../../../../primitives/Hex.mdx#hextype) & `object`
Defined in: [src/primitives/Address/ChecksumAddress.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/ChecksumAddress.js#L7)
#### Type Declaration
##### \_\_checksummed
> `readonly` **\_\_checksummed**: `true`
##### \_\_variant
> `readonly` **\_\_variant**: `"Address"`
#### Type Parameters
## References
### From
Re-exports [From](../index.mdx#from-4)
***
### IsValid
Re-exports [IsValid](../index.mdx#isvalid-4)
# Lowercase
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedAddress/namespaces/Lowercase
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [BrandedAddress](../index.mdx) / Lowercase
# Lowercase
## Type Aliases
### Lowercase
> **Lowercase**\<> = [`HexType`](../../../../primitives/Hex.mdx#hextype) & `object`
Defined in: [src/primitives/Address/LowercaseAddress.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/LowercaseAddress.js#L4)
#### Type Declaration
##### \_\_lowercase
> `readonly` **\_\_lowercase**: `true`
##### \_\_variant
> `readonly` **\_\_variant**: `"Address"`
#### Type Parameters
## Functions
### from()
> **from**(`addr`): [`Lowercase`](#lowercase)
Defined in: [src/primitives/Address/LowercaseAddress.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/LowercaseAddress.js#L20)
Create lowercase address hex string from Address
#### Parameters
##### addr
[`AddressType`](../../../../primitives/Address.mdx#addresstype)
Address to format
#### Returns
[`Lowercase`](#lowercase)
Lowercase address hex string
#### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const lower = Lowercase.from(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
# Uppercase
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedAddress/namespaces/Uppercase
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [BrandedAddress](../index.mdx) / Uppercase
# Uppercase
## Type Aliases
### Uppercase
> **Uppercase**\<> = [`HexType`](../../../../primitives/Hex.mdx#hextype) & `object`
Defined in: [src/primitives/Address/UppercaseAddress.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/UppercaseAddress.js#L4)
#### Type Declaration
##### \_\_uppercase
> `readonly` **\_\_uppercase**: `true`
##### \_\_variant
> `readonly` **\_\_variant**: `"Address"`
#### Type Parameters
## Functions
### from()
> **from**(`addr`): [`Uppercase`](#uppercase)
Defined in: [src/primitives/Address/UppercaseAddress.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/UppercaseAddress.js#L20)
Create uppercase address hex string from Address
#### Parameters
##### addr
[`AddressType`](../../../../primitives/Address.mdx#addresstype)
Address to format
#### Returns
[`Uppercase`](#uppercase)
Uppercase address hex string
#### Example
```typescript theme={null}
const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
const upper = Uppercase.from(addr);
// "0x742D35CC6634C0532925A3B844BC9E7595F251E3"
```
# BrandedBase64
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBase64
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBase64
# BrandedBase64
## Functions
### calcDecodedSize()
> **calcDecodedSize**(`encodedLength`): `number`
Defined in: [src/primitives/Base64/calcDecodedSize.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/calcDecodedSize.js#L7)
Calculate decoded size in bytes
#### Parameters
##### encodedLength
`number`
Length of base64 string
#### Returns
`number`
Maximum size of decoded output
***
### calcEncodedSize()
> **calcEncodedSize**(`dataLength`): `number`
Defined in: [src/primitives/Base64/calcEncodedSize.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/calcEncodedSize.js#L7)
Calculate encoded size in bytes
#### Parameters
##### dataLength
`number`
Length of data to encode
#### Returns
`number`
Size of base64 output
***
### decode()
> **decode**(`encoded`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/decode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decode.js#L19)
Decode standard base64 string to bytes
#### Parameters
##### encoded
`string`
Base64 string to decode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### See
[https://voltaire.tevm.sh/primitives/base64](https://voltaire.tevm.sh/primitives/base64) for Base64 documentation
#### Since
0.0.0
#### Throws
If input is invalid base64
#### Example
```javascript theme={null}
import * as Base64 from './primitives/Base64/index.js';
const decoded = Base64.decode('SGVsbG8=');
// Uint8Array([72, 101, 108, 108, 111])
```
***
### decodeToString()
> **decodeToString**(`encoded`): `string`
Defined in: [src/primitives/Base64/decodeToString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeToString.js#L15)
Decode base64 string to UTF-8 string
#### Parameters
##### encoded
`string`
Base64 string
#### Returns
`string`
Decoded string
#### Example
```typescript theme={null}
const str = Base64.decodeToString('SGVsbG8=');
// "Hello"
```
***
### decodeUrlSafe()
> **decodeUrlSafe**(`encoded`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/decodeUrlSafe.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeUrlSafe.js#L10)
Decode URL-safe base64 string to bytes
#### Parameters
##### encoded
`string`
URL-safe base64 string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Throws
If input is invalid
***
### decodeUrlSafeToString()
> **decodeUrlSafeToString**(`encoded`): `string`
Defined in: [src/primitives/Base64/decodeUrlSafeToString.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeUrlSafeToString.js#L9)
Decode URL-safe base64 to UTF-8 string
#### Parameters
##### encoded
`string`
URL-safe base64 string
#### Returns
`string`
Decoded string
***
### encode()
> **encode**(`data`): [`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Defined in: [src/primitives/Base64/encode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encode.js#L19)
Encode bytes to standard base64 string
Uses standard base64 alphabet (A-Z, a-z, 0-9, +, /)
with padding (=)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
#### Returns
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Base64-encoded string
#### Example
```typescript theme={null}
const data = new Uint8Array([72, 101, 108, 108, 111]);
const encoded = Base64.encode(data);
// "SGVsbG8="
```
***
### encodeString()
> **encodeString**(`str`): `string`
Defined in: [src/primitives/Base64/encodeString.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeString.js#L14)
Encode string to base64
#### Parameters
##### str
`string`
String to encode (UTF-8)
#### Returns
`string`
Base64-encoded string
#### Example
```typescript theme={null}
const encoded = Base64.encodeString('Hello, world!');
```
***
### encodeStringUrlSafe()
> **encodeStringUrlSafe**(`str`): [`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Defined in: [src/primitives/Base64/encodeStringUrlSafe.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeStringUrlSafe.js#L9)
Encode string to URL-safe base64
#### Parameters
##### str
`string`
String to encode (UTF-8)
#### Returns
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
URL-safe base64 string
***
### encodeUrlSafe()
> **encodeUrlSafe**(`data`): [`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Defined in: [src/primitives/Base64/encodeUrlSafe.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeUrlSafe.js#L19)
Encode bytes to URL-safe base64 string
Uses URL-safe alphabet (A-Z, a-z, 0-9, -, \_)
without padding
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
#### Returns
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
URL-safe base64 string
#### Example
```typescript theme={null}
const data = new Uint8Array([255, 254, 253]);
const encoded = Base64.encodeUrlSafe(data);
// No padding, uses - and _ instead of + and /
```
***
### from()
> **from**(`value`): [`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Defined in: [src/primitives/Base64/from.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/from.js#L21)
Convert input to BrandedBase64
#### Parameters
##### value
[`Base64Like`](../../primitives/Base64.mdx#base64like)
Input to convert
#### Returns
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Branded Base64 string
#### Throws
If input cannot be converted to valid Base64
#### Example
```typescript theme={null}
// From string
const b64 = Base64.from("SGVsbG8=");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64 = Base64.from(data);
```
***
### fromUrlSafe()
> **fromUrlSafe**(`value`): [`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Defined in: [src/primitives/Base64/fromUrlSafe.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/fromUrlSafe.js#L21)
Convert input to BrandedBase64Url
#### Parameters
##### value
[`Base64UrlLike`](../../primitives/Base64.mdx#base64urllike)
Input to convert
#### Returns
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Branded Base64Url string
#### Throws
If input cannot be converted to valid Base64Url
#### Example
```typescript theme={null}
// From string
const b64url = Base64.fromUrlSafe("SGVsbG8");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64url = Base64.fromUrlSafe(data);
```
***
### isValid()
> **isValid**(`str`): `boolean`
Defined in: [src/primitives/Base64/isValid.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/isValid.js#L7)
Check if string is valid base64
#### Parameters
##### str
`string`
String to validate
#### Returns
`boolean`
True if valid base64
***
### isValidUrlSafe()
> **isValidUrlSafe**(`str`): `boolean`
Defined in: [src/primitives/Base64/isValidUrlSafe.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/isValidUrlSafe.js#L7)
Check if string is valid URL-safe base64
#### Parameters
##### str
`string`
String to validate
#### Returns
`boolean`
True if valid URL-safe base64
***
### toBase64()
> **toBase64**(`value`): [`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Defined in: [src/primitives/Base64/toBase64.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBase64.js#L17)
Convert BrandedBase64Url to BrandedBase64
#### Parameters
##### value
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Base64Url string
#### Returns
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Base64 string
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const b64 = Base64.toBase64(b64url);
// "SGVsbG8=" (with padding)
```
***
### toBase64Url()
> **toBase64Url**(`value`): [`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Defined in: [src/primitives/Base64/toBase64Url.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBase64Url.js#L17)
Convert BrandedBase64 to BrandedBase64Url
#### Parameters
##### value
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Base64 string
#### Returns
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Base64Url string
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const b64url = Base64.toBase64Url(b64);
// "SGVsbG8" (no padding, URL-safe)
```
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/toBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBytes.js#L16)
Convert BrandedBase64 to bytes
#### Parameters
##### value
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Base64 string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const bytes = Base64.toBytes(b64);
// Uint8Array([72, 101, 108, 108, 111])
```
***
### toBytesUrlSafe()
> **toBytesUrlSafe**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/toBytesUrlSafe.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBytesUrlSafe.js#L16)
Convert BrandedBase64Url to bytes
#### Parameters
##### value
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Base64Url string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const bytes = Base64.toBytesUrlSafe(b64url);
// Uint8Array([72, 101, 108, 108, 111])
```
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Base64/toString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toString.js#L15)
Convert BrandedBase64 to plain string (strip branding)
#### Parameters
##### value
[`BrandedBase64`](../../primitives/Base64.mdx#brandedbase64)
Base64 string
#### Returns
`string`
Plain string
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const str = Base64.toString(b64);
// "SGVsbG8=" (plain string)
```
***
### toStringUrlSafe()
> **toStringUrlSafe**(`value`): `string`
Defined in: [src/primitives/Base64/toStringUrlSafe.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toStringUrlSafe.js#L14)
Convert BrandedBase64Url to plain string (strip branding)
#### Parameters
##### value
[`BrandedBase64Url`](../../primitives/Base64.mdx#brandedbase64url)
Base64Url string
#### Returns
`string`
Plain string
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const str = Base64.toStringUrlSafe(b64url);
// "SGVsbG8" (plain string)
```
## References
### Base64
Re-exports [Base64](../../primitives/Base64.mdx#base64)
# BrandedBytes
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes
# BrandedBytes
## Classes
### InvalidBytesFormatError
Defined in: [src/primitives/Bytes/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L13)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBytesFormatError**(`message`, `details?`): [`InvalidBytesFormatError`](#invalidbytesformaterror)
Defined in: [src/primitives/Bytes/errors.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L18)
###### Parameters
###### message
`string`
###### details?
`any`
###### Returns
[`InvalidBytesFormatError`](#invalidbytesformaterror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/Bytes/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L21)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes/errors.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L20)
###### Inherited from
`Error.name`
***
### InvalidBytesLengthError
Defined in: [src/primitives/Bytes/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBytesLengthError**(`message`, `details?`): [`InvalidBytesLengthError`](#invalidbyteslengtherror)
Defined in: [src/primitives/Bytes/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L6)
###### Parameters
###### message
`string`
###### details?
`any`
###### Returns
[`InvalidBytesLengthError`](#invalidbyteslengtherror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/Bytes/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L9)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L8)
###### Inherited from
`Error.name`
***
### InvalidValueError
Defined in: [src/primitives/Bytes/errors.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L25)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidValueError**(`message`, `details?`): [`InvalidValueError`](#invalidvalueerror)
Defined in: [src/primitives/Bytes/errors.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L30)
###### Parameters
###### message
`string`
###### details?
`any`
###### Returns
[`InvalidValueError`](#invalidvalueerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/Bytes/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L33)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes/errors.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/errors.js#L32)
###### Inherited from
`Error.name`
## Variables
### BytesType
> `const` **BytesType**: `object`
Defined in: [src/primitives/Bytes/Bytes.index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes.index.ts#L59)
#### Type Declaration
##### assert()
> **assert**: (`value`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Assert that value is valid Bytes, throw if not
###### Parameters
###### value
`unknown`
Value to check
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
The validated bytes
###### Throws
If value is not valid Bytes
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
const bytes = Bytes.assert(new Uint8Array([1, 2, 3])); // returns bytes
Bytes.assert("not bytes"); // throws Error
```
##### clone()
> **clone**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Clone Bytes
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to clone
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Cloned Bytes
###### Example
```typescript theme={null}
const copy = Bytes.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `number`
Compare two Bytes (lexicographic)
###### Parameters
###### a
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
First Bytes
###### b
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Second Bytes
###### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
###### Example
```typescript theme={null}
const cmp = Bytes.compare(bytes1, bytes2);
```
##### concat()
> **concat**: (...`arrays`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Concatenate multiple Bytes
###### Parameters
###### arrays
...[`BytesType`](../../primitives/Bytes.mdx#bytestype)\[]
Bytes to concatenate
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Concatenated Bytes
###### Example
```typescript theme={null}
const result = Bytes.concat(bytes1, bytes2, bytes3);
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two Bytes are equal
###### Parameters
###### a
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
First Bytes
###### b
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Second Bytes
###### Returns
`boolean`
True if equal
###### Example
```typescript theme={null}
const equal = Bytes.equals(bytes1, bytes2);
```
##### from()
> **from**: (`value`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Create Bytes from various input types (universal constructor)
###### Parameters
###### value
Uint8Array, hex string, UTF-8 string, or number array
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Throws
If value type is unsupported or invalid
###### Example
```typescript theme={null}
const b1 = Bytes.from(new Uint8Array([0x01, 0x02]));
const b2 = Bytes.from("0x1234");
const b3 = Bytes.from("hello");
const b4 = Bytes.from([0x01, 0x02, 0x03]);
```
##### fromBigInt()
> **fromBigInt**: (`value`, `size?`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert bigint to Bytes
###### Parameters
###### value
`bigint`
BigInt to convert (must be non-negative)
###### size?
`number`
Optional byte size (pads or throws if too small)
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Throws
If value is negative or doesn't fit in size
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.fromBigInt(255n); // Uint8Array([0xff])
Bytes.fromBigInt(255n, 2); // Uint8Array([0x00, 0xff])
Bytes.fromBigInt(0x1234n); // Uint8Array([0x12, 0x34])
```
##### fromHex()
> **fromHex**: (`hex`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Create Bytes from hex string
###### Parameters
###### hex
`string`
Hex string with 0x prefix
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Throws
If hex string is invalid
###### Example
```typescript theme={null}
const bytes = Bytes.fromHex("0x1234");
// Uint8Array([0x12, 0x34])
```
##### fromNumber()
> **fromNumber**: (`value`, `size?`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert number to Bytes
###### Parameters
###### value
`number`
Number to convert (must be safe integer, non-negative)
###### size?
`number`
Optional byte size (pads or throws if too small)
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Throws
If value is negative, not an integer, or exceeds MAX\_SAFE\_INTEGER
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.fromNumber(255); // Uint8Array([0xff])
Bytes.fromNumber(255, 2); // Uint8Array([0x00, 0xff])
Bytes.fromNumber(0x1234); // Uint8Array([0x12, 0x34])
```
##### fromString()
> **fromString**: (`str`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Create Bytes from UTF-8 string
###### Parameters
###### str
`string`
UTF-8 string
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Example
```typescript theme={null}
const bytes = Bytes.fromString("hello");
// Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f])
```
##### isBytes()
> **isBytes**: (`value`) => `value is BytesType`
Check if value is a valid Bytes (Uint8Array)
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is BytesType`
True if value is Uint8Array
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.isBytes(new Uint8Array([1, 2, 3])); // true
Bytes.isBytes([1, 2, 3]); // false
Bytes.isBytes("0x1234"); // false
```
##### isEmpty()
> **isEmpty**: (`bytes`) => `boolean`
Check if Bytes is empty
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to check
###### Returns
`boolean`
True if empty
###### Example
```typescript theme={null}
const empty = Bytes.isEmpty(bytes);
```
##### padLeft()
> **padLeft**: (`bytes`, `targetSize`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Pad Bytes on the left (start) with zeros to target size
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to pad
###### targetSize
`number`
Target size in bytes
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Padded bytes
###### Throws
If bytes exceeds target size
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.padLeft(new Uint8Array([0x12, 0x34]), 4); // Uint8Array([0x00, 0x00, 0x12, 0x34])
```
##### padRight()
> **padRight**: (`bytes`, `targetSize`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Pad Bytes on the right (end) with zeros to target size
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to pad
###### targetSize
`number`
Target size in bytes
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Padded bytes
###### Throws
If bytes exceeds target size
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.padRight(new Uint8Array([0x12, 0x34]), 4); // Uint8Array([0x12, 0x34, 0x00, 0x00])
```
##### random()
> **random**: (`size`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generate random Bytes of specified size
###### Parameters
###### size
`number`
Number of random bytes to generate
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Random bytes
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
const random32 = Bytes.random(32); // 32 random bytes
const random16 = Bytes.random(16); // 16 random bytes
```
##### size()
> **size**: (`bytes`) => `number`
Get size of Bytes
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
###### Returns
`number`
Size in bytes
###### Example
```typescript theme={null}
const size = Bytes.size(bytes);
```
##### slice()
> **slice**: (`bytes`, `start`, `end?`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Slice Bytes
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to slice
###### start
`number`
Start index
###### end?
`number`
End index (optional)
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Sliced Bytes
###### Example
```typescript theme={null}
const slice = Bytes.slice(bytes, 0, 4);
```
##### toBigInt()
> **toBigInt**: (`bytes`) => `bigint`
Convert Bytes to bigint
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
###### Returns
`bigint`
BigInt value
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.toBigInt(new Uint8Array([0xff])); // 255n
Bytes.toBigInt(new Uint8Array([0x12, 0x34])); // 4660n
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes to hex string
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string with 0x prefix
###### Example
```typescript theme={null}
const hex = Bytes.toHex(bytes);
// "0x1234"
```
##### toNumber()
> **toNumber**: (`bytes`) => `number`
Convert Bytes to number
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
###### Returns
`number`
Number value
###### Throws
If value exceeds MAX\_SAFE\_INTEGER
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.toNumber(new Uint8Array([0xff])); // 255
Bytes.toNumber(new Uint8Array([0x12, 0x34])); // 4660
```
##### toString()
> **toString**: (`bytes`) => `string`
Convert Bytes to UTF-8 string
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
###### Returns
`string`
UTF-8 string
###### Example
```typescript theme={null}
const str = Bytes.toString(bytes);
// "hello"
```
##### trimLeft()
> **trimLeft**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trim leading zeros from Bytes
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to trim
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trimmed bytes
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.trimLeft(new Uint8Array([0x00, 0x00, 0x12, 0x34])); // Uint8Array([0x12, 0x34])
Bytes.trimLeft(new Uint8Array([0x00, 0x00, 0x00])); // Uint8Array([])
```
##### trimRight()
> **trimRight**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trim trailing zeros from Bytes
###### Parameters
###### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to trim
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trimmed bytes
###### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.trimRight(new Uint8Array([0x12, 0x34, 0x00, 0x00])); // Uint8Array([0x12, 0x34])
Bytes.trimRight(new Uint8Array([0x00, 0x00, 0x00])); // Uint8Array([])
```
##### zero()
> **zero**: (`size`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Create zero Bytes of specified size
###### Parameters
###### size
`number`
Size in bytes
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Zero Bytes
###### Example
```typescript theme={null}
const zeros = Bytes.zero(32);
```
## Functions
### assert()
> **assert**(`value`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/assert.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/assert.js#L17)
Assert that value is valid Bytes, throw if not
#### Parameters
##### value
`unknown`
Value to check
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
The validated bytes
#### Throws
If value is not valid Bytes
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
const bytes = Bytes.assert(new Uint8Array([1, 2, 3])); // returns bytes
Bytes.assert("not bytes"); // throws Error
```
***
### clone()
> **clone**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/clone.js#L12)
Clone Bytes
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to clone
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Cloned Bytes
#### Example
```typescript theme={null}
const copy = Bytes.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes/compare.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/compare.js#L13)
Compare two Bytes (lexicographic)
#### Parameters
##### a
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
First Bytes
##### b
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Second Bytes
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### Example
```typescript theme={null}
const cmp = Bytes.compare(bytes1, bytes2);
```
***
### concat()
> **concat**(...`arrays`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/concat.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/concat.js#L12)
Concatenate multiple Bytes
#### Parameters
##### arrays
...[`BytesType`](../../primitives/Bytes.mdx#bytestype)\[]
Bytes to concatenate
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Concatenated Bytes
#### Example
```typescript theme={null}
const result = Bytes.concat(bytes1, bytes2, bytes3);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/equals.js#L13)
Check if two Bytes are equal
#### Parameters
##### a
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
First Bytes
##### b
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Second Bytes
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const equal = Bytes.equals(bytes1, bytes2);
```
***
### from()
> **from**(`value`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/from.js#L20)
Create Bytes from various input types (universal constructor)
#### Parameters
##### value
Uint8Array, hex string, UTF-8 string, or number array
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Throws
If value type is unsupported or invalid
#### Example
```typescript theme={null}
const b1 = Bytes.from(new Uint8Array([0x01, 0x02]));
const b2 = Bytes.from("0x1234");
const b3 = Bytes.from("hello");
const b4 = Bytes.from([0x01, 0x02, 0x03]);
```
***
### fromBigInt()
> **fromBigInt**(`value`, `size?`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/fromBigInt.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/fromBigInt.js#L17)
Convert bigint to Bytes
#### Parameters
##### value
`bigint`
BigInt to convert (must be non-negative)
##### size?
`number`
Optional byte size (pads or throws if too small)
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Throws
If value is negative or doesn't fit in size
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.fromBigInt(255n); // Uint8Array([0xff])
Bytes.fromBigInt(255n, 2); // Uint8Array([0x00, 0xff])
Bytes.fromBigInt(0x1234n); // Uint8Array([0x12, 0x34])
```
***
### fromHex()
> **fromHex**(`hex`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/fromHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/fromHex.js#L16)
Create Bytes from hex string
#### Parameters
##### hex
`string`
Hex string with 0x prefix
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Throws
If hex string is invalid
#### Example
```typescript theme={null}
const bytes = Bytes.fromHex("0x1234");
// Uint8Array([0x12, 0x34])
```
***
### fromNumber()
> **fromNumber**(`value`, `size?`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/fromNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/fromNumber.js#L17)
Convert number to Bytes
#### Parameters
##### value
`number`
Number to convert (must be safe integer, non-negative)
##### size?
`number`
Optional byte size (pads or throws if too small)
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Throws
If value is negative, not an integer, or exceeds MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.fromNumber(255); // Uint8Array([0xff])
Bytes.fromNumber(255, 2); // Uint8Array([0x00, 0xff])
Bytes.fromNumber(0x1234); // Uint8Array([0x12, 0x34])
```
***
### fromString()
> **fromString**(`str`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/fromString.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/fromString.js#L13)
Create Bytes from UTF-8 string
#### Parameters
##### str
`string`
UTF-8 string
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Example
```typescript theme={null}
const bytes = Bytes.fromString("hello");
// Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f])
```
***
### isBytes()
> **isBytes**(`value`): `value is BytesType`
Defined in: [src/primitives/Bytes/isBytes.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/isBytes.js#L15)
Check if value is a valid Bytes (Uint8Array)
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is BytesType`
True if value is Uint8Array
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.isBytes(new Uint8Array([1, 2, 3])); // true
Bytes.isBytes([1, 2, 3]); // false
Bytes.isBytes("0x1234"); // false
```
***
### isEmpty()
> **isEmpty**(`bytes`): `boolean`
Defined in: [src/primitives/Bytes/isEmpty.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/isEmpty.js#L12)
Check if Bytes is empty
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to check
#### Returns
`boolean`
True if empty
#### Example
```typescript theme={null}
const empty = Bytes.isEmpty(bytes);
```
***
### padLeft()
> **padLeft**(`bytes`, `targetSize`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/padLeft.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/padLeft.js#L15)
Pad Bytes on the left (start) with zeros to target size
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to pad
##### targetSize
`number`
Target size in bytes
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Padded bytes
#### Throws
If bytes exceeds target size
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.padLeft(new Uint8Array([0x12, 0x34]), 4); // Uint8Array([0x00, 0x00, 0x12, 0x34])
```
***
### padRight()
> **padRight**(`bytes`, `targetSize`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/padRight.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/padRight.js#L15)
Pad Bytes on the right (end) with zeros to target size
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to pad
##### targetSize
`number`
Target size in bytes
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Padded bytes
#### Throws
If bytes exceeds target size
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.padRight(new Uint8Array([0x12, 0x34]), 4); // Uint8Array([0x12, 0x34, 0x00, 0x00])
```
***
### random()
> **random**(`size`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/random.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/random.js#L14)
Generate random Bytes of specified size
#### Parameters
##### size
`number`
Number of random bytes to generate
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Random bytes
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
const random32 = Bytes.random(32); // 32 random bytes
const random16 = Bytes.random(16); // 16 random bytes
```
***
### size()
> **size**(`bytes`): `number`
Defined in: [src/primitives/Bytes/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/size.js#L12)
Get size of Bytes
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes
#### Returns
`number`
Size in bytes
#### Example
```typescript theme={null}
const size = Bytes.size(bytes);
```
***
### slice()
> **slice**(`bytes`, `start`, `end?`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/slice.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/slice.js#L14)
Slice Bytes
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to slice
##### start
`number`
Start index
##### end?
`number`
End index (optional)
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Sliced Bytes
#### Example
```typescript theme={null}
const slice = Bytes.slice(bytes, 0, 4);
```
***
### toBigInt()
> **toBigInt**(`bytes`): `bigint`
Defined in: [src/primitives/Bytes/toBigInt.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/toBigInt.js#L14)
Convert Bytes to bigint
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
#### Returns
`bigint`
BigInt value
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.toBigInt(new Uint8Array([0xff])); // 255n
Bytes.toBigInt(new Uint8Array([0x12, 0x34])); // 4660n
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/toHex.js#L13)
Convert Bytes to hex string
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = Bytes.toHex(bytes);
// "0x1234"
```
***
### toNumber()
> **toNumber**(`bytes`): `number`
Defined in: [src/primitives/Bytes/toNumber.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/toNumber.js#L15)
Convert Bytes to number
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
#### Returns
`number`
Number value
#### Throws
If value exceeds MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.toNumber(new Uint8Array([0xff])); // 255
Bytes.toNumber(new Uint8Array([0x12, 0x34])); // 4660
```
***
### toString()
> **toString**(`bytes`): `string`
Defined in: [src/primitives/Bytes/toString.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/toString.js#L14)
Convert Bytes to UTF-8 string
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to convert
#### Returns
`string`
UTF-8 string
#### Example
```typescript theme={null}
const str = Bytes.toString(bytes);
// "hello"
```
***
### trimLeft()
> **trimLeft**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/trimLeft.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/trimLeft.js#L14)
Trim leading zeros from Bytes
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to trim
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trimmed bytes
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.trimLeft(new Uint8Array([0x00, 0x00, 0x12, 0x34])); // Uint8Array([0x12, 0x34])
Bytes.trimLeft(new Uint8Array([0x00, 0x00, 0x00])); // Uint8Array([])
```
***
### trimRight()
> **trimRight**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/trimRight.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/trimRight.js#L14)
Trim trailing zeros from Bytes
#### Parameters
##### bytes
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Bytes to trim
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Trimmed bytes
#### Example
```javascript theme={null}
import * as Bytes from './primitives/Bytes/index.js';
Bytes.trimRight(new Uint8Array([0x12, 0x34, 0x00, 0x00])); // Uint8Array([0x12, 0x34])
Bytes.trimRight(new Uint8Array([0x00, 0x00, 0x00])); // Uint8Array([])
```
***
### zero()
> **zero**(`size`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/zero.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/zero.js#L12)
Create zero Bytes of specified size
#### Parameters
##### size
`number`
Size in bytes
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Zero Bytes
#### Example
```typescript theme={null}
const zeros = Bytes.zero(32);
```
# BrandedBytes1
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes1
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes1
# BrandedBytes1
## Functions
### Bytes1()
> **Bytes1**(`value`): [`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Defined in: [src/primitives/Bytes/Bytes1/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/index.ts#L31)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
***
### clone()
> **clone**(`bytes`): [`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Defined in: [src/primitives/Bytes/Bytes1/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/clone.js#L12)
Clone Bytes1
#### Parameters
##### bytes
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1 to clone
#### Returns
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Cloned Bytes1
#### Example
```typescript theme={null}
const copy = Bytes1.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes/Bytes1/compare.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/compare.js#L13)
Compare two Bytes1
#### Parameters
##### a
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
First Bytes1
##### b
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Second Bytes1
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### Example
```typescript theme={null}
const cmp = Bytes1.compare(bytes1, bytes2);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes1/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/equals.js#L13)
Check if two Bytes1 are equal
#### Parameters
##### a
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
First Bytes1
##### b
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Second Bytes1
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const equal = Bytes1.equals(bytes1, bytes2);
```
***
### from()
> **from**(`value`): [`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Defined in: [src/primitives/Bytes/Bytes1/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/from.js#L17)
Create Bytes1 from various input types with size validation
#### Parameters
##### value
Uint8Array, hex string, or UTF-8 string (must be exactly 1 byte)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1
#### Throws
If length is not 1 byte
#### Example
```typescript theme={null}
const b1 = Bytes1.from(new Uint8Array([0x12]));
const b2 = Bytes1.from("0x12");
```
***
### fromHex()
> **fromHex**(`hex`): [`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Defined in: [src/primitives/Bytes/Bytes1/fromHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/fromHex.js#L16)
Create Bytes1 from hex string with size validation
#### Parameters
##### hex
`string`
Hex string (must be exactly 2 hex chars + 0x prefix)
#### Returns
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1
#### Throws
If length is not 1 byte
#### Example
```typescript theme={null}
const bytes = Bytes1.fromHex("0x12");
```
***
### fromNumber()
> **fromNumber**(`value`): [`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Defined in: [src/primitives/Bytes/Bytes1/fromNumber.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/fromNumber.js#L13)
Create Bytes1 from number (0-255)
#### Parameters
##### value
`number`
Number value (0-255)
#### Returns
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1
#### Throws
If value is out of range
#### Example
```typescript theme={null}
const bytes = Bytes1.fromNumber(42);
```
***
### size()
> **size**(`_bytes`): `1`
Defined in: [src/primitives/Bytes/Bytes1/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/size.js#L12)
Get size of Bytes1 (always 1)
#### Parameters
##### \_bytes
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1
#### Returns
`1`
Size (always 1)
#### Example
```typescript theme={null}
const size = Bytes1.size(bytes); // 1
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes1/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/toBytes.js#L12)
Convert Bytes1 to generic Bytes
#### Parameters
##### bytes
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes1.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes1/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/toHex.js#L12)
Convert Bytes1 to hex string
#### Parameters
##### bytes
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes1.toHex(bytes);
```
***
### toNumber()
> **toNumber**(`bytes`): `number`
Defined in: [src/primitives/Bytes/Bytes1/toNumber.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/toNumber.js#L12)
Convert Bytes1 to number
#### Parameters
##### bytes
[`Bytes1Type`](../../primitives/Bytes.mdx#bytes1type)
Bytes1 to convert
#### Returns
`number`
Number value
#### Example
```typescript theme={null}
const num = Bytes1.toNumber(bytes);
```
## References
### Bytes1Type
Re-exports [Bytes1Type](../../primitives/Bytes.mdx#bytes1type)
# BrandedBytes16
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes16
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes16
# BrandedBytes16
## Type Aliases
### Bytes16Like
> **Bytes16Like** = [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type) | `string` | `Uint8Array`
Defined in: [src/primitives/Bytes/Bytes16/Bytes16Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/Bytes16Type.ts#L11)
Inputs that can be converted to Bytes16
## Variables
### SIZE
> `const` **SIZE**: `16` = `16`
Defined in: [src/primitives/Bytes/Bytes16/Bytes16Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/Bytes16Type.ts#L13)
***
### ZERO
> `const` **ZERO**: [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/constants.js#L10)
Zero Bytes16 constant (16 zero bytes)
## Functions
### Bytes16()
> **Bytes16**(`value`): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/index.ts#L39)
#### Parameters
##### value
[`Bytes16Like`](#bytes16like)
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
***
### clone()
> **clone**(`bytes`): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/clone.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/clone.js#L14)
Clone a Bytes16 value
#### Parameters
##### bytes
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Value to clone
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Cloned value
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const cloned = Bytes16.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes/Bytes16/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/compare.js#L15)
Compare two Bytes16 values
#### Parameters
##### a
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
First value
##### b
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Second value
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const result = Bytes16.compare(a, b);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes16/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/equals.js#L15)
Check if two Bytes16 values are equal
#### Parameters
##### a
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
First value
##### b
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Second value
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const equal = Bytes16.equals(a, b);
```
***
### from()
> **from**(`value`): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/from.js#L19)
Create Bytes16 from string or bytes
#### Parameters
##### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const bytes = Bytes16.from('0x1234567890abcdef1234567890abcdef');
const bytes2 = Bytes16.from(new Uint8Array(16));
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/fromBytes.js#L18)
Create Bytes16 from raw bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 16 bytes)
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Throws
If bytes is wrong length
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const bytes = Bytes16.fromBytes(new Uint8Array(16));
```
***
### fromHex()
> **fromHex**(`hex`): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/fromHex.js#L19)
Create Bytes16 from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Throws
If hex is wrong length
#### Throws
If hex contains invalid characters
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const bytes = Bytes16.fromHex('0x1234567890abcdef1234567890abcdef');
```
***
### isZero()
> **isZero**(`bytes`): `boolean`
Defined in: [src/primitives/Bytes/Bytes16/isZero.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/isZero.js#L14)
Check if Bytes16 is all zeros
#### Parameters
##### bytes
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Value to check
#### Returns
`boolean`
True if all zeros
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const isAllZeros = Bytes16.isZero(bytes);
```
***
### size()
> **size**(`_bytes`): `16`
Defined in: [src/primitives/Bytes/Bytes16/size.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/size.js#L16)
Get size of Bytes16 (always 16)
#### Parameters
##### \_bytes
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16 value
#### Returns
`16`
Size in bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const s = Bytes16.size(bytes); // 16
```
***
### toHex()
> **toHex**(`bytes`): `string`
Defined in: [src/primitives/Bytes/Bytes16/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/toHex.js#L15)
Convert Bytes16 to hex string
#### Parameters
##### bytes
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16 to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const hex = Bytes16.toHex(bytes);
// "0x1234567890abcdef1234567890abcdef"
```
***
### toUint8Array()
> **toUint8Array**(`bytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Bytes/Bytes16/toUint8Array.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/toUint8Array.js#L14)
Convert Bytes16 to Uint8Array
#### Parameters
##### bytes
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Bytes16 to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const raw = Bytes16.toUint8Array(bytes);
```
***
### zero()
> **zero**(): [`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Defined in: [src/primitives/Bytes/Bytes16/zero.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/zero.js#L15)
Create a zero-filled Bytes16
#### Returns
[`Bytes16Type`](../../primitives/Bytes.mdx#bytes16type)
Zero-filled Bytes16
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes16](https://voltaire.tevm.sh/primitives/bytes/bytes16) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes16 from './primitives/Bytes/Bytes16/index.js';
const zeros = Bytes16.zero();
```
## References
### Bytes16Type
Re-exports [Bytes16Type](../../primitives/Bytes.mdx#bytes16type)
# BrandedBytes2
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes2
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes2
# BrandedBytes2
## Variables
### BytesType2
> `const` **BytesType2**: `object`
Defined in: [src/primitives/Bytes/Bytes2/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/index.ts#L16)
#### Type Declaration
##### clone()
> **clone**: (`bytes`) => [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Clone Bytes2
###### Parameters
###### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to clone
###### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Cloned Bytes2
###### Example
```typescript theme={null}
const copy = Bytes2.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `-1` | `0` | `1`
###### Parameters
###### a
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### b
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### Returns
`-1` | `0` | `1`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### b
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
##### size()
> **size**: (`_bytes`) => `2`
Get size of Bytes2 (always 2)
###### Parameters
###### \_bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2
###### Returns
`2`
Size (always 2)
###### Example
```typescript theme={null}
const size = Bytes2.size(bytes); // 2
```
##### toBytes()
> **toBytes**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert Bytes2 to generic Bytes
###### Parameters
###### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to convert
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
###### Example
```typescript theme={null}
const genericBytes = Bytes2.toBytes(bytes);
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes2 to hex string
###### Parameters
###### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### Example
```typescript theme={null}
const hex = Bytes2.toHex(bytes);
```
## Functions
### clone()
> **clone**(`bytes`): [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Defined in: [src/primitives/Bytes/Bytes2/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/clone.js#L12)
Clone Bytes2
#### Parameters
##### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to clone
#### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Cloned Bytes2
#### Example
```typescript theme={null}
const copy = Bytes2.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes2/compare.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/compare.js#L6)
#### Parameters
##### a
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
##### b
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes2/equals.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/equals.js#L6)
#### Parameters
##### a
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
##### b
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Defined in: [src/primitives/Bytes/Bytes2/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Defined in: [src/primitives/Bytes/Bytes2/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
***
### size()
> **size**(`_bytes`): `2`
Defined in: [src/primitives/Bytes/Bytes2/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/size.js#L12)
Get size of Bytes2 (always 2)
#### Parameters
##### \_bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2
#### Returns
`2`
Size (always 2)
#### Example
```typescript theme={null}
const size = Bytes2.size(bytes); // 2
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes2/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/toBytes.js#L12)
Convert Bytes2 to generic Bytes
#### Parameters
##### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes2.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes2/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/toHex.js#L12)
Convert Bytes2 to hex string
#### Parameters
##### bytes
[`Bytes2Type`](../../primitives/Bytes.mdx#bytes2type)
Bytes2 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes2.toHex(bytes);
```
## References
### Bytes2Type
Re-exports [Bytes2Type](../../primitives/Bytes.mdx#bytes2type)
# BrandedBytes3
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes3
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes3
# BrandedBytes3
## Variables
### BytesType3
> `const` **BytesType3**: `object`
Defined in: [src/primitives/Bytes/Bytes3/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/index.ts#L16)
#### Type Declaration
##### clone()
> **clone**: (`bytes`) => [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Clone Bytes3
###### Parameters
###### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to clone
###### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Cloned Bytes3
###### Example
```typescript theme={null}
const copy = Bytes3.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `-1` | `0` | `1`
###### Parameters
###### a
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### b
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### Returns
`-1` | `0` | `1`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### b
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
##### size()
> **size**: (`_bytes`) => `3`
Get size of Bytes3 (always 3)
###### Parameters
###### \_bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3
###### Returns
`3`
Size (always 3)
###### Example
```typescript theme={null}
const size = Bytes3.size(bytes); // 3
```
##### toBytes()
> **toBytes**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert Bytes3 to generic Bytes
###### Parameters
###### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to convert
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
###### Example
```typescript theme={null}
const genericBytes = Bytes3.toBytes(bytes);
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes3 to hex string
###### Parameters
###### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### Example
```typescript theme={null}
const hex = Bytes3.toHex(bytes);
```
## Functions
### clone()
> **clone**(`bytes`): [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Defined in: [src/primitives/Bytes/Bytes3/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/clone.js#L12)
Clone Bytes3
#### Parameters
##### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to clone
#### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Cloned Bytes3
#### Example
```typescript theme={null}
const copy = Bytes3.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes3/compare.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/compare.js#L6)
#### Parameters
##### a
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
##### b
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes3/equals.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/equals.js#L6)
#### Parameters
##### a
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
##### b
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Defined in: [src/primitives/Bytes/Bytes3/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Defined in: [src/primitives/Bytes/Bytes3/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
***
### size()
> **size**(`_bytes`): `3`
Defined in: [src/primitives/Bytes/Bytes3/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/size.js#L12)
Get size of Bytes3 (always 3)
#### Parameters
##### \_bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3
#### Returns
`3`
Size (always 3)
#### Example
```typescript theme={null}
const size = Bytes3.size(bytes); // 3
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes3/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/toBytes.js#L12)
Convert Bytes3 to generic Bytes
#### Parameters
##### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes3.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes3/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/toHex.js#L12)
Convert Bytes3 to hex string
#### Parameters
##### bytes
[`Bytes3Type`](../../primitives/Bytes.mdx#bytes3type)
Bytes3 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes3.toHex(bytes);
```
## References
### Bytes3Type
Re-exports [Bytes3Type](../../primitives/Bytes.mdx#bytes3type)
# BrandedBytes32
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes32
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes32
# BrandedBytes32
## Type Aliases
### Bytes32Like
> **Bytes32Like** = [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type) | `string` | `Uint8Array` | `bigint` | `number`
Defined in: [src/primitives/Bytes/Bytes32/Bytes32Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/Bytes32Type.ts#L11)
Inputs that can be converted to Bytes32
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/Bytes/Bytes32/Bytes32Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/Bytes32Type.ts#L13)
***
### ZERO
> `const` **ZERO**: [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/constants.js#L12)
Zero Bytes32 constant (32 zero bytes)
## Functions
### Bytes32()
> **Bytes32**(`value`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/index.ts#L49)
#### Parameters
##### value
[`Bytes32Like`](#bytes32like)
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
***
### clone()
> **clone**(`bytes`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/clone.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/clone.js#L14)
Clone a Bytes32 value
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Value to clone
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Cloned value
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const cloned = Bytes32.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes/Bytes32/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/compare.js#L15)
Compare two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
First value
##### b
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Second value
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const result = Bytes32.compare(a, b);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes32/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/equals.js#L15)
Check if two Bytes32 values are equal
#### Parameters
##### a
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
First value
##### b
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Second value
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const equal = Bytes32.equals(a, b);
```
***
### from()
> **from**(`value`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/from.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/from.js#L23)
Create Bytes32 from string, bytes, number, or bigint
#### Parameters
##### value
Value to convert
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const bytes1 = Bytes32.from('0x' + '12'.repeat(32));
const bytes2 = Bytes32.from(new Uint8Array(32));
const bytes3 = Bytes32.from(42);
const bytes4 = Bytes32.from(123n);
```
***
### fromBigint()
> **fromBigint**(`value`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/fromBigint.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/fromBigint.js#L16)
Create Bytes32 from bigint (padded to 32 bytes)
#### Parameters
##### value
`bigint`
Bigint to convert
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 (big-endian)
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const bytes = Bytes32.fromBigint(123456789012345678901234567890n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/fromBytes.js#L18)
Create Bytes32 from raw bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 32 bytes)
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Throws
If bytes is wrong length
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const bytes = Bytes32.fromBytes(new Uint8Array(32));
```
***
### fromHex()
> **fromHex**(`hex`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/fromHex.js#L19)
Create Bytes32 from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Throws
If hex is wrong length
#### Throws
If hex contains invalid characters
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const bytes = Bytes32.fromHex('0x' + '1234'.repeat(16));
```
***
### fromNumber()
> **fromNumber**(`value`): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/fromNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/fromNumber.js#L16)
Create Bytes32 from number (padded to 32 bytes)
#### Parameters
##### value
`number`
Number to convert
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 (big-endian)
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const bytes = Bytes32.fromNumber(42);
```
***
### isZero()
> **isZero**(`bytes`): `boolean`
Defined in: [src/primitives/Bytes/Bytes32/isZero.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/isZero.js#L14)
Check if Bytes32 is all zeros
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Value to check
#### Returns
`boolean`
True if all zeros
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const isAllZeros = Bytes32.isZero(bytes);
```
***
### size()
> **size**(`_bytes`): `32`
Defined in: [src/primitives/Bytes/Bytes32/size.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/size.js#L16)
Get size of Bytes32 (always 32)
#### Parameters
##### \_bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 value
#### Returns
`32`
Size in bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const s = Bytes32.size(bytes); // 32
```
***
### toAddress()
> **toAddress**(`bytes`): [`AddressType`](../../primitives/Address.mdx#addresstype)
Defined in: [src/primitives/Bytes/Bytes32/toAddress.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/toAddress.js#L14)
Extract Address from Bytes32 (last 20 bytes)
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 to extract from
#### Returns
[`AddressType`](../../primitives/Address.mdx#addresstype)
Address
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const addr = Bytes32.toAddress(bytes);
```
***
### toBigint()
> **toBigint**(`bytes`): `bigint`
Defined in: [src/primitives/Bytes/Bytes32/toBigint.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/toBigint.js#L14)
Convert Bytes32 to bigint (big-endian)
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 to convert
#### Returns
`bigint`
Bigint value
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const value = Bytes32.toBigint(bytes);
```
***
### toHash()
> **toHash**(`bytes`): [`HashType`](HashType.mdx#hashtype)
Defined in: [src/primitives/Bytes/Bytes32/toHash.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/toHash.js#L14)
Convert Bytes32 to Hash (same size, different semantic meaning)
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 to convert
#### Returns
[`HashType`](HashType.mdx#hashtype)
Hash
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const hash = Bytes32.toHash(bytes);
```
***
### toHex()
> **toHex**(`bytes`): `string`
Defined in: [src/primitives/Bytes/Bytes32/toHex.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/toHex.js#L14)
Convert Bytes32 to hex string
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const hex = Bytes32.toHex(bytes);
```
***
### toUint8Array()
> **toUint8Array**(`bytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Bytes/Bytes32/toUint8Array.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/toUint8Array.js#L14)
Convert Bytes32 to Uint8Array
#### Parameters
##### bytes
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Bytes32 to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const raw = Bytes32.toUint8Array(bytes);
```
***
### zero()
> **zero**(): [`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Defined in: [src/primitives/Bytes/Bytes32/zero.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/zero.js#L15)
Create a zero-filled Bytes32
#### Returns
[`Bytes32Type`](../../primitives/Bytes.mdx#bytes32type)
Zero-filled Bytes32
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes32](https://voltaire.tevm.sh/primitives/bytes/bytes32) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes32 from './primitives/Bytes/Bytes32/index.js';
const zeros = Bytes32.zero();
```
## References
### Bytes32Type
Re-exports [Bytes32Type](../../primitives/Bytes.mdx#bytes32type)
# BrandedBytes4
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes4
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes4
# BrandedBytes4
## Functions
### Bytes4()
> **Bytes4**(`value`): [`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Defined in: [src/primitives/Bytes/Bytes4/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/index.ts#L18)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
***
### clone()
> **clone**(`bytes`): [`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Defined in: [src/primitives/Bytes/Bytes4/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/clone.js#L12)
Clone Bytes4
#### Parameters
##### bytes
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Bytes4 to clone
#### Returns
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Cloned Bytes4
#### Example
```typescript theme={null}
const copy = Bytes4.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes4/compare.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/compare.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes4/equals.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/equals.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Defined in: [src/primitives/Bytes/Bytes4/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Defined in: [src/primitives/Bytes/Bytes4/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
***
### size()
> **size**(`_bytes`): `4`
Defined in: [src/primitives/Bytes/Bytes4/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/size.js#L12)
Get size of Bytes4 (always 4)
#### Parameters
##### \_bytes
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Bytes4
#### Returns
`4`
Size (always 4)
#### Example
```typescript theme={null}
const size = Bytes4.size(bytes); // 4
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes4/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/toBytes.js#L12)
Convert Bytes4 to generic Bytes
#### Parameters
##### bytes
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Bytes4 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes4.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes4/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/toHex.js#L12)
Convert Bytes4 to hex string
#### Parameters
##### bytes
[`Bytes4Type`](../../primitives/Bytes.mdx#bytes4type)
Bytes4 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes4.toHex(bytes);
```
## References
### Bytes4Type
Re-exports [Bytes4Type](../../primitives/Bytes.mdx#bytes4type)
# BrandedBytes5
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes5
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes5
# BrandedBytes5
## Variables
### BytesType5
> `const` **BytesType5**: `object`
Defined in: [src/primitives/Bytes/Bytes5/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/index.ts#L16)
#### Type Declaration
##### clone()
> **clone**: (`bytes`) => [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Clone Bytes5
###### Parameters
###### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to clone
###### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Cloned Bytes5
###### Example
```typescript theme={null}
const copy = Bytes5.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `-1` | `0` | `1`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`-1` | `0` | `1`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
##### size()
> **size**: (`_bytes`) => `5`
Get size of Bytes5 (always 5)
###### Parameters
###### \_bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5
###### Returns
`5`
Size (always 5)
###### Example
```typescript theme={null}
const size = Bytes5.size(bytes); // 5
```
##### toBytes()
> **toBytes**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert Bytes5 to generic Bytes
###### Parameters
###### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to convert
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
###### Example
```typescript theme={null}
const genericBytes = Bytes5.toBytes(bytes);
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes5 to hex string
###### Parameters
###### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### Example
```typescript theme={null}
const hex = Bytes5.toHex(bytes);
```
## Functions
### clone()
> **clone**(`bytes`): [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Defined in: [src/primitives/Bytes/Bytes5/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/clone.js#L12)
Clone Bytes5
#### Parameters
##### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to clone
#### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Cloned Bytes5
#### Example
```typescript theme={null}
const copy = Bytes5.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes5/compare.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/compare.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes5/equals.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/equals.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Defined in: [src/primitives/Bytes/Bytes5/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Defined in: [src/primitives/Bytes/Bytes5/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
***
### size()
> **size**(`_bytes`): `5`
Defined in: [src/primitives/Bytes/Bytes5/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/size.js#L12)
Get size of Bytes5 (always 5)
#### Parameters
##### \_bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5
#### Returns
`5`
Size (always 5)
#### Example
```typescript theme={null}
const size = Bytes5.size(bytes); // 5
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes5/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/toBytes.js#L12)
Convert Bytes5 to generic Bytes
#### Parameters
##### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes5.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes5/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/toHex.js#L12)
Convert Bytes5 to hex string
#### Parameters
##### bytes
[`Bytes5Type`](../../primitives/Bytes.mdx#bytes5type)
Bytes5 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes5.toHex(bytes);
```
## References
### Bytes5Type
Re-exports [Bytes5Type](../../primitives/Bytes.mdx#bytes5type)
# BrandedBytes6
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes6
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes6
# BrandedBytes6
## Variables
### BytesType6
> `const` **BytesType6**: `object`
Defined in: [src/primitives/Bytes/Bytes6/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/index.ts#L16)
#### Type Declaration
##### clone()
> **clone**: (`bytes`) => [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Clone Bytes6
###### Parameters
###### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to clone
###### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Cloned Bytes6
###### Example
```typescript theme={null}
const copy = Bytes6.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `-1` | `0` | `1`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`-1` | `0` | `1`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
##### size()
> **size**: (`_bytes`) => `6`
Get size of Bytes6 (always 6)
###### Parameters
###### \_bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6
###### Returns
`6`
Size (always 6)
###### Example
```typescript theme={null}
const size = Bytes6.size(bytes); // 6
```
##### toBytes()
> **toBytes**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert Bytes6 to generic Bytes
###### Parameters
###### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to convert
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
###### Example
```typescript theme={null}
const genericBytes = Bytes6.toBytes(bytes);
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes6 to hex string
###### Parameters
###### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### Example
```typescript theme={null}
const hex = Bytes6.toHex(bytes);
```
## Functions
### clone()
> **clone**(`bytes`): [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Defined in: [src/primitives/Bytes/Bytes6/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/clone.js#L12)
Clone Bytes6
#### Parameters
##### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to clone
#### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Cloned Bytes6
#### Example
```typescript theme={null}
const copy = Bytes6.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes6/compare.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/compare.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes6/equals.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/equals.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Defined in: [src/primitives/Bytes/Bytes6/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Defined in: [src/primitives/Bytes/Bytes6/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
***
### size()
> **size**(`_bytes`): `6`
Defined in: [src/primitives/Bytes/Bytes6/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/size.js#L12)
Get size of Bytes6 (always 6)
#### Parameters
##### \_bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6
#### Returns
`6`
Size (always 6)
#### Example
```typescript theme={null}
const size = Bytes6.size(bytes); // 6
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes6/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/toBytes.js#L12)
Convert Bytes6 to generic Bytes
#### Parameters
##### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes6.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes6/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/toHex.js#L12)
Convert Bytes6 to hex string
#### Parameters
##### bytes
[`Bytes6Type`](../../primitives/Bytes.mdx#bytes6type)
Bytes6 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes6.toHex(bytes);
```
## References
### Bytes6Type
Re-exports [Bytes6Type](../../primitives/Bytes.mdx#bytes6type)
# BrandedBytes64
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes64
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes64
# BrandedBytes64
## Type Aliases
### Bytes64Like
> **Bytes64Like** = [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type) | `string` | `Uint8Array`
Defined in: [src/primitives/Bytes/Bytes64/Bytes64Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/Bytes64Type.ts#L11)
Inputs that can be converted to Bytes64
## Variables
### SIZE
> `const` **SIZE**: `64` = `64`
Defined in: [src/primitives/Bytes/Bytes64/Bytes64Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/Bytes64Type.ts#L13)
***
### ZERO
> `const` **ZERO**: [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/constants.js#L10)
Zero Bytes64 constant (64 zero bytes)
## Functions
### Bytes64()
> **Bytes64**(`value`): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/index.ts#L39)
#### Parameters
##### value
[`Bytes64Like`](#bytes64like)
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
***
### clone()
> **clone**(`bytes`): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/clone.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/clone.js#L14)
Clone a Bytes64 value
#### Parameters
##### bytes
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Value to clone
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Cloned value
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const cloned = Bytes64.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes/Bytes64/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/compare.js#L15)
Compare two Bytes64 values
#### Parameters
##### a
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
First value
##### b
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Second value
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const result = Bytes64.compare(a, b);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes64/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/equals.js#L15)
Check if two Bytes64 values are equal
#### Parameters
##### a
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
First value
##### b
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Second value
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const equal = Bytes64.equals(a, b);
```
***
### from()
> **from**(`value`): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/from.js#L19)
Create Bytes64 from string or bytes
#### Parameters
##### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const bytes = Bytes64.from('0x' + '12'.repeat(64));
const bytes2 = Bytes64.from(new Uint8Array(64));
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/fromBytes.js#L18)
Create Bytes64 from raw bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 64 bytes)
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Throws
If bytes is wrong length
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const bytes = Bytes64.fromBytes(new Uint8Array(64));
```
***
### fromHex()
> **fromHex**(`hex`): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/fromHex.js#L19)
Create Bytes64 from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Throws
If hex is wrong length
#### Throws
If hex contains invalid characters
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const bytes = Bytes64.fromHex('0x' + '1234'.repeat(32));
```
***
### isZero()
> **isZero**(`bytes`): `boolean`
Defined in: [src/primitives/Bytes/Bytes64/isZero.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/isZero.js#L14)
Check if Bytes64 is all zeros
#### Parameters
##### bytes
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Value to check
#### Returns
`boolean`
True if all zeros
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const isAllZeros = Bytes64.isZero(bytes);
```
***
### size()
> **size**(`_bytes`): `64`
Defined in: [src/primitives/Bytes/Bytes64/size.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/size.js#L16)
Get size of Bytes64 (always 64)
#### Parameters
##### \_bytes
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64 value
#### Returns
`64`
Size in bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const s = Bytes64.size(bytes); // 64
```
***
### toHex()
> **toHex**(`bytes`): `string`
Defined in: [src/primitives/Bytes/Bytes64/toHex.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/toHex.js#L14)
Convert Bytes64 to hex string
#### Parameters
##### bytes
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64 to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const hex = Bytes64.toHex(bytes);
```
***
### toUint8Array()
> **toUint8Array**(`bytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Bytes/Bytes64/toUint8Array.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/toUint8Array.js#L14)
Convert Bytes64 to Uint8Array
#### Parameters
##### bytes
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Bytes64 to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const raw = Bytes64.toUint8Array(bytes);
```
***
### zero()
> **zero**(): [`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Defined in: [src/primitives/Bytes/Bytes64/zero.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/zero.js#L15)
Create a zero-filled Bytes64
#### Returns
[`Bytes64Type`](../../primitives/Bytes.mdx#bytes64type)
Zero-filled Bytes64
#### See
[https://voltaire.tevm.sh/primitives/bytes/bytes64](https://voltaire.tevm.sh/primitives/bytes/bytes64) for documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Bytes64 from './primitives/Bytes/Bytes64/index.js';
const zeros = Bytes64.zero();
```
## References
### Bytes64Type
Re-exports [Bytes64Type](../../primitives/Bytes.mdx#bytes64type)
# BrandedBytes7
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes7
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes7
# BrandedBytes7
## Variables
### BytesType7
> `const` **BytesType7**: `object`
Defined in: [src/primitives/Bytes/Bytes7/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/index.ts#L16)
#### Type Declaration
##### clone()
> **clone**: (`bytes`) => [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Clone Bytes7
###### Parameters
###### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to clone
###### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Cloned Bytes7
###### Example
```typescript theme={null}
const copy = Bytes7.clone(bytes);
```
##### compare()
> **compare**: (`a`, `b`) => `-1` | `0` | `1`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`-1` | `0` | `1`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
`Uint8Array`\<`ArrayBufferLike`>
###### b
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
##### size()
> **size**: (`_bytes`) => `7`
Get size of Bytes7 (always 7)
###### Parameters
###### \_bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7
###### Returns
`7`
Size (always 7)
###### Example
```typescript theme={null}
const size = Bytes7.size(bytes); // 7
```
##### toBytes()
> **toBytes**: (`bytes`) => [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Convert Bytes7 to generic Bytes
###### Parameters
###### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to convert
###### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
###### Example
```typescript theme={null}
const genericBytes = Bytes7.toBytes(bytes);
```
##### toHex()
> **toHex**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert Bytes7 to hex string
###### Parameters
###### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### Example
```typescript theme={null}
const hex = Bytes7.toHex(bytes);
```
## Functions
### clone()
> **clone**(`bytes`): [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Defined in: [src/primitives/Bytes/Bytes7/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/clone.js#L12)
Clone Bytes7
#### Parameters
##### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to clone
#### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Cloned Bytes7
#### Example
```typescript theme={null}
const copy = Bytes7.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes7/compare.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/compare.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes7/equals.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/equals.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Defined in: [src/primitives/Bytes/Bytes7/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Defined in: [src/primitives/Bytes/Bytes7/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/fromHex.js#L8)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
***
### size()
> **size**(`_bytes`): `7`
Defined in: [src/primitives/Bytes/Bytes7/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/size.js#L12)
Get size of Bytes7 (always 7)
#### Parameters
##### \_bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7
#### Returns
`7`
Size (always 7)
#### Example
```typescript theme={null}
const size = Bytes7.size(bytes); // 7
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes7/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/toBytes.js#L12)
Convert Bytes7 to generic Bytes
#### Parameters
##### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes7.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes7/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/toHex.js#L12)
Convert Bytes7 to hex string
#### Parameters
##### bytes
[`Bytes7Type`](../../primitives/Bytes.mdx#bytes7type)
Bytes7 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes7.toHex(bytes);
```
## References
### Bytes7Type
Re-exports [Bytes7Type](../../primitives/Bytes.mdx#bytes7type)
# BrandedBytes8
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedBytes8
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedBytes8
# BrandedBytes8
## Functions
### Bytes8()
> **Bytes8**(`value`): [`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Defined in: [src/primitives/Bytes/Bytes8/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/index.ts#L18)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | `number`\[]
#### Returns
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
***
### clone()
> **clone**(`bytes`): [`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Defined in: [src/primitives/Bytes/Bytes8/clone.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/clone.js#L12)
Clone Bytes8
#### Parameters
##### bytes
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Bytes8 to clone
#### Returns
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Cloned Bytes8
#### Example
```typescript theme={null}
const copy = Bytes8.clone(bytes);
```
***
### compare()
> **compare**(`a`, `b`): `-1` | `0` | `1`
Defined in: [src/primitives/Bytes/Bytes8/compare.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/compare.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`-1` | `0` | `1`
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes/Bytes8/equals.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/equals.js#L2)
#### Parameters
##### a
`Uint8Array`\<`ArrayBufferLike`>
##### b
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Defined in: [src/primitives/Bytes/Bytes8/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/from.js#L8)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
***
### fromHex()
> **fromHex**(`hex`): [`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Defined in: [src/primitives/Bytes/Bytes8/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/fromHex.js#L8)
#### Parameters
##### hex
`string`
#### Returns
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
***
### size()
> **size**(`_bytes`): `8`
Defined in: [src/primitives/Bytes/Bytes8/size.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/size.js#L12)
Get size of Bytes8 (always 8)
#### Parameters
##### \_bytes
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Bytes8
#### Returns
`8`
Size (always 8)
#### Example
```typescript theme={null}
const size = Bytes8.size(bytes); // 8
```
***
### toBytes()
> **toBytes**(`bytes`): [`BytesType`](../../primitives/Bytes.mdx#bytestype)
Defined in: [src/primitives/Bytes/Bytes8/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/toBytes.js#L12)
Convert Bytes8 to generic Bytes
#### Parameters
##### bytes
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Bytes8 to convert
#### Returns
[`BytesType`](../../primitives/Bytes.mdx#bytestype)
Generic Bytes
#### Example
```typescript theme={null}
const genericBytes = Bytes8.toBytes(bytes);
```
***
### toHex()
> **toHex**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Bytes/Bytes8/toHex.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/toHex.js#L12)
Convert Bytes8 to hex string
#### Parameters
##### bytes
[`Bytes8Type`](../../primitives/Bytes.mdx#bytes8type)
Bytes8 to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### Example
```typescript theme={null}
const hex = Bytes8.toHex(bytes);
```
## References
### Bytes8Type
Re-exports [Bytes8Type](../../primitives/Bytes.mdx#bytes8type)
# BrandedChain
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedChain
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedChain
# BrandedChain
## Interfaces
### ChainConstructor()
Defined in: [src/primitives/Chain/ChainConstructor.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/ChainConstructor.ts#L6)
Chain constructor type
> **ChainConstructor**(`chain`): `Chain`
Defined in: [src/primitives/Chain/ChainConstructor.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/ChainConstructor.ts#L7)
Chain constructor type
#### Parameters
##### chain
`Chain`
#### Returns
`Chain`
#### Properties
##### byId
> **byId**: `Record`\<`number`, `Chain`>
Defined in: [src/primitives/Chain/ChainConstructor.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/ChainConstructor.ts#L10)
##### from()
> **from**: (`chain`) => `Chain`
Defined in: [src/primitives/Chain/ChainConstructor.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/ChainConstructor.ts#L8)
###### Parameters
###### chain
`Chain`
###### Returns
`Chain`
##### fromId()
> **fromId**: (`id`) => `Chain` | `undefined`
Defined in: [src/primitives/Chain/ChainConstructor.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/ChainConstructor.ts#L9)
###### Parameters
###### id
`number`
###### Returns
`Chain` | `undefined`
## Type Aliases
### Chain
> **Chain**\<> = `Chain`
Defined in: [src/primitives/Chain/Chain.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/Chain.js#L39)
#### Type Parameters
## Variables
### BrandedChain
> `const` **BrandedChain**: `object`
Defined in: [src/primitives/Chain/index.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/index.js#L14)
#### Type Declaration
##### byId
> **byId**: `Record`\<`number`, `Chain`>
Record mapping chain IDs to chain objects
###### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Chain from './primitives/Chain/index.js';
const mainnet = Chain.byId[1];
const optimism = Chain.byId[10];
```
##### from()
> **from**: (`chain`) => `Chain`
Create Chain from a chain object (identity function)
###### Parameters
###### chain
`Chain`
Chain object
###### Returns
`Chain`
Chain object
###### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { mainnet } from '@tevm/chains';
import * as Chain from './primitives/Chain/index.js';
const chain = Chain.from(mainnet);
```
##### fromId()
> **fromId**: (`id`) => `Chain` | `undefined`
Get a chain by its chain ID
###### Parameters
###### id
`number`
Chain ID
###### Returns
`Chain` | `undefined`
Chain object or undefined if not found
###### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Chain from './primitives/Chain/index.js';
const mainnet = Chain.fromId(1);
const optimism = Chain.fromId(10);
```
***
### byId
> `const` **byId**: `Record`\<`number`, `Chain`> = `tevmChainById`
Defined in: [src/primitives/Chain/byId.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/byId.js#L17)
Record mapping chain IDs to chain objects
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Chain from './primitives/Chain/index.js';
const mainnet = Chain.byId[1];
const optimism = Chain.byId[10];
```
***
### CHAIN\_METADATA
> `const` **CHAIN\_METADATA**: `Record`\<`number`, `ChainMetadata`>
Defined in: [src/primitives/Chain/metadata.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/metadata.ts#L48)
Metadata for popular chains
***
### DEFAULT\_METADATA
> `const` **DEFAULT\_METADATA**: `ChainMetadata`
Defined in: [src/primitives/Chain/metadata.ts:449](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/metadata.ts#L449)
Default metadata for chains not in the registry
## Functions
### \_from()
> **\_from**(`chain`): `Chain`
Defined in: [src/primitives/Chain/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/from.js#L16)
Create Chain from a chain object (identity function)
#### Parameters
##### chain
`Chain`
Chain object
#### Returns
`Chain`
Chain object
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { mainnet } from '@tevm/chains';
import * as Chain from './primitives/Chain/index.js';
const chain = Chain.from(mainnet);
```
***
### \_fromId()
> **\_fromId**(`id`): `Chain` | `undefined`
Defined in: [src/primitives/Chain/fromId.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/fromId.js#L18)
Get a chain by its chain ID
#### Parameters
##### id
`number`
Chain ID
#### Returns
`Chain` | `undefined`
Chain object or undefined if not found
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Chain from './primitives/Chain/index.js';
const mainnet = Chain.fromId(1);
const optimism = Chain.fromId(10);
```
***
### Chain()
> **Chain**(`chain`): `Chain`
Defined in: [src/primitives/Chain/Chain.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/Chain.js#L39)
Factory function for creating Chain instances
#### Parameters
##### chain
`any`
#### Returns
`Chain`
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { mainnet } from '@tevm/chains';
import * as Chain from './primitives/Chain/index.js';
const chain = Chain.Chain(mainnet);
```
***
### from()
> **from**(`chain`): `Chain`
Defined in: [src/primitives/Chain/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/from.js#L16)
Create Chain from a chain object (identity function)
#### Parameters
##### chain
`Chain`
Chain object
#### Returns
`Chain`
Chain object
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import { mainnet } from '@tevm/chains';
import * as Chain from './primitives/Chain/index.js';
const chain = Chain.from(mainnet);
```
***
### fromId()
> **fromId**(`id`): `Chain` | `undefined`
Defined in: [src/primitives/Chain/fromId.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Chain/fromId.js#L18)
Get a chain by its chain ID
#### Parameters
##### id
`number`
Chain ID
#### Returns
`Chain` | `undefined`
Chain object or undefined if not found
#### See
[https://voltaire.tevm.sh/primitives/chain](https://voltaire.tevm.sh/primitives/chain) for Chain documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Chain from './primitives/Chain/index.js';
const mainnet = Chain.fromId(1);
const optimism = Chain.fromId(10);
```
## References
### \_byId
Renames and re-exports [byId](#byid-2)
# BrandedEther
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedEther
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedEther
# BrandedEther
## Type Aliases
### BrandedEther
> **BrandedEther** = [`EtherType`](#ethertype)
Defined in: [src/primitives/Denomination/EtherType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/EtherType.ts#L12)
***
### EtherType
> **EtherType** = `string` & `object`
Defined in: [src/primitives/Denomination/EtherType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/EtherType.ts#L9)
Branded Ether type - represents Ethereum amounts in ether (10^18 wei)
Uses string to support decimal values like "1.5" or "0.001"
For whole number wei amounts, use WeiType (bigint)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Ether"`
## Variables
### Ether
> `const` **Ether**: `object`
Defined in: [src/primitives/Denomination/ether-index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-index.ts#L19)
#### Type Declaration
##### from()
> **from**: (`value`) => [`EtherType`](#ethertype)
Create Ether from bigint, number, or string
Ether is a string type to support decimal values like "1.5" or "0.001"
###### Parameters
###### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
###### Returns
[`EtherType`](#ethertype)
Ether amount as branded string
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If value is not a valid number
###### Example
```typescript theme={null}
const ether1 = Ether.from(1n); // "1"
const ether2 = Ether.from(1.5); // "1.5"
const ether3 = Ether.from("1.5"); // "1.5"
const ether4 = Ether.from("0.001"); // "0.001"
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`EtherType`](#ethertype)
Convert Gwei to Ether
Converts gwei string to ether string (divides by 10^9).
Alias for Gwei.toEther().
###### Parameters
###### gwei
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string)
###### Returns
[`EtherType`](#ethertype)
Amount in Ether (string)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const ether1 = Ether.fromGwei(Gwei.from("1000000000")); // "1"
const ether2 = Ether.fromGwei(Gwei.from("1500000000")); // "1.5"
```
##### fromWei()
> **fromWei**: (`wei`) => [`EtherType`](#ethertype)
Convert Wei to Ether
Converts bigint wei to decimal string ether value.
Alias for Wei.toEther().
###### Parameters
###### wei
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
###### Returns
[`EtherType`](#ethertype)
Amount in Ether (string with decimal precision)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const ether1 = Ether.fromWei(Wei.from(1000000000000000000n)); // "1"
const ether2 = Ether.fromWei(Wei.from(1500000000000000000n)); // "1.5"
```
##### toGwei()
> **toGwei**: (`ether`) => [`GweiType`](BrandedGwei.mdx#gweitype)
Convert Ether to Gwei
Converts ether string to gwei string (multiplies by 10^9).
###### Parameters
###### ether
[`EtherType`](#ethertype)
Amount in Ether (string)
###### Returns
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const gwei1 = Ether.toGwei(Ether.from("1")); // "1000000000"
const gwei2 = Ether.toGwei(Ether.from("1.5")); // "1500000000"
const gwei3 = Ether.toGwei(Ether.from("0.000000001")); // "1"
```
##### toU256()
> **toU256**: (`ether`) => [`Type`](../../primitives/Uint.mdx#type)
Convert Ether to Uint256 (in Wei)
Converts ether string to wei bigint, then returns as Uint256.
###### Parameters
###### ether
[`EtherType`](#ethertype)
Amount in Ether (string)
###### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value in Wei
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If ether value has more than 18 decimal places
###### Example
```typescript theme={null}
const u256_1 = Ether.toU256(Ether.from("1")); // 1000000000000000000n
const u256_2 = Ether.toU256(Ether.from("1.5")); // 1500000000000000000n
```
##### toWei()
> **toWei**: (`ether`) => [`WeiType`](BrandedWei.mdx#weitype)
Convert Ether to Wei
Parses decimal string and converts to bigint wei value.
###### Parameters
###### ether
[`EtherType`](#ethertype)
Amount in Ether (string, supports decimals like "1.5")
###### Returns
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If ether value has more than 18 decimal places
###### Example
```typescript theme={null}
const wei1 = Ether.toWei(Ether.from("1")); // 1000000000000000000n
const wei2 = Ether.toWei(Ether.from("1.5")); // 1500000000000000000n
const wei3 = Ether.toWei(Ether.from("0.001")); // 1000000000000000n
```
***
### GWEI\_PER\_ETHER
> `const` **GWEI\_PER\_ETHER**: `1000000000n` = `1_000_000_000n`
Defined in: [src/primitives/Denomination/ether-constants.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-constants.ts#L15)
Number of Gwei in one Ether (10^9)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
***
### WEI\_PER\_ETHER
> `const` **WEI\_PER\_ETHER**: `1000000000000000000n` = `1_000_000_000_000_000_000n`
Defined in: [src/primitives/Denomination/ether-constants.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-constants.ts#L7)
Number of Wei in one Ether (10^18)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
## Functions
### from()
> **from**(`value`): [`EtherType`](#ethertype)
Defined in: [src/primitives/Denomination/ether-from.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-from.ts#L21)
Create Ether from bigint, number, or string
Ether is a string type to support decimal values like "1.5" or "0.001"
#### Parameters
##### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
#### Returns
[`EtherType`](#ethertype)
Ether amount as branded string
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If value is not a valid number
#### Example
```typescript theme={null}
const ether1 = Ether.from(1n); // "1"
const ether2 = Ether.from(1.5); // "1.5"
const ether3 = Ether.from("1.5"); // "1.5"
const ether4 = Ether.from("0.001"); // "0.001"
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`EtherType`](#ethertype)
Defined in: [src/primitives/Denomination/ether-fromGwei.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-fromGwei.ts#L22)
Convert Gwei to Ether
Converts gwei string to ether string (divides by 10^9).
Alias for Gwei.toEther().
#### Parameters
##### gwei
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string)
#### Returns
[`EtherType`](#ethertype)
Amount in Ether (string)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const ether1 = Ether.fromGwei(Gwei.from("1000000000")); // "1"
const ether2 = Ether.fromGwei(Gwei.from("1500000000")); // "1.5"
```
***
### fromWei()
> **fromWei**(`wei`): [`EtherType`](#ethertype)
Defined in: [src/primitives/Denomination/ether-fromWei.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-fromWei.ts#L22)
Convert Wei to Ether
Converts bigint wei to decimal string ether value.
Alias for Wei.toEther().
#### Parameters
##### wei
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
#### Returns
[`EtherType`](#ethertype)
Amount in Ether (string with decimal precision)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const ether1 = Ether.fromWei(Wei.from(1000000000000000000n)); // "1"
const ether2 = Ether.fromWei(Wei.from(1500000000000000000n)); // "1.5"
```
***
### toGwei()
> **toGwei**(`ether`): [`GweiType`](BrandedGwei.mdx#gweitype)
Defined in: [src/primitives/Denomination/ether-toGwei.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-toGwei.ts#L23)
Convert Ether to Gwei
Converts ether string to gwei string (multiplies by 10^9).
#### Parameters
##### ether
[`EtherType`](#ethertype)
Amount in Ether (string)
#### Returns
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const gwei1 = Ether.toGwei(Ether.from("1")); // "1000000000"
const gwei2 = Ether.toGwei(Ether.from("1.5")); // "1500000000"
const gwei3 = Ether.toGwei(Ether.from("0.000000001")); // "1"
```
***
### toU256()
> **toU256**(`ether`): [`Type`](../../primitives/Uint.mdx#type)
Defined in: [src/primitives/Denomination/ether-toU256.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-toU256.ts#L21)
Convert Ether to Uint256 (in Wei)
Converts ether string to wei bigint, then returns as Uint256.
#### Parameters
##### ether
[`EtherType`](#ethertype)
Amount in Ether (string)
#### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value in Wei
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If ether value has more than 18 decimal places
#### Example
```typescript theme={null}
const u256_1 = Ether.toU256(Ether.from("1")); // 1000000000000000000n
const u256_2 = Ether.toU256(Ether.from("1.5")); // 1500000000000000000n
```
***
### toWei()
> **toWei**(`ether`): [`WeiType`](BrandedWei.mdx#weitype)
Defined in: [src/primitives/Denomination/ether-toWei.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/ether-toWei.ts#L23)
Convert Ether to Wei
Parses decimal string and converts to bigint wei value.
#### Parameters
##### ether
[`EtherType`](#ethertype)
Amount in Ether (string, supports decimals like "1.5")
#### Returns
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If ether value has more than 18 decimal places
#### Example
```typescript theme={null}
const wei1 = Ether.toWei(Ether.from("1")); // 1000000000000000000n
const wei2 = Ether.toWei(Ether.from("1.5")); // 1500000000000000000n
const wei3 = Ether.toWei(Ether.from("0.001")); // 1000000000000000n
```
# BrandedFeeMarket
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedFeeMarket
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedFeeMarket
# BrandedFeeMarket
## Type Aliases
### BlobTxFee
> **BlobTxFee** = [`TxFee`](#txfee) & `object`
Defined in: [src/primitives/FeeMarket/BlobTxFee.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BlobTxFee.ts#L6)
Calculated blob transaction fee breakdown
#### Type Declaration
##### blobGasPrice
> **blobGasPrice**: `bigint`
Blob gas price paid (wei per blob gas)
##### totalBlobFee
> **totalBlobFee**: `bigint`
Total blob fee (wei)
***
### BlobTxFeeParams
> **BlobTxFeeParams** = [`TxFeeParams`](#txfeeparams) & `object`
Defined in: [src/primitives/FeeMarket/BlobTxFeeParams.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BlobTxFeeParams.ts#L6)
Blob transaction fee parameters (EIP-4844)
#### Type Declaration
##### blobBaseFee
> **blobBaseFee**: `bigint`
Current blob base fee (wei)
##### blobCount
> **blobCount**: `bigint`
Number of blobs in transaction
##### maxFeePerBlobGas
> **maxFeePerBlobGas**: `bigint`
Maximum fee per blob gas (wei)
***
### BrandedState
> **BrandedState** = `object`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L4)
Complete fee market state for a block
#### Properties
##### baseFee
> **baseFee**: `bigint`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L10)
Base fee per gas (wei)
##### blobGasUsed
> **blobGasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L14)
Blob gas used in block
##### excessBlobGas
> **excessBlobGas**: `bigint`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L12)
Excess blob gas accumulated
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L8)
Gas limit of block
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/BrandedState.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BrandedState.ts#L6)
Gas used in block
***
### Eip1559State
> **Eip1559State** = `object`
Defined in: [src/primitives/FeeMarket/Eip1559State.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip1559State.ts#L4)
EIP-1559 specific state
#### Properties
##### baseFee
> **baseFee**: `bigint`
Defined in: [src/primitives/FeeMarket/Eip1559State.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip1559State.ts#L10)
Base fee per gas (wei)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/FeeMarket/Eip1559State.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip1559State.ts#L8)
Gas limit of block
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/Eip1559State.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip1559State.ts#L6)
Gas used in block
***
### Eip4844State
> **Eip4844State** = `object`
Defined in: [src/primitives/FeeMarket/Eip4844State.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip4844State.ts#L4)
EIP-4844 specific state
#### Properties
##### blobGasUsed
> **blobGasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/Eip4844State.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip4844State.ts#L8)
Blob gas used in block
##### excessBlobGas
> **excessBlobGas**: `bigint`
Defined in: [src/primitives/FeeMarket/Eip4844State.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/Eip4844State.ts#L6)
Excess blob gas accumulated
***
### State
> **State** = `object`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L4)
Complete fee market state for a block
#### Properties
##### baseFee
> **baseFee**: `bigint`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L10)
Base fee per gas (wei)
##### blobGasUsed
> **blobGasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L14)
Blob gas used in block
##### excessBlobGas
> **excessBlobGas**: `bigint`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L12)
Excess blob gas accumulated
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L8)
Gas limit of block
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/primitives/FeeMarket/FeeMarketType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarketType.ts#L6)
Gas used in block
***
### TxFee
> **TxFee** = `object`
Defined in: [src/primitives/FeeMarket/TxFee.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFee.ts#L4)
Calculated transaction fee breakdown
#### Properties
##### baseFee
> **baseFee**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFee.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFee.ts#L10)
Base fee paid (wei per gas)
##### effectiveGasPrice
> **effectiveGasPrice**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFee.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFee.ts#L6)
Effective gas price paid (wei per gas)
##### priorityFee
> **priorityFee**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFee.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFee.ts#L8)
Priority fee paid (wei per gas)
***
### TxFeeParams
> **TxFeeParams** = `object`
Defined in: [src/primitives/FeeMarket/TxFeeParams.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFeeParams.ts#L4)
Transaction fee parameters
#### Properties
##### baseFee
> **baseFee**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFeeParams.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFeeParams.ts#L10)
Current block base fee (wei)
##### maxFeePerGas
> **maxFeePerGas**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFeeParams.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFeeParams.ts#L6)
Maximum fee per gas willing to pay (wei)
##### maxPriorityFeePerGas
> **maxPriorityFeePerGas**: `bigint`
Defined in: [src/primitives/FeeMarket/TxFeeParams.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/TxFeeParams.ts#L8)
Maximum priority fee per gas (tip to miner, wei)
## Variables
### Eip1559
> `const` **Eip1559**: `__module` = `Eip1559Constants`
Defined in: [src/primitives/FeeMarket/FeeMarket.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarket.js#L39)
***
### Eip4844
> `const` **Eip4844**: `__module` = `Eip4844Constants`
Defined in: [src/primitives/FeeMarket/FeeMarket.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarket.js#L40)
***
### State
> `const` **State**: `object`
Defined in: [src/primitives/FeeMarket/FeeMarket.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/FeeMarket.js#L83)
State namespace with convenience methods
#### Type Declaration
##### getBlobBaseFee()
> **getBlobBaseFee**: (`this`) => `bigint`
Get current blob base fee
###### Parameters
###### this
[`State`](#state)
###### Returns
`bigint`
##### getGasTarget()
> **getGasTarget**: (`this`) => `bigint`
Get gas target for block
###### Parameters
###### this
[`State`](#state)
###### Returns
`bigint`
##### isAboveBlobGasTarget()
> **isAboveBlobGasTarget**: (`this`) => `boolean`
Check if block is above blob gas target
###### Parameters
###### this
[`State`](#state)
###### Returns
`boolean`
##### isAboveGasTarget()
> **isAboveGasTarget**: (`this`) => `boolean`
Check if block is above gas target
###### Parameters
###### this
[`State`](#state)
###### Returns
`boolean`
##### next()
> **next**: (`this`) => [`State`](#state)
Calculate next block's fee market state
###### Parameters
###### this
[`State`](#state)
###### Returns
[`State`](#state)
## Functions
### BaseFee()
> **BaseFee**(`parentGasUsed`, `parentGasLimit`, `parentBaseFee`): `bigint`
Defined in: [src/primitives/FeeMarket/BaseFee.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BaseFee.js#L29)
Calculate next block's base fee using EIP-1559 formula (constructor form)
Formula:
* gasTarget = gasLimit / 2
* If gasUsed > gasTarget: baseFee increases (up to 12.5%)
* If gasUsed \< gasTarget: baseFee decreases (up to 12.5%)
* If gasUsed == gasTarget: baseFee stays same
* Always: baseFee >= MIN\_BASE\_FEE (7 wei)
#### Parameters
##### parentGasUsed
`bigint`
Gas used in parent block
##### parentGasLimit
`bigint`
Gas limit of parent block
##### parentBaseFee
`bigint`
Base fee of parent block (wei)
#### Returns
`bigint`
Next block's base fee (wei)
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
// Block at target (50% full): base fee unchanged
const baseFee1 = FeeMarket.BaseFee(15_000_000n, 30_000_000n, 1_000_000_000n);
// baseFee1 === 1_000_000_000n
```
***
### BlobBaseFee()
> **BlobBaseFee**(`excessBlobGas`): `bigint`
Defined in: [src/primitives/FeeMarket/BlobBaseFee.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/BlobBaseFee.js#L25)
Calculate blob base fee using EIP-4844 formula (constructor form)
Formula: fakeExponential(MIN\_BLOB\_BASE\_FEE, excessBlobGas, BLOB\_BASE\_FEE\_UPDATE\_FRACTION)
Uses Taylor series to approximate: MIN\_BLOB\_BASE\_FEE \* e^(excessBlobGas / UPDATE\_FRACTION)
#### Parameters
##### excessBlobGas
`bigint`
Excess blob gas from previous blocks
#### Returns
`bigint`
Blob base fee (wei per blob gas)
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
// No excess: minimum fee
const fee1 = FeeMarket.BlobBaseFee(0n);
// fee1 === 1n
```
***
### calculateBlobTxFee()
> **calculateBlobTxFee**(`params`): [`BlobTxFee`](#blobtxfee)
Defined in: [src/primitives/FeeMarket/calculateBlobTxFee.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/calculateBlobTxFee.js#L28)
Calculate blob transaction fee (standard form)
Combines regular gas fee with blob gas fee.
#### Parameters
##### params
[`BlobTxFeeParams`](#blobtxfeeparams)
Blob transaction fee parameters
#### Returns
[`BlobTxFee`](#blobtxfee)
Calculated fee breakdown including blob fees
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const fee = FeeMarket.calculateBlobTxFee({
maxFeePerGas: 2_000_000_000n,
maxPriorityFeePerGas: 1_000_000_000n,
baseFee: 800_000_000n,
maxFeePerBlobGas: 10_000_000n,
blobBaseFee: 5_000_000n,
blobCount: 3n
});
```
***
### calculateExcessBlobGas()
> **calculateExcessBlobGas**(`parentExcessBlobGas`, `parentBlobGasUsed`): `bigint`
Defined in: [src/primitives/FeeMarket/calculateExcessBlobGas.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/calculateExcessBlobGas.js#L23)
Calculate excess blob gas for next block using EIP-4844 formula (standard form)
Formula: max(0, parentExcessBlobGas + parentBlobGasUsed - TARGET\_BLOB\_GAS\_PER\_BLOCK)
#### Parameters
##### parentExcessBlobGas
`bigint`
Excess blob gas from parent block
##### parentBlobGasUsed
`bigint`
Blob gas used in parent block
#### Returns
`bigint`
Excess blob gas for next block
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
// Below target: no excess
const excess1 = FeeMarket.calculateExcessBlobGas(0n, 131072n); // 1 blob
// excess1 === 0n
```
***
### calculateTxFee()
> **calculateTxFee**(`params`): `any`
Defined in: [src/primitives/FeeMarket/calculateTxFee.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/calculateTxFee.js#L25)
Calculate effective transaction fee (standard form)
Formula:
* effectiveGasPrice = min(maxFeePerGas, baseFee + maxPriorityFeePerGas)
* priorityFee = effectiveGasPrice - baseFee
#### Parameters
##### params
`any`
Transaction fee parameters
#### Returns
`any`
Calculated fee breakdown
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const fee = FeeMarket.calculateTxFee({
maxFeePerGas: 2_000_000_000n,
maxPriorityFeePerGas: 1_000_000_000n,
baseFee: 800_000_000n
});
```
***
### canIncludeTx()
> **canIncludeTx**(`params`): `boolean`
Defined in: [src/primitives/FeeMarket/canIncludeTx.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/canIncludeTx.js#L25)
Check if transaction can be included in block (standard form)
Transaction is valid if:
* maxFeePerGas >= baseFee
* For blob txs: maxFeePerBlobGas >= blobBaseFee
#### Parameters
##### params
`any`
Transaction fee parameters
#### Returns
`boolean`
true if transaction meets minimum fee requirements
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const canInclude = FeeMarket.canIncludeTx({
maxFeePerGas: 1_000_000_000n,
maxPriorityFeePerGas: 100_000_000n,
baseFee: 900_000_000n
});
```
***
### gweiToWei()
> **gweiToWei**(`gwei`): `bigint`
Defined in: [src/primitives/FeeMarket/gweiToWei.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/gweiToWei.js#L17)
Convert gwei to wei
#### Parameters
##### gwei
`number`
Amount in gwei
#### Returns
`bigint`
Amount in wei
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const wei = FeeMarket.gweiToWei(1.5); // 1_500_000_000n
```
***
### nextState()
> **nextState**(`state`): [`State`](#state)
Defined in: [src/primitives/FeeMarket/nextState.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/nextState.js#L28)
Calculate next block's fee market state (standard form)
Updates both EIP-1559 base fee and EIP-4844 blob base fee components.
#### Parameters
##### state
[`State`](#state)
Current block state
#### Returns
[`State`](#state)
Next block's state
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const currentState = {
gasUsed: 20_000_000n,
gasLimit: 30_000_000n,
baseFee: 1_000_000_000n,
excessBlobGas: 0n,
blobGasUsed: 262144n
};
const next = FeeMarket.nextState(currentState);
```
***
### projectBaseFees()
> **projectBaseFees**(`initialState`, `blocks`, `avgGasUsed`, `avgBlobGasUsed?`): `bigint`\[]
Defined in: [src/primitives/FeeMarket/projectBaseFees.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/projectBaseFees.js#L29)
Calculate series of future base fees (standard form)
Useful for estimating fee trends over multiple blocks.
#### Parameters
##### initialState
[`State`](#state)
Starting state
##### blocks
`number`
Number of blocks to project
##### avgGasUsed
`bigint`
Average gas used per block
##### avgBlobGasUsed?
`bigint` = `0n`
Average blob gas used per block
#### Returns
`bigint`\[]
Array of future base fees
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const fees = FeeMarket.projectBaseFees(
{ gasUsed: 15_000_000n, gasLimit: 30_000_000n, baseFee: 1_000_000_000n,
excessBlobGas: 0n, blobGasUsed: 0n },
10,
25_000_000n,
262144n
);
```
***
### validateState()
> **validateState**(`state`): `string`\[]
Defined in: [src/primitives/FeeMarket/validateState.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/validateState.js#L20)
Validate block state
#### Parameters
##### state
[`State`](#state)
Block state
#### Returns
`string`\[]
Validation errors, empty array if valid
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const state = { gasUsed: 0n, gasLimit: 30000000n, baseFee: 1000000000n, excessBlobGas: 0n, blobGasUsed: 0n };
const errors = FeeMarket.validateState(state);
```
***
### validateTxFeeParams()
> **validateTxFeeParams**(`params`): `string`\[]
Defined in: [src/primitives/FeeMarket/validateTxFeeParams.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/validateTxFeeParams.js#L22)
Validate transaction fee parameters
#### Parameters
##### params
`any`
Transaction fee parameters
#### Returns
`string`\[]
Validation errors, empty array if valid
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const errors = FeeMarket.validateTxFeeParams({
maxFeePerGas: 2000000000n,
maxPriorityFeePerGas: 1000000000n,
baseFee: 800000000n
});
```
***
### weiToGwei()
> **weiToGwei**(`wei`): `string`
Defined in: [src/primitives/FeeMarket/weiToGwei.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeMarket/weiToGwei.js#L17)
Convert wei to gwei for display
#### Parameters
##### wei
`bigint`
Amount in wei
#### Returns
`string`
Amount in gwei (formatted with 9 decimal places)
#### See
[https://voltaire.tevm.sh/primitives/feemarket](https://voltaire.tevm.sh/primitives/feemarket) for FeeMarket documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as FeeMarket from './primitives/FeeMarket/index.js';
const gwei = FeeMarket.weiToGwei(1_500_000_000n); // "1.500000000"
```
## References
### FeeMarketType
Renames and re-exports [State](#state)
# BrandedGwei
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedGwei
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedGwei
# BrandedGwei
## Type Aliases
### BrandedGwei
> **BrandedGwei** = [`GweiType`](#gweitype)
Defined in: [src/primitives/Denomination/GweiType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/GweiType.ts#L12)
***
### GweiType
> **GweiType** = `string` & `object`
Defined in: [src/primitives/Denomination/GweiType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/GweiType.ts#L9)
Branded Gwei type - represents Ethereum amounts in gwei (10^9 wei = 10^-9 ETH)
Uses string to support decimal values like "1.5" or "0.001"
For whole number wei amounts, use WeiType (bigint)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Gwei"`
## Variables
### Gwei
> `const` **Gwei**: `object`
Defined in: [src/primitives/Denomination/gwei-index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-index.ts#L19)
#### Type Declaration
##### from()
> **from**: (`value`) => [`GweiType`](#gweitype)
Create Gwei from bigint, number, or string
Gwei is a string type to support decimal values like "1.5" or "0.001"
###### Parameters
###### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
###### Returns
[`GweiType`](#gweitype)
Gwei amount as branded string
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If value is not a valid number
###### Example
```typescript theme={null}
const gwei1 = Gwei.from(1n); // "1"
const gwei2 = Gwei.from(1.5); // "1.5"
const gwei3 = Gwei.from("1.5"); // "1.5"
const gwei4 = Gwei.from("0.001"); // "0.001"
```
##### fromEther()
> **fromEther**: (`ether`) => [`GweiType`](#gweitype)
Convert Ether to Gwei
Converts ether string to gwei string (multiplies by 10^9).
Alias for Ether.toGwei().
###### Parameters
###### ether
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string)
###### Returns
[`GweiType`](#gweitype)
Amount in Gwei (string)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const gwei1 = Gwei.fromEther(Ether.from("1")); // "1000000000"
const gwei2 = Gwei.fromEther(Ether.from("1.5")); // "1500000000"
```
##### fromWei()
> **fromWei**: (`wei`) => [`GweiType`](#gweitype)
Convert Wei to Gwei
Converts bigint wei to decimal string gwei value.
Alias for Wei.toGwei().
###### Parameters
###### wei
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
###### Returns
[`GweiType`](#gweitype)
Amount in Gwei (string with decimal precision)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const gwei1 = Gwei.fromWei(Wei.from(5000000000n)); // "5"
const gwei2 = Gwei.fromWei(Wei.from(1500000000n)); // "1.5"
```
##### toEther()
> **toEther**: (`gwei`) => [`EtherType`](BrandedEther.mdx#ethertype)
Convert Gwei to Ether
Converts gwei string to ether string (divides by 10^9).
###### Parameters
###### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string)
###### Returns
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const ether1 = Gwei.toEther(Gwei.from("1000000000")); // "1"
const ether2 = Gwei.toEther(Gwei.from("1500000000")); // "1.5"
const ether3 = Gwei.toEther(Gwei.from("1")); // "0.000000001"
```
##### toU256()
> **toU256**: (`gwei`) => [`Type`](../../primitives/Uint.mdx#type)
Convert Gwei to Uint256 (in Wei)
Converts gwei string to wei bigint, then returns as Uint256.
###### Parameters
###### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string)
###### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value in Wei
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If gwei value has more than 9 decimal places
###### Example
```typescript theme={null}
const u256_1 = Gwei.toU256(Gwei.from("5")); // 5000000000n
const u256_2 = Gwei.toU256(Gwei.from("1.5")); // 1500000000n
```
##### toWei()
> **toWei**: (`gwei`) => [`WeiType`](BrandedWei.mdx#weitype)
Convert Gwei to Wei
Parses decimal gwei string and converts to bigint wei value.
###### Parameters
###### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string, supports decimals like "1.5")
###### Returns
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If gwei value has more than 9 decimal places
###### Example
```typescript theme={null}
const wei1 = Gwei.toWei(Gwei.from("5")); // 5000000000n
const wei2 = Gwei.toWei(Gwei.from("1.5")); // 1500000000n
const wei3 = Gwei.toWei(Gwei.from("0.001")); // 1000000n
```
***
### GWEI\_PER\_ETHER
> `const` **GWEI\_PER\_ETHER**: `1000000000n` = `1_000_000_000n`
Defined in: [src/primitives/Denomination/gwei-constants.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-constants.ts#L15)
Number of Gwei in one Ether (10^9)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
***
### WEI\_PER\_GWEI
> `const` **WEI\_PER\_GWEI**: `1000000000n` = `1_000_000_000n`
Defined in: [src/primitives/Denomination/gwei-constants.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-constants.ts#L7)
Number of Wei in one Gwei (10^9)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
## Functions
### from()
> **from**(`value`): [`GweiType`](#gweitype)
Defined in: [src/primitives/Denomination/gwei-from.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-from.ts#L21)
Create Gwei from bigint, number, or string
Gwei is a string type to support decimal values like "1.5" or "0.001"
#### Parameters
##### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
#### Returns
[`GweiType`](#gweitype)
Gwei amount as branded string
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If value is not a valid number
#### Example
```typescript theme={null}
const gwei1 = Gwei.from(1n); // "1"
const gwei2 = Gwei.from(1.5); // "1.5"
const gwei3 = Gwei.from("1.5"); // "1.5"
const gwei4 = Gwei.from("0.001"); // "0.001"
```
***
### fromEther()
> **fromEther**(`ether`): [`GweiType`](#gweitype)
Defined in: [src/primitives/Denomination/gwei-fromEther.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-fromEther.ts#L22)
Convert Ether to Gwei
Converts ether string to gwei string (multiplies by 10^9).
Alias for Ether.toGwei().
#### Parameters
##### ether
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string)
#### Returns
[`GweiType`](#gweitype)
Amount in Gwei (string)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const gwei1 = Gwei.fromEther(Ether.from("1")); // "1000000000"
const gwei2 = Gwei.fromEther(Ether.from("1.5")); // "1500000000"
```
***
### fromWei()
> **fromWei**(`wei`): [`GweiType`](#gweitype)
Defined in: [src/primitives/Denomination/gwei-fromWei.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-fromWei.ts#L22)
Convert Wei to Gwei
Converts bigint wei to decimal string gwei value.
Alias for Wei.toGwei().
#### Parameters
##### wei
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
#### Returns
[`GweiType`](#gweitype)
Amount in Gwei (string with decimal precision)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const gwei1 = Gwei.fromWei(Wei.from(5000000000n)); // "5"
const gwei2 = Gwei.fromWei(Wei.from(1500000000n)); // "1.5"
```
***
### toEther()
> **toEther**(`gwei`): [`EtherType`](BrandedEther.mdx#ethertype)
Defined in: [src/primitives/Denomination/gwei-toEther.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-toEther.ts#L23)
Convert Gwei to Ether
Converts gwei string to ether string (divides by 10^9).
#### Parameters
##### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string)
#### Returns
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const ether1 = Gwei.toEther(Gwei.from("1000000000")); // "1"
const ether2 = Gwei.toEther(Gwei.from("1500000000")); // "1.5"
const ether3 = Gwei.toEther(Gwei.from("1")); // "0.000000001"
```
***
### toU256()
> **toU256**(`gwei`): [`Type`](../../primitives/Uint.mdx#type)
Defined in: [src/primitives/Denomination/gwei-toU256.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-toU256.ts#L21)
Convert Gwei to Uint256 (in Wei)
Converts gwei string to wei bigint, then returns as Uint256.
#### Parameters
##### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string)
#### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value in Wei
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If gwei value has more than 9 decimal places
#### Example
```typescript theme={null}
const u256_1 = Gwei.toU256(Gwei.from("5")); // 5000000000n
const u256_2 = Gwei.toU256(Gwei.from("1.5")); // 1500000000n
```
***
### toWei()
> **toWei**(`gwei`): [`WeiType`](BrandedWei.mdx#weitype)
Defined in: [src/primitives/Denomination/gwei-toWei.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/gwei-toWei.ts#L23)
Convert Gwei to Wei
Parses decimal gwei string and converts to bigint wei value.
#### Parameters
##### gwei
[`GweiType`](#gweitype)
Amount in Gwei (string, supports decimals like "1.5")
#### Returns
[`WeiType`](BrandedWei.mdx#weitype)
Amount in Wei (bigint)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If gwei value has more than 9 decimal places
#### Example
```typescript theme={null}
const wei1 = Gwei.toWei(Gwei.from("5")); // 5000000000n
const wei2 = Gwei.toWei(Gwei.from("1.5")); // 1500000000n
const wei3 = Gwei.toWei(Gwei.from("0.001")); // 1000000n
```
# BrandedHex
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedHex
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedHex
# BrandedHex
## Variables
### BrandedHex
> `const` **BrandedHex**: `object`
Defined in: [src/primitives/Hex/internal-index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/internal-index.ts#L63)
#### Type Declaration
##### assertSize()
> **assertSize**: \<`TSize`>(`hex`, `targetSize`) => [`Sized`](../../primitives/Hex.mdx#sized)\<`TSize`>
Assert hex has specific size
###### Type Parameters
###### TSize
`TSize` *extends* `number`
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to check
###### targetSize
`TSize`
Expected byte size
###### Returns
[`Sized`](../../primitives/Hex.mdx#sized)\<`TSize`>
Sized hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If size doesn't match
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const sized = Hex.assertSize(hex, 2); // Sized<2>
```
##### clone()
> **clone**: (`hex`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Create a copy of a Hex string
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to clone
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Copy of the hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex1 = Hex.from("0x1234");
const hex2 = Hex.clone(hex1);
console.log(Hex.equals(hex1, hex2)); // true
```
##### concat()
> **concat**: (...`hexes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Concatenate multiple hex strings
###### Parameters
###### hexes
...[`HexType`](../../primitives/Hex.mdx#hextype)\[]
Hex strings to concatenate
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Concatenated hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.concat('0x12', '0x34', '0x56'); // '0x123456'
```
##### equals()
> **equals**: (`hex`, `other`) => `boolean`
Check if two hex strings are equal
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
First hex string
###### other
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to compare with
###### Returns
`boolean`
True if equal
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.equals(hex, Hex.from('0x1234')); // true
```
##### from()
> **from**: (`value`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Create Hex from string or bytes
###### Parameters
###### value
Hex string or bytes
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const hex2 = Hex.from(new Uint8Array([0x12, 0x34]));
```
##### fromBigInt()
> **fromBigInt**: (`value`, `size?`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert bigint to hex
###### Parameters
###### value
`bigint`
BigInt to convert
###### size?
`number`
Optional byte size for padding
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromBigInt(255n); // '0xff'
Hex.fromBigInt(255n, 32); // '0x00...00ff' (32 bytes)
```
##### fromBoolean()
> **fromBoolean**: (`value`) => [`Sized`](../../primitives/Hex.mdx#sized)\<`1`>
Convert boolean to hex
###### Parameters
###### value
`boolean`
Boolean to convert
###### Returns
[`Sized`](../../primitives/Hex.mdx#sized)\<`1`>
Hex string ('0x01' for true, '0x00' for false)
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromBoolean(true); // '0x01'
Hex.fromBoolean(false); // '0x00'
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert bytes to hex
###### Parameters
###### bytes
`Uint8Array`
Byte array to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.fromBytes(new Uint8Array([0x12, 0x34])); // '0x1234'
```
##### fromNumber()
> **fromNumber**: (`value`, `size?`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert number to hex
###### Parameters
###### value
`number`
Number to convert (must be safe integer)
###### size?
`number`
Optional byte size for padding
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or is negative
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromNumber(255); // '0xff'
Hex.fromNumber(255, 2); // '0x00ff'
Hex.fromNumber(0x1234); // '0x1234'
```
##### fromString()
> **fromString**: (`str`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Convert string to hex
###### Parameters
###### str
`string`
String to convert
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromString('hello'); // '0x68656c6c6f'
```
##### isHex()
> **isHex**: (`value`) => `value is HexType`
Check if string is valid hex
###### Parameters
###### value
`string`
String to validate
###### Returns
`value is HexType`
True if valid hex format
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.isHex('0x1234'); // true
Hex.isHex('1234'); // false
Hex.isHex('0xZZZZ'); // false
```
##### isSized()
> **isSized**: \<`TSize`>(`hex`, `targetSize`) => `hex is Sized`
Check if hex has specific byte size
###### Type Parameters
###### TSize
`TSize` *extends* `number`
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to check
###### targetSize
`TSize`
Expected size in bytes
###### Returns
`hex is Sized`
True if size matches
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.isSized(hex, 2); // true
```
##### pad()
> **pad**: (`hex`, `targetSize`) => `string`
Pad hex to target size (left-padded with zeros)
###### Parameters
###### hex
`string`
Hex string to pad
###### targetSize
`number`
Target size in bytes
###### Returns
`string`
Padded hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If hex exceeds target size
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const padded = Hex.pad(hex, 4); // '0x00001234'
Hex.pad('0x1234', 1); // throws Error (2 bytes > 1 byte target)
```
##### padRight()
> **padRight**: (`hex`, `targetSize`) => `string`
Pad hex to right (suffix with zeros)
###### Parameters
###### hex
`string`
Hex string to pad
###### targetSize
`number`
Target size in bytes
###### Returns
`string`
Right-padded hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const padded = Hex.padRight(hex, 4); // '0x12340000'
```
##### random()
> **random**: (`size`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Generate random hex of specific size
###### Parameters
###### size
`number`
Size in bytes
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Random hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const random = Hex.random(32); // random 32-byte hex
```
##### size()
> **size**: (`hex`) => `number`
Get byte size of hex
###### Parameters
###### hex
`string`
Hex string
###### Returns
`number`
Size in bytes
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.size(hex); // 2
```
##### slice()
> **slice**: (`hex`, `start`, `end?`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Slice hex string
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to slice
###### start
`number`
Start byte index
###### end?
`number`
End byte index (optional)
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Sliced hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x123456');
const sliced = Hex.slice(hex, 1); // '0x3456'
```
##### toBigInt()
> **toBigInt**: (`hex`) => `bigint`
Convert hex to bigint
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
###### Returns
`bigint`
BigInt value
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0xff');
const big = Hex.toBigInt(hex); // 255n
```
##### toBoolean()
> **toBoolean**: (`hex`) => `boolean`
Convert hex to boolean (strict: only 0x0/0x00 or 0x1/0x01 are valid)
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
###### Returns
`boolean`
Boolean value (true for 0x1/0x01, false for 0x0/0x00)
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If hex is not a valid boolean value (only 0 or 1 allowed)
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x01');
const bool = Hex.toBoolean(hex); // true
Hex.toBoolean('0x00'); // false
Hex.toBoolean('0x02'); // throws Error
```
##### toBytes()
> **toBytes**: (`hex`) => `Uint8Array`
Convert hex to bytes
###### Parameters
###### hex
Hex string to convert
`string` | [`HexType`](../../primitives/Hex.mdx#hextype)
###### Returns
`Uint8Array`
Byte array
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const bytes = Hex.toBytes(hex); // Uint8Array([0x12, 0x34])
```
##### toNumber()
> **toNumber**: (`hex`) => `number`
Convert hex to number
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
###### Returns
`number`
Number value
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If hex represents value larger than MAX\_SAFE\_INTEGER
###### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0xff');
const num = Hex.toNumber(hex); // 255
```
##### toString()
> **toString**: (`hex`) => `string`
Convert hex to string
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
###### Returns
`string`
Decoded string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x68656c6c6f');
const str = Hex.toString(hex); // 'hello'
```
##### trim()
> **trim**: (`hex`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Trim leading zeros from hex
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to trim
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Trimmed hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x00001234');
const trimmed = Hex.trim(hex); // '0x1234'
```
##### validate()
> **validate**: (`value`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Validate hex string
###### Parameters
###### value
`string`
String to validate as hex
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Validated hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.validate('0x1234'); // HexType
```
##### xor()
> **xor**: (`hex`, `other`) => [`HexType`](../../primitives/Hex.mdx#hextype)
XOR with another hex string of same length
###### Parameters
###### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
First hex string
###### other
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to XOR with
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
XOR result
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
If missing 0x prefix or contains invalid hex characters
###### Throws
If hex has odd number of digits or lengths don't match
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x12');
const result = Hex.xor(hex, Hex.from('0x34')); // '0x26'
```
##### zero()
> **zero**: (`size`) => [`HexType`](../../primitives/Hex.mdx#hextype)
Create zero-filled hex of specific size
###### Parameters
###### size
`number`
Size in bytes
###### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Zero-filled hex string
###### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.zero(4); // '0x00000000'
```
## Functions
### assertSize()
> **assertSize**\<`TSize`>(`hex`, `targetSize`): [`Sized`](../../primitives/Hex.mdx#sized)\<`TSize`>
Defined in: [src/primitives/Hex/assertSize.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/assertSize.ts#L20)
Assert hex has specific size
#### Type Parameters
##### TSize
`TSize` *extends* `number`
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to check
##### targetSize
`TSize`
Expected byte size
#### Returns
[`Sized`](../../primitives/Hex.mdx#sized)\<`TSize`>
Sized hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If size doesn't match
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const sized = Hex.assertSize(hex, 2); // Sized<2>
```
***
### clone()
> **clone**(`hex`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/clone.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/clone.js#L17)
Create a copy of a Hex string
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to clone
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Copy of the hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex1 = Hex.from("0x1234");
const hex2 = Hex.clone(hex1);
console.log(Hex.equals(hex1, hex2)); // true
```
***
### concat()
> **concat**(...`hexes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/concat.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/concat.ts#L21)
Concatenate multiple hex strings
#### Parameters
##### hexes
...[`HexType`](../../primitives/Hex.mdx#hextype)\[]
Hex strings to concatenate
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Concatenated hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.concat('0x12', '0x34', '0x56'); // '0x123456'
```
***
### equals()
> **equals**(`hex`, `other`): `boolean`
Defined in: [src/primitives/Hex/equals.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/equals.ts#L19)
Check if two hex strings are equal
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
First hex string
##### other
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to compare with
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.equals(hex, Hex.from('0x1234')); // true
```
***
### from()
> **from**(`value`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/from.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/from.ts#L19)
Create Hex from string or bytes
#### Parameters
##### value
Hex string or bytes
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const hex2 = Hex.from(new Uint8Array([0x12, 0x34]));
```
***
### fromBigInt()
> **fromBigInt**(`value`, `size?`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/fromBigInt.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/fromBigInt.ts#L19)
Convert bigint to hex
#### Parameters
##### value
`bigint`
BigInt to convert
##### size?
`number`
Optional byte size for padding
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromBigInt(255n); // '0xff'
Hex.fromBigInt(255n, 32); // '0x00...00ff' (32 bytes)
```
***
### fromBoolean()
> **fromBoolean**(`value`): [`Sized`](../../primitives/Hex.mdx#sized)\<`1`>
Defined in: [src/primitives/Hex/fromBoolean.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/fromBoolean.js#L16)
Convert boolean to hex
#### Parameters
##### value
`boolean`
Boolean to convert
#### Returns
[`Sized`](../../primitives/Hex.mdx#sized)\<`1`>
Hex string ('0x01' for true, '0x00' for false)
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromBoolean(true); // '0x01'
Hex.fromBoolean(false); // '0x00'
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/fromBytes.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/fromBytes.ts#L17)
Convert bytes to hex
#### Parameters
##### bytes
`Uint8Array`
Byte array to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.fromBytes(new Uint8Array([0x12, 0x34])); // '0x1234'
```
***
### fromNumber()
> **fromNumber**(`value`, `size?`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/fromNumber.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/fromNumber.js#L18)
Convert number to hex
#### Parameters
##### value
`number`
Number to convert (must be safe integer)
##### size?
`number`
Optional byte size for padding
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or is negative
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromNumber(255); // '0xff'
Hex.fromNumber(255, 2); // '0x00ff'
Hex.fromNumber(0x1234); // '0x1234'
```
***
### fromString()
> **fromString**(`str`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/fromString.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/fromString.ts#L18)
Convert string to hex
#### Parameters
##### str
`string`
String to convert
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.fromString('hello'); // '0x68656c6c6f'
```
***
### isHex()
> **isHex**(`value`): `value is HexType`
Defined in: [src/primitives/Hex/isHex.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/isHex.ts#L20)
Check if string is valid hex
#### Parameters
##### value
`string`
String to validate
#### Returns
`value is HexType`
True if valid hex format
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.isHex('0x1234'); // true
Hex.isHex('1234'); // false
Hex.isHex('0xZZZZ'); // false
```
***
### isSized()
> **isSized**\<`TSize`>(`hex`, `targetSize`): `hex is Sized`
Defined in: [src/primitives/Hex/isSized.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/isSized.ts#L19)
Check if hex has specific byte size
#### Type Parameters
##### TSize
`TSize` *extends* `number`
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to check
##### targetSize
`TSize`
Expected size in bytes
#### Returns
`hex is Sized`
True if size matches
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.isSized(hex, 2); // true
```
***
### pad()
> **pad**(`hex`, `targetSize`): `string`
Defined in: [src/primitives/Hex/pad.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/pad.js#L21)
Pad hex to target size (left-padded with zeros)
#### Parameters
##### hex
`string`
Hex string to pad
##### targetSize
`number`
Target size in bytes
#### Returns
`string`
Padded hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If hex exceeds target size
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const padded = Hex.pad(hex, 4); // '0x00001234'
Hex.pad('0x1234', 1); // throws Error (2 bytes > 1 byte target)
```
***
### padRight()
> **padRight**(`hex`, `targetSize`): `string`
Defined in: [src/primitives/Hex/padRight.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/padRight.js#L20)
Pad hex to right (suffix with zeros)
#### Parameters
##### hex
`string`
Hex string to pad
##### targetSize
`number`
Target size in bytes
#### Returns
`string`
Right-padded hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const padded = Hex.padRight(hex, 4); // '0x12340000'
```
***
### random()
> **random**(`size`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/random.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/random.ts#L18)
Generate random hex of specific size
#### Parameters
##### size
`number`
Size in bytes
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Random hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const random = Hex.random(32); // random 32-byte hex
```
***
### size()
> **size**(`hex`): `number`
Defined in: [src/primitives/Hex/size.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/size.js#L16)
Get byte size of hex
#### Parameters
##### hex
`string`
Hex string
#### Returns
`number`
Size in bytes
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
Hex.size(hex); // 2
```
***
### slice()
> **slice**(`hex`, `start`, `end?`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/slice.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/slice.ts#L24)
Slice hex string
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to slice
##### start
`number`
Start byte index
##### end?
`number`
End byte index (optional)
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Sliced hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x123456');
const sliced = Hex.slice(hex, 1); // '0x3456'
```
***
### toBigInt()
> **toBigInt**(`hex`): `bigint`
Defined in: [src/primitives/Hex/toBigInt.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/toBigInt.ts#L18)
Convert hex to bigint
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
#### Returns
`bigint`
BigInt value
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0xff');
const big = Hex.toBigInt(hex); // 255n
```
***
### toBoolean()
> **toBoolean**(`hex`): `boolean`
Defined in: [src/primitives/Hex/toBoolean.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/toBoolean.js#L20)
Convert hex to boolean (strict: only 0x0/0x00 or 0x1/0x01 are valid)
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
#### Returns
`boolean`
Boolean value (true for 0x1/0x01, false for 0x0/0x00)
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If hex is not a valid boolean value (only 0 or 1 allowed)
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x01');
const bool = Hex.toBoolean(hex); // true
Hex.toBoolean('0x00'); // false
Hex.toBoolean('0x02'); // throws Error
```
***
### toBytes()
> **toBytes**(`hex`): `Uint8Array`
Defined in: [src/primitives/Hex/toBytes.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/toBytes.ts#L21)
Convert hex to bytes
#### Parameters
##### hex
Hex string to convert
`string` | [`HexType`](../../primitives/Hex.mdx#hextype)
#### Returns
`Uint8Array`
Byte array
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const bytes = Hex.toBytes(hex); // Uint8Array([0x12, 0x34])
```
***
### toNumber()
> **toNumber**(`hex`): `number`
Defined in: [src/primitives/Hex/toNumber.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/toNumber.js#L18)
Convert hex to number
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
#### Returns
`number`
Number value
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If hex represents value larger than MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0xff');
const num = Hex.toNumber(hex); // 255
```
***
### toString()
> **toString**(`hex`): `string`
Defined in: [src/primitives/Hex/toString.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/toString.ts#L22)
Convert hex to string
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to convert
#### Returns
`string`
Decoded string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x68656c6c6f');
const str = Hex.toString(hex); // 'hello'
```
***
### trim()
> **trim**(`hex`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/trim.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/trim.ts#L22)
Trim leading zeros from hex
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to trim
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Trimmed hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x00001234');
const trimmed = Hex.trim(hex); // '0x1234'
```
***
### validate()
> **validate**(`value`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/validate.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/validate.ts#L19)
Validate hex string
#### Parameters
##### value
`string`
String to validate as hex
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Validated hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.validate('0x1234'); // HexType
```
***
### xor()
> **xor**(`hex`, `other`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/xor.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/xor.ts#L24)
XOR with another hex string of same length
#### Parameters
##### hex
[`HexType`](../../primitives/Hex.mdx#hextype)
First hex string
##### other
[`HexType`](../../primitives/Hex.mdx#hextype)
Hex string to XOR with
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
XOR result
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits or lengths don't match
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x12');
const result = Hex.xor(hex, Hex.from('0x34')); // '0x26'
```
***
### zero()
> **zero**(`size`): [`HexType`](../../primitives/Hex.mdx#hextype)
Defined in: [src/primitives/Hex/zero.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/zero.ts#L18)
Create zero-filled hex of specific size
#### Parameters
##### size
`number`
Size in bytes
#### Returns
[`HexType`](../../primitives/Hex.mdx#hextype)
Zero-filled hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
Hex.zero(4); // '0x00000000'
```
## References
### HexType
Renames and re-exports [HexBrand](../../primitives/Hex.mdx#hexbrand)
***
### InvalidCharacterError
Re-exports [InvalidCharacterError](../../primitives/Hex.mdx#invalidcharactererror)
***
### InvalidFormatError
Re-exports [InvalidFormatError](../../primitives/Hex.mdx#invalidformaterror)
***
### InvalidHexCharacterError
Re-exports [InvalidHexCharacterError](../../primitives/Hex.mdx#invalidhexcharactererror)
***
### InvalidHexFormatError
Re-exports [InvalidHexFormatError](../../primitives/Hex.mdx#invalidhexformaterror)
***
### InvalidHexLengthError
Re-exports [InvalidHexLengthError](../../primitives/Hex.mdx#invalidhexlengtherror)
***
### InvalidLengthError
Re-exports [InvalidLengthError](../../primitives/Hex.mdx#invalidlengtherror)
***
### OddLengthError
Re-exports [OddLengthError](../../primitives/Hex.mdx#oddlengtherror)
***
### OddLengthHexError
Re-exports [OddLengthHexError](../../primitives/Hex.mdx#oddlengthhexerror)
# BrandedOpcode
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedOpcode
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedOpcode
# BrandedOpcode
## Functions
### \_disassemble()
> **\_disassemble**(`bytecode`): `string`\[]
Defined in: [src/primitives/Opcode/disassemble.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/disassemble.js#L22)
Disassemble bytecode to human-readable strings
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`string`\[]
Array of formatted instruction strings
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const asm = Opcode.disassemble(bytecode);
// [
// "0x0000: PUSH1 0x01",
// "0x0002: PUSH1 0x02",
// "0x0004: ADD"
// ]
```
***
### \_dupPosition()
> **\_dupPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/dupPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/dupPosition.js#L17)
Get position for DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a DUP
#### Example
```typescript theme={null}
Opcode.dupPosition(Opcode.DUP1); // 1
Opcode.dupPosition(Opcode.DUP16); // 16
Opcode.dupPosition(Opcode.ADD); // undefined
```
***
### \_format()
> **\_format**(`instruction`): `string`
Defined in: [src/primitives/Opcode/format.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/format.js#L20)
Format instruction to human-readable string
#### Parameters
##### instruction
[`Instruction`](../../primitives/Opcode.mdx#instruction)
Instruction to format
#### Returns
`string`
Human-readable string
#### Example
```typescript theme={null}
const inst = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42])
};
Opcode.format(inst); // "0x0000: PUSH1 0x42"
```
***
### \_getCategory()
> **\_getCategory**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getCategory.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getCategory.js#L18)
Get opcode category
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Category name
#### Example
```typescript theme={null}
Opcode.getCategory(Opcode.ADD); // "arithmetic"
Opcode.getCategory(Opcode.SSTORE); // "storage"
Opcode.getCategory(Opcode.CALL); // "system"
```
***
### \_getDescription()
> **\_getDescription**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getDescription.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getDescription.js#L140)
Get human-readable description of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Description or generated description for PUSH/DUP/SWAP
#### Example
```typescript theme={null}
const desc = Opcode.getDescription(Opcode.ADD);
// "Addition operation"
const desc2 = Opcode.getDescription(Opcode.PUSH1);
// "Place 1-byte item on stack"
```
***
### \_getGasCost()
> **\_getGasCost**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getGasCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getGasCost.js#L16)
Get static gas cost for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Static gas cost or undefined if invalid
#### Example
```typescript theme={null}
const gas = Opcode.getGasCost(Opcode.ADD); // 3
const gas2 = Opcode.getGasCost(Opcode.SSTORE); // 100 (base cost, may be higher at runtime)
```
***
### \_getName()
> **\_getName**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getName.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getName.js#L16)
Get mnemonic name of an opcode (alias for name)
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.getName(Opcode.ADD); // "ADD"
const name2 = Opcode.getName(0xFF); // "SELFDESTRUCT"
```
***
### \_getPushSize()
> **\_getPushSize**(`opcode`): `number`
Defined in: [src/primitives/Opcode/getPushSize.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getPushSize.js#L18)
Get PUSH data size in bytes
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number`
Push size (0 for PUSH0, 1-32 for PUSH1-PUSH32, 0 for non-PUSH)
#### Example
```typescript theme={null}
Opcode.getPushSize(Opcode.PUSH0); // 0
Opcode.getPushSize(Opcode.PUSH1); // 1
Opcode.getPushSize(Opcode.PUSH32); // 32
Opcode.getPushSize(Opcode.ADD); // 0
```
***
### \_getStackEffect()
> **\_getStackEffect**(`opcode`): \{ `pop`: `number`; `push`: `number`; } | `undefined`
Defined in: [src/primitives/Opcode/getStackEffect.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackEffect.js#L19)
Get stack effect for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
\{ `pop`: `number`; `push`: `number`; } | `undefined`
Stack items consumed and produced
#### Example
```typescript theme={null}
const effect = Opcode.getStackEffect(Opcode.ADD);
// { pop: 2, push: 1 }
const effect2 = Opcode.getStackEffect(Opcode.DUP1);
// { pop: 1, push: 2 }
```
***
### \_getStackInput()
> **\_getStackInput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackInput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackInput.js#L16)
Get number of stack items consumed by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items consumed
#### Example
```typescript theme={null}
const inputs = Opcode.getStackInput(Opcode.ADD); // 2
const inputs2 = Opcode.getStackInput(Opcode.PUSH1); // 0
```
***
### \_getStackOutput()
> **\_getStackOutput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackOutput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackOutput.js#L16)
Get number of stack items produced by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items produced
#### Example
```typescript theme={null}
const outputs = Opcode.getStackOutput(Opcode.ADD); // 1
const outputs2 = Opcode.getStackOutput(Opcode.PUSH1); // 1
```
***
### \_info()
> **\_info**(`opcode`): [`Info`](../../primitives/Opcode.mdx#info) | `undefined`
Defined in: [src/primitives/Opcode/info.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/info.js#L17)
Get metadata for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
[`Info`](../../primitives/Opcode.mdx#info) | `undefined`
Metadata with gas cost and stack requirements
#### Example
```typescript theme={null}
const info = Opcode.info(Opcode.ADD);
console.log(info?.name); // "ADD"
console.log(info?.gasCost); // 3
```
***
### \_isDup()
> **\_isDup**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isDup.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isDup.js#L16)
Check if opcode is a DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if DUP1-DUP16
#### Example
```typescript theme={null}
Opcode.isDup(Opcode.DUP1); // true
Opcode.isDup(Opcode.ADD); // false
```
***
### \_isJump()
> **\_isJump**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJump.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJump.js#L17)
Check if opcode is a jump
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMP or JUMPI
#### Example
```typescript theme={null}
Opcode.isJump(Opcode.JUMP); // true
Opcode.isJump(Opcode.JUMPI); // true
Opcode.isJump(Opcode.ADD); // false
```
***
### \_isJumpDestination()
> **\_isJumpDestination**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJumpDestination.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJumpDestination.js#L16)
Check if opcode is JUMPDEST
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMPDEST
#### Example
```typescript theme={null}
Opcode.isJumpDestination(Opcode.JUMPDEST); // true
Opcode.isJumpDestination(Opcode.JUMP); // false
```
***
### \_isLog()
> **\_isLog**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isLog.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isLog.js#L16)
Check if opcode is a LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if LOG0-LOG4
#### Example
```typescript theme={null}
Opcode.isLog(Opcode.LOG1); // true
Opcode.isLog(Opcode.ADD); // false
```
***
### \_isPush()
> **\_isPush**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isPush.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isPush.js#L16)
Check if opcode is a PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if PUSH0-PUSH32
#### Example
```typescript theme={null}
Opcode.isPush(Opcode.PUSH1); // true
Opcode.isPush(Opcode.ADD); // false
```
***
### \_isSwap()
> **\_isSwap**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isSwap.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isSwap.js#L16)
Check if opcode is a SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if SWAP1-SWAP16
#### Example
```typescript theme={null}
Opcode.isSwap(Opcode.SWAP1); // true
Opcode.isSwap(Opcode.ADD); // false
```
***
### \_isTerminating()
> **\_isTerminating**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminating.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminating.js#L16)
Check if opcode terminates execution
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminating(Opcode.RETURN); // true
Opcode.isTerminating(Opcode.ADD); // false
```
***
### \_isTerminator()
> **\_isTerminator**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminator.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminator.js#L16)
Check if opcode terminates execution (alias for isTerminating)
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminator(Opcode.RETURN); // true
Opcode.isTerminator(Opcode.ADD); // false
```
***
### \_isValid()
> **\_isValid**(`opcode`): `opcode is BrandedOpcode`
Defined in: [src/primitives/Opcode/isValid.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValid.js#L16)
Check if opcode is valid
#### Parameters
##### opcode
`number`
Byte value to check
#### Returns
`opcode is BrandedOpcode`
True if opcode is defined in the EVM
#### Example
```typescript theme={null}
Opcode.isValid(0x01); // true (ADD)
Opcode.isValid(0x0c); // false (undefined)
```
***
### \_isValidJumpDest()
> **\_isValidJumpDest**(`bytecode`, `offset`): `boolean`
Defined in: [src/primitives/Opcode/isValidJumpDest.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidJumpDest.js#L18)
Check if offset is a valid jump destination
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
##### offset
`number`
Byte offset to check
#### Returns
`boolean`
True if offset is a JUMPDEST and not inside immediate data
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01]);
Opcode.isValidJumpDest(bytecode, 0); // true (JUMPDEST)
Opcode.isValidJumpDest(bytecode, 2); // false (immediate data)
```
***
### \_isValidOpcode()
> **\_isValidOpcode**(`value`): `boolean`
Defined in: [src/primitives/Opcode/isValidOpcode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidOpcode.js#L17)
Check if value is a valid opcode (alias for isValid)
#### Parameters
##### value
`number`
Value to check
#### Returns
`boolean`
True if valid opcode
#### Example
```typescript theme={null}
Opcode.isValidOpcode(0x01); // true (ADD)
Opcode.isValidOpcode(0xFF); // true (SELFDESTRUCT)
Opcode.isValidOpcode(0x0C); // false
```
***
### \_jumpDests()
> **\_jumpDests**(`bytecode`): `Set`\<`number`>
Defined in: [src/primitives/Opcode/jumpDests.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/jumpDests.js#L17)
Find all valid JUMPDEST locations
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`Set`\<`number`>
Set of valid jump destinations (byte offsets)
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01, 0x5b]);
const dests = Opcode.jumpDests(bytecode); // Set { 0, 3 }
```
***
### \_logTopics()
> **\_logTopics**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/logTopics.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/logTopics.js#L17)
Get number of topics for LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of topics (0-4), or undefined if not a LOG
#### Example
```typescript theme={null}
Opcode.logTopics(Opcode.LOG0); // 0
Opcode.logTopics(Opcode.LOG4); // 4
Opcode.logTopics(Opcode.ADD); // undefined
```
***
### \_name()
> **\_name**(`opcode`): `string`
Defined in: [src/primitives/Opcode/name.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/name.js#L15)
Get name of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.name(Opcode.ADD); // "ADD"
```
***
### \_parse()
> **\_parse**(`bytecode`): [`Instruction`](../../primitives/Opcode.mdx#instruction)\[]
Defined in: [src/primitives/Opcode/parse.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/parse.js#L21)
Parse bytecode into instructions
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
[`Instruction`](../../primitives/Opcode.mdx#instruction)\[]
Array of parsed instructions
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const instructions = Opcode.parse(bytecode);
// [
// { offset: 0, opcode: PUSH1, immediate: [0x01] },
// { offset: 2, opcode: PUSH1, immediate: [0x02] },
// { offset: 4, opcode: ADD }
// ]
```
***
### \_pushBytes()
> **\_pushBytes**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/pushBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushBytes.js#L18)
Get number of bytes pushed by PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of bytes (0-32), or undefined if not a PUSH
#### Example
```typescript theme={null}
Opcode.pushBytes(Opcode.PUSH1); // 1
Opcode.pushBytes(Opcode.PUSH32); // 32
Opcode.pushBytes(Opcode.PUSH0); // 0
Opcode.pushBytes(Opcode.ADD); // undefined
```
***
### \_pushOpcode()
> **\_pushOpcode**(`bytes`): [`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Defined in: [src/primitives/Opcode/pushOpcode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushOpcode.js#L19)
Get PUSH opcode for given byte count
#### Parameters
##### bytes
`number`
Number of bytes (0-32)
#### Returns
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
PUSH opcode for that size
#### Throws
If bytes is not 0-32
#### Example
```typescript theme={null}
Opcode.pushOpcode(1); // Opcode.PUSH1
Opcode.pushOpcode(32); // Opcode.PUSH32
Opcode.pushOpcode(0); // Opcode.PUSH0
```
***
### \_swapPosition()
> **\_swapPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/swapPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/swapPosition.js#L17)
Get position for SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a SWAP
#### Example
```typescript theme={null}
Opcode.swapPosition(Opcode.SWAP1); // 1
Opcode.swapPosition(Opcode.SWAP16); // 16
Opcode.swapPosition(Opcode.ADD); // undefined
```
***
### disassemble()
> **disassemble**(`bytecode`): `string`\[]
Defined in: [src/primitives/Opcode/disassemble.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/disassemble.js#L22)
Disassemble bytecode to human-readable strings
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`string`\[]
Array of formatted instruction strings
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const asm = Opcode.disassemble(bytecode);
// [
// "0x0000: PUSH1 0x01",
// "0x0002: PUSH1 0x02",
// "0x0004: ADD"
// ]
```
***
### dupPosition()
> **dupPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/dupPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/dupPosition.js#L17)
Get position for DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a DUP
#### Example
```typescript theme={null}
Opcode.dupPosition(Opcode.DUP1); // 1
Opcode.dupPosition(Opcode.DUP16); // 16
Opcode.dupPosition(Opcode.ADD); // undefined
```
***
### format()
> **format**(`instruction`): `string`
Defined in: [src/primitives/Opcode/format.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/format.js#L20)
Format instruction to human-readable string
#### Parameters
##### instruction
[`Instruction`](../../primitives/Opcode.mdx#instruction)
Instruction to format
#### Returns
`string`
Human-readable string
#### Example
```typescript theme={null}
const inst = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42])
};
Opcode.format(inst); // "0x0000: PUSH1 0x42"
```
***
### getCategory()
> **getCategory**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getCategory.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getCategory.js#L18)
Get opcode category
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Category name
#### Example
```typescript theme={null}
Opcode.getCategory(Opcode.ADD); // "arithmetic"
Opcode.getCategory(Opcode.SSTORE); // "storage"
Opcode.getCategory(Opcode.CALL); // "system"
```
***
### getDescription()
> **getDescription**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getDescription.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getDescription.js#L140)
Get human-readable description of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Description or generated description for PUSH/DUP/SWAP
#### Example
```typescript theme={null}
const desc = Opcode.getDescription(Opcode.ADD);
// "Addition operation"
const desc2 = Opcode.getDescription(Opcode.PUSH1);
// "Place 1-byte item on stack"
```
***
### getGasCost()
> **getGasCost**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getGasCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getGasCost.js#L16)
Get static gas cost for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Static gas cost or undefined if invalid
#### Example
```typescript theme={null}
const gas = Opcode.getGasCost(Opcode.ADD); // 3
const gas2 = Opcode.getGasCost(Opcode.SSTORE); // 100 (base cost, may be higher at runtime)
```
***
### getName()
> **getName**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getName.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getName.js#L16)
Get mnemonic name of an opcode (alias for name)
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.getName(Opcode.ADD); // "ADD"
const name2 = Opcode.getName(0xFF); // "SELFDESTRUCT"
```
***
### getPushSize()
> **getPushSize**(`opcode`): `number`
Defined in: [src/primitives/Opcode/getPushSize.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getPushSize.js#L18)
Get PUSH data size in bytes
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number`
Push size (0 for PUSH0, 1-32 for PUSH1-PUSH32, 0 for non-PUSH)
#### Example
```typescript theme={null}
Opcode.getPushSize(Opcode.PUSH0); // 0
Opcode.getPushSize(Opcode.PUSH1); // 1
Opcode.getPushSize(Opcode.PUSH32); // 32
Opcode.getPushSize(Opcode.ADD); // 0
```
***
### getStackEffect()
> **getStackEffect**(`opcode`): \{ `pop`: `number`; `push`: `number`; } | `undefined`
Defined in: [src/primitives/Opcode/getStackEffect.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackEffect.js#L19)
Get stack effect for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
\{ `pop`: `number`; `push`: `number`; } | `undefined`
Stack items consumed and produced
#### Example
```typescript theme={null}
const effect = Opcode.getStackEffect(Opcode.ADD);
// { pop: 2, push: 1 }
const effect2 = Opcode.getStackEffect(Opcode.DUP1);
// { pop: 1, push: 2 }
```
***
### getStackInput()
> **getStackInput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackInput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackInput.js#L16)
Get number of stack items consumed by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items consumed
#### Example
```typescript theme={null}
const inputs = Opcode.getStackInput(Opcode.ADD); // 2
const inputs2 = Opcode.getStackInput(Opcode.PUSH1); // 0
```
***
### getStackOutput()
> **getStackOutput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackOutput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackOutput.js#L16)
Get number of stack items produced by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items produced
#### Example
```typescript theme={null}
const outputs = Opcode.getStackOutput(Opcode.ADD); // 1
const outputs2 = Opcode.getStackOutput(Opcode.PUSH1); // 1
```
***
### info()
> **info**(`opcode`): [`Info`](../../primitives/Opcode.mdx#info) | `undefined`
Defined in: [src/primitives/Opcode/info.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/info.js#L17)
Get metadata for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
[`Info`](../../primitives/Opcode.mdx#info) | `undefined`
Metadata with gas cost and stack requirements
#### Example
```typescript theme={null}
const info = Opcode.info(Opcode.ADD);
console.log(info?.name); // "ADD"
console.log(info?.gasCost); // 3
```
***
### isDup()
> **isDup**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isDup.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isDup.js#L16)
Check if opcode is a DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if DUP1-DUP16
#### Example
```typescript theme={null}
Opcode.isDup(Opcode.DUP1); // true
Opcode.isDup(Opcode.ADD); // false
```
***
### isJump()
> **isJump**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJump.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJump.js#L17)
Check if opcode is a jump
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMP or JUMPI
#### Example
```typescript theme={null}
Opcode.isJump(Opcode.JUMP); // true
Opcode.isJump(Opcode.JUMPI); // true
Opcode.isJump(Opcode.ADD); // false
```
***
### isJumpDestination()
> **isJumpDestination**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJumpDestination.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJumpDestination.js#L16)
Check if opcode is JUMPDEST
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMPDEST
#### Example
```typescript theme={null}
Opcode.isJumpDestination(Opcode.JUMPDEST); // true
Opcode.isJumpDestination(Opcode.JUMP); // false
```
***
### isLog()
> **isLog**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isLog.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isLog.js#L16)
Check if opcode is a LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if LOG0-LOG4
#### Example
```typescript theme={null}
Opcode.isLog(Opcode.LOG1); // true
Opcode.isLog(Opcode.ADD); // false
```
***
### isPush()
> **isPush**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isPush.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isPush.js#L16)
Check if opcode is a PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if PUSH0-PUSH32
#### Example
```typescript theme={null}
Opcode.isPush(Opcode.PUSH1); // true
Opcode.isPush(Opcode.ADD); // false
```
***
### isSwap()
> **isSwap**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isSwap.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isSwap.js#L16)
Check if opcode is a SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if SWAP1-SWAP16
#### Example
```typescript theme={null}
Opcode.isSwap(Opcode.SWAP1); // true
Opcode.isSwap(Opcode.ADD); // false
```
***
### isTerminating()
> **isTerminating**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminating.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminating.js#L16)
Check if opcode terminates execution
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminating(Opcode.RETURN); // true
Opcode.isTerminating(Opcode.ADD); // false
```
***
### isTerminator()
> **isTerminator**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminator.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminator.js#L16)
Check if opcode terminates execution (alias for isTerminating)
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminator(Opcode.RETURN); // true
Opcode.isTerminator(Opcode.ADD); // false
```
***
### isValid()
> **isValid**(`opcode`): `opcode is BrandedOpcode`
Defined in: [src/primitives/Opcode/isValid.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValid.js#L16)
Check if opcode is valid
#### Parameters
##### opcode
`number`
Byte value to check
#### Returns
`opcode is BrandedOpcode`
True if opcode is defined in the EVM
#### Example
```typescript theme={null}
Opcode.isValid(0x01); // true (ADD)
Opcode.isValid(0x0c); // false (undefined)
```
***
### isValidJumpDest()
> **isValidJumpDest**(`bytecode`, `offset`): `boolean`
Defined in: [src/primitives/Opcode/isValidJumpDest.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidJumpDest.js#L18)
Check if offset is a valid jump destination
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
##### offset
`number`
Byte offset to check
#### Returns
`boolean`
True if offset is a JUMPDEST and not inside immediate data
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01]);
Opcode.isValidJumpDest(bytecode, 0); // true (JUMPDEST)
Opcode.isValidJumpDest(bytecode, 2); // false (immediate data)
```
***
### isValidOpcode()
> **isValidOpcode**(`value`): `boolean`
Defined in: [src/primitives/Opcode/isValidOpcode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidOpcode.js#L17)
Check if value is a valid opcode (alias for isValid)
#### Parameters
##### value
`number`
Value to check
#### Returns
`boolean`
True if valid opcode
#### Example
```typescript theme={null}
Opcode.isValidOpcode(0x01); // true (ADD)
Opcode.isValidOpcode(0xFF); // true (SELFDESTRUCT)
Opcode.isValidOpcode(0x0C); // false
```
***
### jumpDests()
> **jumpDests**(`bytecode`): `Set`\<`number`>
Defined in: [src/primitives/Opcode/jumpDests.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/jumpDests.js#L17)
Find all valid JUMPDEST locations
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`Set`\<`number`>
Set of valid jump destinations (byte offsets)
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01, 0x5b]);
const dests = Opcode.jumpDests(bytecode); // Set { 0, 3 }
```
***
### logTopics()
> **logTopics**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/logTopics.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/logTopics.js#L17)
Get number of topics for LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of topics (0-4), or undefined if not a LOG
#### Example
```typescript theme={null}
Opcode.logTopics(Opcode.LOG0); // 0
Opcode.logTopics(Opcode.LOG4); // 4
Opcode.logTopics(Opcode.ADD); // undefined
```
***
### name()
> **name**(`opcode`): `string`
Defined in: [src/primitives/Opcode/name.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/name.js#L15)
Get name of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.name(Opcode.ADD); // "ADD"
```
***
### parse()
> **parse**(`bytecode`): [`Instruction`](../../primitives/Opcode.mdx#instruction)\[]
Defined in: [src/primitives/Opcode/parse.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/parse.js#L21)
Parse bytecode into instructions
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
[`Instruction`](../../primitives/Opcode.mdx#instruction)\[]
Array of parsed instructions
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const instructions = Opcode.parse(bytecode);
// [
// { offset: 0, opcode: PUSH1, immediate: [0x01] },
// { offset: 2, opcode: PUSH1, immediate: [0x02] },
// { offset: 4, opcode: ADD }
// ]
```
***
### pushBytes()
> **pushBytes**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/pushBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushBytes.js#L18)
Get number of bytes pushed by PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of bytes (0-32), or undefined if not a PUSH
#### Example
```typescript theme={null}
Opcode.pushBytes(Opcode.PUSH1); // 1
Opcode.pushBytes(Opcode.PUSH32); // 32
Opcode.pushBytes(Opcode.PUSH0); // 0
Opcode.pushBytes(Opcode.ADD); // undefined
```
***
### pushOpcode()
> **pushOpcode**(`bytes`): [`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Defined in: [src/primitives/Opcode/pushOpcode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushOpcode.js#L19)
Get PUSH opcode for given byte count
#### Parameters
##### bytes
`number`
Number of bytes (0-32)
#### Returns
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
PUSH opcode for that size
#### Throws
If bytes is not 0-32
#### Example
```typescript theme={null}
Opcode.pushOpcode(1); // Opcode.PUSH1
Opcode.pushOpcode(32); // Opcode.PUSH32
Opcode.pushOpcode(0); // Opcode.PUSH0
```
***
### swapPosition()
> **swapPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/swapPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/swapPosition.js#L17)
Get position for SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](../../primitives/Opcode.mdx#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a SWAP
#### Example
```typescript theme={null}
Opcode.swapPosition(Opcode.SWAP1); // 1
Opcode.swapPosition(Opcode.SWAP16); // 16
Opcode.swapPosition(Opcode.ADD); // undefined
```
## References
### ADD
Re-exports [ADD](../../primitives/Opcode.mdx#add)
***
### ADDMOD
Re-exports [ADDMOD](../../primitives/Opcode.mdx#addmod)
***
### ADDRESS
Re-exports [ADDRESS](../../primitives/Opcode.mdx#address)
***
### AND
Re-exports [AND](../../primitives/Opcode.mdx#and)
***
### AUTH
Re-exports [AUTH](../../primitives/Opcode.mdx#auth)
***
### AUTHCALL
Re-exports [AUTHCALL](../../primitives/Opcode.mdx#authcall)
***
### BALANCE
Re-exports [BALANCE](../../primitives/Opcode.mdx#balance)
***
### BASEFEE
Re-exports [BASEFEE](../../primitives/Opcode.mdx#basefee)
***
### BLOBBASEFEE
Re-exports [BLOBBASEFEE](../../primitives/Opcode.mdx#blobbasefee)
***
### BLOBHASH
Re-exports [BLOBHASH](../../primitives/Opcode.mdx#blobhash)
***
### BLOCKHASH
Re-exports [BLOCKHASH](../../primitives/Opcode.mdx#blockhash)
***
### BrandedOpcode
Re-exports [BrandedOpcode](../../primitives/Opcode.mdx#brandedopcode-1)
***
### BYTE
Re-exports [BYTE](../../primitives/Opcode.mdx#byte-1)
***
### CALL
Re-exports [CALL](../../primitives/Opcode.mdx#call-1)
***
### CALLCODE
Re-exports [CALLCODE](../../primitives/Opcode.mdx#callcode-1)
***
### CALLDATACOPY
Re-exports [CALLDATACOPY](../../primitives/Opcode.mdx#calldatacopy-1)
***
### CALLDATALOAD
Re-exports [CALLDATALOAD](../../primitives/Opcode.mdx#calldataload-1)
***
### CALLDATASIZE
Re-exports [CALLDATASIZE](../../primitives/Opcode.mdx#calldatasize-1)
***
### CALLER
Re-exports [CALLER](../../primitives/Opcode.mdx#caller-1)
***
### CALLVALUE
Re-exports [CALLVALUE](../../primitives/Opcode.mdx#callvalue-1)
***
### CHAINID
Re-exports [CHAINID](../../primitives/Opcode.mdx#chainid-1)
***
### CODECOPY
Re-exports [CODECOPY](../../primitives/Opcode.mdx#codecopy-1)
***
### CODESIZE
Re-exports [CODESIZE](../../primitives/Opcode.mdx#codesize-1)
***
### COINBASE
Re-exports [COINBASE](../../primitives/Opcode.mdx#coinbase-1)
***
### CREATE
Re-exports [CREATE](../../primitives/Opcode.mdx#create-1)
***
### CREATE2
Re-exports [CREATE2](../../primitives/Opcode.mdx#create2-1)
***
### DELEGATECALL
Re-exports [DELEGATECALL](../../primitives/Opcode.mdx#delegatecall-1)
***
### DIFFICULTY
Re-exports [DIFFICULTY](../../primitives/Opcode.mdx#difficulty-1)
***
### DIV
Re-exports [DIV](../../primitives/Opcode.mdx#div-1)
***
### DUP1
Re-exports [DUP1](../../primitives/Opcode.mdx#dup1-1)
***
### DUP10
Re-exports [DUP10](../../primitives/Opcode.mdx#dup10-1)
***
### DUP11
Re-exports [DUP11](../../primitives/Opcode.mdx#dup11-1)
***
### DUP12
Re-exports [DUP12](../../primitives/Opcode.mdx#dup12-1)
***
### DUP13
Re-exports [DUP13](../../primitives/Opcode.mdx#dup13-1)
***
### DUP14
Re-exports [DUP14](../../primitives/Opcode.mdx#dup14-1)
***
### DUP15
Re-exports [DUP15](../../primitives/Opcode.mdx#dup15-1)
***
### DUP16
Re-exports [DUP16](../../primitives/Opcode.mdx#dup16-1)
***
### DUP2
Re-exports [DUP2](../../primitives/Opcode.mdx#dup2-1)
***
### DUP3
Re-exports [DUP3](../../primitives/Opcode.mdx#dup3-1)
***
### DUP4
Re-exports [DUP4](../../primitives/Opcode.mdx#dup4-1)
***
### DUP5
Re-exports [DUP5](../../primitives/Opcode.mdx#dup5-1)
***
### DUP6
Re-exports [DUP6](../../primitives/Opcode.mdx#dup6-1)
***
### DUP7
Re-exports [DUP7](../../primitives/Opcode.mdx#dup7-1)
***
### DUP8
Re-exports [DUP8](../../primitives/Opcode.mdx#dup8-1)
***
### DUP9
Re-exports [DUP9](../../primitives/Opcode.mdx#dup9-1)
***
### EQ
Re-exports [EQ](../../primitives/Opcode.mdx#eq-1)
***
### EXP
Re-exports [EXP](../../primitives/Opcode.mdx#exp-1)
***
### EXTCODECOPY
Re-exports [EXTCODECOPY](../../primitives/Opcode.mdx#extcodecopy-1)
***
### EXTCODEHASH
Re-exports [EXTCODEHASH](../../primitives/Opcode.mdx#extcodehash-1)
***
### EXTCODESIZE
Re-exports [EXTCODESIZE](../../primitives/Opcode.mdx#extcodesize-1)
***
### GAS
Re-exports [GAS](../../primitives/Opcode.mdx#gas-1)
***
### GASLIMIT
Re-exports [GASLIMIT](../../primitives/Opcode.mdx#gaslimit-1)
***
### GASPRICE
Re-exports [GASPRICE](../../primitives/Opcode.mdx#gasprice-1)
***
### GT
Re-exports [GT](../../primitives/Opcode.mdx#gt-1)
***
### Info
Re-exports [Info](../../primitives/Opcode.mdx#info)
***
### Instruction
Re-exports [Instruction](../../primitives/Opcode.mdx#instruction)
***
### INVALID
Re-exports [INVALID](../../primitives/Opcode.mdx#invalid-1)
***
### ISZERO
Re-exports [ISZERO](../../primitives/Opcode.mdx#iszero-1)
***
### JUMP
Re-exports [JUMP](../../primitives/Opcode.mdx#jump-1)
***
### JUMPDEST
Re-exports [JUMPDEST](../../primitives/Opcode.mdx#jumpdest-1)
***
### JUMPI
Re-exports [JUMPI](../../primitives/Opcode.mdx#jumpi-1)
***
### KECCAK256
Re-exports [KECCAK256](../../primitives/Opcode.mdx#keccak256-1)
***
### LOG0
Re-exports [LOG0](../../primitives/Opcode.mdx#log0-1)
***
### LOG1
Re-exports [LOG1](../../primitives/Opcode.mdx#log1-1)
***
### LOG2
Re-exports [LOG2](../../primitives/Opcode.mdx#log2-1)
***
### LOG3
Re-exports [LOG3](../../primitives/Opcode.mdx#log3-1)
***
### LOG4
Re-exports [LOG4](../../primitives/Opcode.mdx#log4-1)
***
### LT
Re-exports [LT](../../primitives/Opcode.mdx#lt-1)
***
### MCOPY
Re-exports [MCOPY](../../primitives/Opcode.mdx#mcopy-1)
***
### MLOAD
Re-exports [MLOAD](../../primitives/Opcode.mdx#mload-1)
***
### MOD
Re-exports [MOD](../../primitives/Opcode.mdx#mod-1)
***
### MSIZE
Re-exports [MSIZE](../../primitives/Opcode.mdx#msize-1)
***
### MSTORE
Re-exports [MSTORE](../../primitives/Opcode.mdx#mstore-1)
***
### MSTORE8
Re-exports [MSTORE8](../../primitives/Opcode.mdx#mstore8-1)
***
### MUL
Re-exports [MUL](../../primitives/Opcode.mdx#mul-1)
***
### MULMOD
Re-exports [MULMOD](../../primitives/Opcode.mdx#mulmod-1)
***
### NOT
Re-exports [NOT](../../primitives/Opcode.mdx#not-1)
***
### NUMBER
Re-exports [NUMBER](../../primitives/Opcode.mdx#number-1)
***
### Opcode
Re-exports [Opcode](../index.mdx#opcode)
***
### OR
Re-exports [OR](../../primitives/Opcode.mdx#or-1)
***
### ORIGIN
Re-exports [ORIGIN](../../primitives/Opcode.mdx#origin-1)
***
### PC
Re-exports [PC](../../primitives/Opcode.mdx#pc-1)
***
### POP
Re-exports [POP](../../primitives/Opcode.mdx#pop-1)
***
### PUSH0
Re-exports [PUSH0](../../primitives/Opcode.mdx#push0-1)
***
### PUSH1
Re-exports [PUSH1](../../primitives/Opcode.mdx#push1-1)
***
### PUSH10
Re-exports [PUSH10](../../primitives/Opcode.mdx#push10-1)
***
### PUSH11
Re-exports [PUSH11](../../primitives/Opcode.mdx#push11-1)
***
### PUSH12
Re-exports [PUSH12](../../primitives/Opcode.mdx#push12-1)
***
### PUSH13
Re-exports [PUSH13](../../primitives/Opcode.mdx#push13-1)
***
### PUSH14
Re-exports [PUSH14](../../primitives/Opcode.mdx#push14-1)
***
### PUSH15
Re-exports [PUSH15](../../primitives/Opcode.mdx#push15-1)
***
### PUSH16
Re-exports [PUSH16](../../primitives/Opcode.mdx#push16-1)
***
### PUSH17
Re-exports [PUSH17](../../primitives/Opcode.mdx#push17-1)
***
### PUSH18
Re-exports [PUSH18](../../primitives/Opcode.mdx#push18-1)
***
### PUSH19
Re-exports [PUSH19](../../primitives/Opcode.mdx#push19-1)
***
### PUSH2
Re-exports [PUSH2](../../primitives/Opcode.mdx#push2-1)
***
### PUSH20
Re-exports [PUSH20](../../primitives/Opcode.mdx#push20-1)
***
### PUSH21
Re-exports [PUSH21](../../primitives/Opcode.mdx#push21-1)
***
### PUSH22
Re-exports [PUSH22](../../primitives/Opcode.mdx#push22-1)
***
### PUSH23
Re-exports [PUSH23](../../primitives/Opcode.mdx#push23-1)
***
### PUSH24
Re-exports [PUSH24](../../primitives/Opcode.mdx#push24-1)
***
### PUSH25
Re-exports [PUSH25](../../primitives/Opcode.mdx#push25-1)
***
### PUSH26
Re-exports [PUSH26](../../primitives/Opcode.mdx#push26-1)
***
### PUSH27
Re-exports [PUSH27](../../primitives/Opcode.mdx#push27-1)
***
### PUSH28
Re-exports [PUSH28](../../primitives/Opcode.mdx#push28-1)
***
### PUSH29
Re-exports [PUSH29](../../primitives/Opcode.mdx#push29-1)
***
### PUSH3
Re-exports [PUSH3](../../primitives/Opcode.mdx#push3-1)
***
### PUSH30
Re-exports [PUSH30](../../primitives/Opcode.mdx#push30-1)
***
### PUSH31
Re-exports [PUSH31](../../primitives/Opcode.mdx#push31-1)
***
### PUSH32
Re-exports [PUSH32](../../primitives/Opcode.mdx#push32-1)
***
### PUSH4
Re-exports [PUSH4](../../primitives/Opcode.mdx#push4-1)
***
### PUSH5
Re-exports [PUSH5](../../primitives/Opcode.mdx#push5-1)
***
### PUSH6
Re-exports [PUSH6](../../primitives/Opcode.mdx#push6-1)
***
### PUSH7
Re-exports [PUSH7](../../primitives/Opcode.mdx#push7-1)
***
### PUSH8
Re-exports [PUSH8](../../primitives/Opcode.mdx#push8-1)
***
### PUSH9
Re-exports [PUSH9](../../primitives/Opcode.mdx#push9-1)
***
### RETURN
Re-exports [RETURN](../../primitives/Opcode.mdx#return-1)
***
### RETURNDATACOPY
Re-exports [RETURNDATACOPY](../../primitives/Opcode.mdx#returndatacopy-1)
***
### RETURNDATASIZE
Re-exports [RETURNDATASIZE](../../primitives/Opcode.mdx#returndatasize-1)
***
### REVERT
Re-exports [REVERT](../../primitives/Opcode.mdx#revert-1)
***
### SAR
Re-exports [SAR](../../primitives/Opcode.mdx#sar-1)
***
### SDIV
Re-exports [SDIV](../../primitives/Opcode.mdx#sdiv-1)
***
### SELFBALANCE
Re-exports [SELFBALANCE](../../primitives/Opcode.mdx#selfbalance-1)
***
### SELFDESTRUCT
Re-exports [SELFDESTRUCT](../../primitives/Opcode.mdx#selfdestruct-1)
***
### SGT
Re-exports [SGT](../../primitives/Opcode.mdx#sgt-1)
***
### SHL
Re-exports [SHL](../../primitives/Opcode.mdx#shl-1)
***
### SHR
Re-exports [SHR](../../primitives/Opcode.mdx#shr-1)
***
### SIGNEXTEND
Re-exports [SIGNEXTEND](../../primitives/Opcode.mdx#signextend-1)
***
### SLOAD
Re-exports [SLOAD](../../primitives/Opcode.mdx#sload-1)
***
### SLT
Re-exports [SLT](../../primitives/Opcode.mdx#slt-1)
***
### SMOD
Re-exports [SMOD](../../primitives/Opcode.mdx#smod-1)
***
### SSTORE
Re-exports [SSTORE](../../primitives/Opcode.mdx#sstore-1)
***
### STATICCALL
Re-exports [STATICCALL](../../primitives/Opcode.mdx#staticcall-1)
***
### STOP
Re-exports [STOP](../../primitives/Opcode.mdx#stop-1)
***
### SUB
Re-exports [SUB](../../primitives/Opcode.mdx#sub-1)
***
### SWAP1
Re-exports [SWAP1](../../primitives/Opcode.mdx#swap1-1)
***
### SWAP10
Re-exports [SWAP10](../../primitives/Opcode.mdx#swap10-1)
***
### SWAP11
Re-exports [SWAP11](../../primitives/Opcode.mdx#swap11-1)
***
### SWAP12
Re-exports [SWAP12](../../primitives/Opcode.mdx#swap12-1)
***
### SWAP13
Re-exports [SWAP13](../../primitives/Opcode.mdx#swap13-1)
***
### SWAP14
Re-exports [SWAP14](../../primitives/Opcode.mdx#swap14-1)
***
### SWAP15
Re-exports [SWAP15](../../primitives/Opcode.mdx#swap15-1)
***
### SWAP16
Re-exports [SWAP16](../../primitives/Opcode.mdx#swap16-1)
***
### SWAP2
Re-exports [SWAP2](../../primitives/Opcode.mdx#swap2-1)
***
### SWAP3
Re-exports [SWAP3](../../primitives/Opcode.mdx#swap3-1)
***
### SWAP4
Re-exports [SWAP4](../../primitives/Opcode.mdx#swap4-1)
***
### SWAP5
Re-exports [SWAP5](../../primitives/Opcode.mdx#swap5-1)
***
### SWAP6
Re-exports [SWAP6](../../primitives/Opcode.mdx#swap6-1)
***
### SWAP7
Re-exports [SWAP7](../../primitives/Opcode.mdx#swap7-1)
***
### SWAP8
Re-exports [SWAP8](../../primitives/Opcode.mdx#swap8-1)
***
### SWAP9
Re-exports [SWAP9](../../primitives/Opcode.mdx#swap9-1)
***
### TIMESTAMP
Re-exports [TIMESTAMP](../../primitives/Opcode.mdx#timestamp-1)
***
### TLOAD
Re-exports [TLOAD](../../primitives/Opcode.mdx#tload-1)
***
### TSTORE
Re-exports [TSTORE](../../primitives/Opcode.mdx#tstore-1)
***
### XOR
Re-exports [XOR](../../primitives/Opcode.mdx#xor-1)
# BrandedRlp
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedRlp
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedRlp
# BrandedRlp
## Variables
### BrandedRlp
> `const` **BrandedRlp**: `object`
Defined in: [src/primitives/Rlp/internal-index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/internal-index.ts#L65)
#### Type Declaration
##### decode()
> **decode**: (`bytes`, `stream?`) => `Decoded`
Decodes RLP-encoded bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### stream?
`boolean` = `false`
If true, allows extra data after decoded value. If false, expects exact match
###### Returns
`Decoded`
Decoded RLP data with remainder
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If input is too short, invalid, or has unexpected remainder (when stream=false)
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Decode single value
const bytes = new Uint8Array([0x83, 1, 2, 3]);
const result = Rlp.decode(bytes);
// => { data: { type: 'bytes', value: Uint8Array([1, 2, 3]) }, remainder: Uint8Array([]) }
// Stream decoding (multiple values)
const stream = new Uint8Array([0x01, 0x02]);
const result = Rlp.decode(stream, true);
// => { data: { type: 'bytes', value: Uint8Array([1]) }, remainder: Uint8Array([2]) }
// Decode list
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
const result = Rlp.decode(list);
```
##### decodeArray()
> **decodeArray**: (`data`) => `any`\[]
Decodes RLP-encoded bytes to an array
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### Returns
`any`\[]
Decoded array
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If decoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeArray([
new Uint8Array([1, 2]),
new Uint8Array([3, 4])
]);
const arr = Rlp.decodeArray(encoded);
// => [Uint8Array([1, 2]), Uint8Array([3, 4])]
```
##### decodeBatch()
> **decodeBatch**: (`data`) => `any`\[]\[]
Decodes multiple RLP-encoded items
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded data
###### Returns
`any`\[]\[]
Array of decoded results
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If decoding fails for any item
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
Rlp.encode([new Uint8Array([1, 2])]),
Rlp.encode([new Uint8Array([3, 4])])
];
const decoded = Rlp.decodeBatch(items);
// => [[Uint8Array([1, 2])], [Uint8Array([3, 4])]]
```
##### decodeObject()
> **decodeObject**: (`data`) => `Record`\<`string`, `any`>
Decodes RLP-encoded bytes to an object with known keys
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### Returns
`Record`\<`string`, `any`>
Decoded object
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If decoding fails or data format is invalid
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = { name: new Uint8Array([65, 66]), age: new Uint8Array([25]) };
const encoded = Rlp.encodeObject(obj);
const decoded = Rlp.decodeObject(encoded);
```
##### encode()
> **encode**: (`data`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes data to RLP format
###### Parameters
###### data
`Encodable`
Data to encode (Uint8Array, RlpData, or array)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If data type is invalid or encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Encode bytes
const bytes = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encode(bytes);
// => Uint8Array([0x83, 1, 2, 3])
// Encode list
const list = [new Uint8Array([1, 2]), new Uint8Array([3, 4])];
const encoded = Rlp.encode(list);
// Encode nested structures
const nested = [new Uint8Array([1]), [new Uint8Array([2]), new Uint8Array([3])]];
const encoded = Rlp.encode(nested);
```
##### encodeArray()
> **encodeArray**: (`items`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes an array of values to RLP format
###### Parameters
###### items
`Encodable`\[]
Array of values to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
new Uint8Array([1, 2, 3]),
new Uint8Array([4, 5, 6])
];
const encoded = Rlp.encodeArray(items);
```
##### encodeBatch()
> **encodeBatch**: (`items`) => `Uint8Array`\<`ArrayBufferLike`>\[]
Encodes multiple items efficiently
###### Parameters
###### items
`Encodable`\[]\[]
Array of items to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded results
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails for any item
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
[new Uint8Array([1, 2]), new Uint8Array([3, 4])],
[new Uint8Array([5, 6]), new Uint8Array([7, 8])]
];
const encoded = Rlp.encodeBatch(items);
// => [Uint8Array(...), Uint8Array(...)]
```
##### encodeBytes()
> **encodeBytes**: (`bytes`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes a byte array according to RLP string rules
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Single byte < 0x80
const b1 = new Uint8Array([0x7f]);
const encoded = Rlp.encodeBytes(b1);
// => Uint8Array([0x7f])
// Short string
const b2 = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encodeBytes(b2);
// => Uint8Array([0x83, 1, 2, 3])
// Long string (> 55 bytes)
const longBytes = new Uint8Array(60).fill(0x42);
const encoded = Rlp.encodeBytes(longBytes);
// => Uint8Array([0xb8, 60, ...longBytes])
```
##### encodeList()
> **encodeList**: (`items`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes a list of RLP-encodable items
###### Parameters
###### items
(`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp))\[]
Array of items to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded list
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Empty list
const empty = [];
const encoded = Rlp.encodeList(empty);
// => Uint8Array([0xc0])
// Simple list
const list = [new Uint8Array([1]), new Uint8Array([2])];
const encoded = Rlp.encodeList(list);
// => Uint8Array([0xc4, 0x01, 0x02])
// Nested list
const nested = [new Uint8Array([1]), [new Uint8Array([2])]];
const encoded = Rlp.encodeList(nested);
```
##### encodeObject()
> **encodeObject**: (`obj`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes an object (key-value pairs) to RLP format
Converts object to array of \[key, value] pairs and encodes
###### Parameters
###### obj
`Record`\<`string`, `Encodable`>
Object to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = {
name: new Uint8Array([65, 66, 67]),
age: new Uint8Array([25])
};
const encoded = Rlp.encodeObject(obj);
```
##### encodeVariadic()
> **encodeVariadic**: (...`items`) => `Uint8Array`\<`ArrayBufferLike`>
Encodes a variadic list of items to RLP format
###### Parameters
###### items
...`Encodable`\[]
Items to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If encoding fails
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeVariadic(
new Uint8Array([1, 2]),
new Uint8Array([3, 4]),
new Uint8Array([5, 6])
);
```
##### equals()
> **equals**: (`data`, `other`) => `boolean`
Check if two RLP Data structures are equal
###### Parameters
###### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
First RLP data structure
###### other
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Second RLP data structure
###### Returns
`boolean`
True if structures are deeply equal
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const a = { type: 'bytes', value: new Uint8Array([1, 2]) };
const b = { type: 'bytes', value: new Uint8Array([1, 2]) };
Rlp.equals(a, b); // => true
```
##### flatten()
> **flatten**: (`data`) => [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) & `object`\[]
Flatten nested list Data into array of bytes Data (depth-first)
###### Parameters
###### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure to flatten
###### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) & `object`\[]
Array of bytes data (all nested lists flattened)
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const nested = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{
type: 'list',
value: [{ type: 'bytes', value: new Uint8Array([2]) }]
}
]
};
const flat = Rlp.flatten(nested);
// => [
// { type: 'bytes', value: Uint8Array([1]) },
// { type: 'bytes', value: Uint8Array([2]) }
// ]
```
##### from()
> **from**: (`value`) => [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Create RLP data from various inputs
###### Parameters
###### value
Uint8Array (bytes), RlpData, or array (list)
`Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)\[]
###### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If input type is invalid
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const rlp = Rlp.from(new Uint8Array([1, 2, 3]));
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
const rlp2 = Rlp.from([{ type: 'bytes', value: new Uint8Array([1]) }]);
// => { type: 'list', value: [...] }
```
##### fromJSON()
> **fromJSON**: (`json`) => [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Convert JSON representation back to RLP Data
###### Parameters
###### json
`unknown`
JSON object from toJSON
###### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If JSON format is invalid or type is unrecognized
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const json = { type: 'bytes', value: [1, 2, 3] };
const data = Rlp.fromJSON(json);
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
```
##### getEncodedLength()
> **getEncodedLength**: (`data`) => `number`
Get the total byte length of RLP-encoded data without actually encoding
###### Parameters
###### data
Data to measure
`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
###### Returns
`number`
Length in bytes after RLP encoding
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If data type is invalid
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([1, 2, 3]);
const length = Rlp.getEncodedLength(bytes);
// => 4 (0x83 prefix + 3 bytes)
```
##### getLength()
> **getLength**: (`data`) => `number`
Gets the total length of an RLP item (prefix + payload)
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### Returns
`number`
Total length in bytes
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If data is empty, too short, or has invalid prefix
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = new Uint8Array([0x83, 1, 2, 3]);
const length = Rlp.getLength(encoded);
// => 4 (1 byte prefix + 3 bytes payload)
```
##### isBytesData()
> **isBytesData**: (`value`) => `boolean`
Check if value is RLP bytes data
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`boolean`
True if value is RLP bytes data structure
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isBytesData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isBytesData({ type: 'list', value: [] });
// => false
```
##### isCanonical()
> **isCanonical**: (`bytes`, `depth?`) => `boolean`
Validates if RLP encoding is canonical
Canonical encoding rules:
* Integers must use minimum bytes (no leading zeros)
* Strings/bytes must use shortest length prefix
* Single byte \< 0x80 must not be encoded as string
* Length prefix must use minimum bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### depth?
`number` = `0`
Current recursion depth (internal)
###### Returns
`boolean`
True if encoding is canonical
###### See
* [https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
* [https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/) for canonical rules
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Canonical encoding
const canonical = new Uint8Array([0x83, 0x64, 0x6f, 0x67]); // "dog"
Rlp.isCanonical(canonical); // => true
// Non-canonical: single byte should not be prefixed
const nonCanonical = new Uint8Array([0x81, 0x7f]); // should be just 0x7f
Rlp.isCanonical(nonCanonical); // => false
// Non-canonical: leading zeros in length
const leadingZeros = new Uint8Array([0xb8, 0x00, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f]);
Rlp.isCanonical(leadingZeros); // => false
```
##### isData()
> **isData**: (`value`) => `value is BrandedRlp`
Check if value is RLP Data structure
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is BrandedRlp`
True if value is valid RLP data structure
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isData({ type: 'list', value: [] });
// => true
Rlp.isData('invalid');
// => false
```
##### isList()
> **isList**: (`data`) => `boolean`
Checks if RLP-encoded data represents a list
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### Returns
`boolean`
True if data encodes a list
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If data is empty
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isList(list);
// => true
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isList(bytes);
// => false
```
##### isListData()
> **isListData**: (`value`) => `boolean`
Check if value is RLP list data
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`boolean`
True if value is RLP list data structure
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isListData({ type: 'list', value: [] });
// => true
Rlp.isListData({ type: 'bytes', value: new Uint8Array([1]) });
// => false
```
##### isString()
> **isString**: (`data`) => `boolean`
Checks if RLP-encoded data represents a string (byte array)
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
###### Returns
`boolean`
True if data encodes a string
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
If data is empty
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isString(bytes);
// => true
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isString(list);
// => false
```
##### toJSON()
> **toJSON**: (`data`) => `unknown`
Convert RLP Data to human-readable JSON format
###### Parameters
###### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
###### Returns
`unknown`
JSON-serializable representation
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const json = Rlp.toJSON(data);
// => { type: 'bytes', value: [1, 2, 3] }
```
##### toRaw()
> **toRaw**: (`data`) => `any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Converts RLP Data structure to raw JavaScript values (Uint8Array or nested arrays)
###### Parameters
###### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure to convert
###### Returns
`any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Raw value (Uint8Array for bytes, array for list)
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const raw = Rlp.toRaw(data);
// => Uint8Array([1, 2, 3])
const listData = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{ type: 'bytes', value: new Uint8Array([2]) }
]
};
const rawList = Rlp.toRaw(listData);
// => [Uint8Array([1]), Uint8Array([2])]
```
##### validate()
> **validate**: (`data`) => `boolean`
Validates if data is valid RLP encoding
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Data to validate
###### Returns
`boolean`
True if valid RLP encoding
###### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const valid = Rlp.validate(new Uint8Array([0x83, 1, 2, 3]));
// => true
const invalid = Rlp.validate(new Uint8Array([0x83, 1]));
// => false (incomplete)
```
## Functions
### decode()
> **decode**(`bytes`, `stream?`): `Decoded`
Defined in: [src/primitives/Rlp/decode.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decode.js#L75)
Decodes RLP-encoded bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
##### stream?
`boolean` = `false`
If true, allows extra data after decoded value. If false, expects exact match
#### Returns
`Decoded`
Decoded RLP data with remainder
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If input is too short, invalid, or has unexpected remainder (when stream=false)
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Decode single value
const bytes = new Uint8Array([0x83, 1, 2, 3]);
const result = Rlp.decode(bytes);
// => { data: { type: 'bytes', value: Uint8Array([1, 2, 3]) }, remainder: Uint8Array([]) }
// Stream decoding (multiple values)
const stream = new Uint8Array([0x01, 0x02]);
const result = Rlp.decode(stream, true);
// => { data: { type: 'bytes', value: Uint8Array([1]) }, remainder: Uint8Array([2]) }
// Decode list
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
const result = Rlp.decode(list);
```
***
### decodeArray()
> **decodeArray**(`data`): `any`\[]
Defined in: [src/primitives/Rlp/decodeArray.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeArray.js#L23)
Decodes RLP-encoded bytes to an array
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`any`\[]
Decoded array
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeArray([
new Uint8Array([1, 2]),
new Uint8Array([3, 4])
]);
const arr = Rlp.decodeArray(encoded);
// => [Uint8Array([1, 2]), Uint8Array([3, 4])]
```
***
### decodeBatch()
> **decodeBatch**(`data`): `any`\[]\[]
Defined in: [src/primitives/Rlp/decodeBatch.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeBatch.js#L23)
Decodes multiple RLP-encoded items
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded data
#### Returns
`any`\[]\[]
Array of decoded results
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails for any item
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
Rlp.encode([new Uint8Array([1, 2])]),
Rlp.encode([new Uint8Array([3, 4])])
];
const decoded = Rlp.decodeBatch(items);
// => [[Uint8Array([1, 2])], [Uint8Array([3, 4])]]
```
***
### decodeObject()
> **decodeObject**(`data`): `Record`\<`string`, `any`>
Defined in: [src/primitives/Rlp/decodeObject.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeObject.js#L20)
Decodes RLP-encoded bytes to an object with known keys
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`Record`\<`string`, `any`>
Decoded object
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails or data format is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = { name: new Uint8Array([65, 66]), age: new Uint8Array([25]) };
const encoded = Rlp.encodeObject(obj);
const decoded = Rlp.decodeObject(encoded);
```
***
### encode()
> **encode**(`data`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encode.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encode.js#L47)
Encodes data to RLP format
#### Parameters
##### data
`Encodable`
Data to encode (Uint8Array, RlpData, or array)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data type is invalid or encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Encode bytes
const bytes = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encode(bytes);
// => Uint8Array([0x83, 1, 2, 3])
// Encode list
const list = [new Uint8Array([1, 2]), new Uint8Array([3, 4])];
const encoded = Rlp.encode(list);
// Encode nested structures
const nested = [new Uint8Array([1]), [new Uint8Array([2]), new Uint8Array([3])]];
const encoded = Rlp.encode(nested);
```
***
### encodeArray()
> **encodeArray**(`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeArray.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeArray.js#L25)
Encodes an array of values to RLP format
#### Parameters
##### items
`Encodable`\[]
Array of values to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
new Uint8Array([1, 2, 3]),
new Uint8Array([4, 5, 6])
];
const encoded = Rlp.encodeArray(items);
```
***
### encodeBatch()
> **encodeBatch**(`items`): `Uint8Array`\<`ArrayBufferLike`>\[]
Defined in: [src/primitives/Rlp/encodeBatch.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeBatch.js#L26)
Encodes multiple items efficiently
#### Parameters
##### items
`Encodable`\[]\[]
Array of items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded results
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails for any item
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
[new Uint8Array([1, 2]), new Uint8Array([3, 4])],
[new Uint8Array([5, 6]), new Uint8Array([7, 8])]
];
const encoded = Rlp.encodeBatch(items);
// => [Uint8Array(...), Uint8Array(...)]
```
***
### encodeBytes()
> **encodeBytes**(`bytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeBytes.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeBytes.js#L30)
Encodes a byte array according to RLP string rules
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Single byte < 0x80
const b1 = new Uint8Array([0x7f]);
const encoded = Rlp.encodeBytes(b1);
// => Uint8Array([0x7f])
// Short string
const b2 = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encodeBytes(b2);
// => Uint8Array([0x83, 1, 2, 3])
// Long string (> 55 bytes)
const longBytes = new Uint8Array(60).fill(0x42);
const encoded = Rlp.encodeBytes(longBytes);
// => Uint8Array([0xb8, 60, ...longBytes])
```
***
### encodeList()
> **encodeList**(`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeList.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeList.js#L29)
Encodes a list of RLP-encodable items
#### Parameters
##### items
(`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp))\[]
Array of items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded list
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Empty list
const empty = [];
const encoded = Rlp.encodeList(empty);
// => Uint8Array([0xc0])
// Simple list
const list = [new Uint8Array([1]), new Uint8Array([2])];
const encoded = Rlp.encodeList(list);
// => Uint8Array([0xc4, 0x01, 0x02])
// Nested list
const nested = [new Uint8Array([1]), [new Uint8Array([2])]];
const encoded = Rlp.encodeList(nested);
```
***
### encodeObject()
> **encodeObject**(`obj`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeObject.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeObject.js#L26)
Encodes an object (key-value pairs) to RLP format
Converts object to array of \[key, value] pairs and encodes
#### Parameters
##### obj
`Record`\<`string`, `Encodable`>
Object to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = {
name: new Uint8Array([65, 66, 67]),
age: new Uint8Array([25])
};
const encoded = Rlp.encodeObject(obj);
```
***
### encodeVariadic()
> **encodeVariadic**(...`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeVariadic.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeVariadic.js#L25)
Encodes a variadic list of items to RLP format
#### Parameters
##### items
...`Encodable`\[]
Items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeVariadic(
new Uint8Array([1, 2]),
new Uint8Array([3, 4]),
new Uint8Array([5, 6])
);
```
***
### equals()
> **equals**(`data`, `other`): `boolean`
Defined in: [src/primitives/Rlp/equals.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/equals.js#L19)
Check if two RLP Data structures are equal
#### Parameters
##### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
First RLP data structure
##### other
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Second RLP data structure
#### Returns
`boolean`
True if structures are deeply equal
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const a = { type: 'bytes', value: new Uint8Array([1, 2]) };
const b = { type: 'bytes', value: new Uint8Array([1, 2]) };
Rlp.equals(a, b); // => true
```
***
### flatten()
> **flatten**(`data`): [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) & `object`\[]
Defined in: [src/primitives/Rlp/flatten.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/flatten.js#L29)
Flatten nested list Data into array of bytes Data (depth-first)
#### Parameters
##### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure to flatten
#### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) & `object`\[]
Array of bytes data (all nested lists flattened)
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const nested = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{
type: 'list',
value: [{ type: 'bytes', value: new Uint8Array([2]) }]
}
]
};
const flat = Rlp.flatten(nested);
// => [
// { type: 'bytes', value: Uint8Array([1]) },
// { type: 'bytes', value: Uint8Array([2]) }
// ]
```
***
### from()
> **from**(`value`): [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Defined in: [src/primitives/Rlp/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/from.js#L20)
Create RLP data from various inputs
#### Parameters
##### value
Uint8Array (bytes), RlpData, or array (list)
`Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp) | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)\[]
#### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If input type is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const rlp = Rlp.from(new Uint8Array([1, 2, 3]));
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
const rlp2 = Rlp.from([{ type: 'bytes', value: new Uint8Array([1]) }]);
// => { type: 'list', value: [...] }
```
***
### fromJSON()
> **fromJSON**(`json`): [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
Defined in: [src/primitives/Rlp/fromJSON.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/fromJSON.js#L19)
Convert JSON representation back to RLP Data
#### Parameters
##### json
`unknown`
JSON object from toJSON
#### Returns
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If JSON format is invalid or type is unrecognized
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const json = { type: 'bytes', value: [1, 2, 3] };
const data = Rlp.fromJSON(json);
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
```
***
### getEncodedLength()
> **getEncodedLength**(`data`): `number`
Defined in: [src/primitives/Rlp/getEncodedLength.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/getEncodedLength.js#L21)
Get the total byte length of RLP-encoded data without actually encoding
#### Parameters
##### data
Data to measure
`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
#### Returns
`number`
Length in bytes after RLP encoding
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data type is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([1, 2, 3]);
const length = Rlp.getEncodedLength(bytes);
// => 4 (0x83 prefix + 3 bytes)
```
***
### getLength()
> **getLength**(`data`): `number`
Defined in: [src/primitives/Rlp/getLength.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/getLength.js#L20)
Gets the total length of an RLP item (prefix + payload)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`number`
Total length in bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty, too short, or has invalid prefix
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = new Uint8Array([0x83, 1, 2, 3]);
const length = Rlp.getLength(encoded);
// => 4 (1 byte prefix + 3 bytes payload)
```
***
### isBytesData()
> **isBytesData**(`value`): `boolean`
Defined in: [src/primitives/Rlp/isBytesData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isBytesData.js#L20)
Check if value is RLP bytes data
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if value is RLP bytes data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isBytesData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isBytesData({ type: 'list', value: [] });
// => false
```
***
### isCanonical()
> **isCanonical**(`bytes`, `depth?`): `boolean`
Defined in: [src/primitives/Rlp/isCanonical.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isCanonical.js#L34)
Validates if RLP encoding is canonical
Canonical encoding rules:
* Integers must use minimum bytes (no leading zeros)
* Strings/bytes must use shortest length prefix
* Single byte \< 0x80 must not be encoded as string
* Length prefix must use minimum bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
##### depth?
`number` = `0`
Current recursion depth (internal)
#### Returns
`boolean`
True if encoding is canonical
#### See
* [https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
* [https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/) for canonical rules
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Canonical encoding
const canonical = new Uint8Array([0x83, 0x64, 0x6f, 0x67]); // "dog"
Rlp.isCanonical(canonical); // => true
// Non-canonical: single byte should not be prefixed
const nonCanonical = new Uint8Array([0x81, 0x7f]); // should be just 0x7f
Rlp.isCanonical(nonCanonical); // => false
// Non-canonical: leading zeros in length
const leadingZeros = new Uint8Array([0xb8, 0x00, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f]);
Rlp.isCanonical(leadingZeros); // => false
```
***
### isData()
> **isData**(`value`): `value is BrandedRlp`
Defined in: [src/primitives/Rlp/isData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isData.js#L20)
Check if value is RLP Data structure
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is BrandedRlp`
True if value is valid RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isData({ type: 'list', value: [] });
// => true
Rlp.isData('invalid');
// => false
```
***
### isList()
> **isList**(`data`): `boolean`
Defined in: [src/primitives/Rlp/isList.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isList.js#L23)
Checks if RLP-encoded data represents a list
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`boolean`
True if data encodes a list
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isList(list);
// => true
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isList(bytes);
// => false
```
***
### isListData()
> **isListData**(`value`): `boolean`
Defined in: [src/primitives/Rlp/isListData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isListData.js#L20)
Check if value is RLP list data
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if value is RLP list data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isListData({ type: 'list', value: [] });
// => true
Rlp.isListData({ type: 'bytes', value: new Uint8Array([1]) });
// => false
```
***
### isString()
> **isString**(`data`): `boolean`
Defined in: [src/primitives/Rlp/isString.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isString.js#L23)
Checks if RLP-encoded data represents a string (byte array)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`boolean`
True if data encodes a string
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isString(bytes);
// => true
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isString(list);
// => false
```
***
### toJSON()
> **toJSON**(`data`): `unknown`
Defined in: [src/primitives/Rlp/toJSON.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/toJSON.js#L17)
Convert RLP Data to human-readable JSON format
#### Parameters
##### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure
#### Returns
`unknown`
JSON-serializable representation
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const json = Rlp.toJSON(data);
// => { type: 'bytes', value: [1, 2, 3] }
```
***
### toRaw()
> **toRaw**(`data`): `any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/toRaw.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/toRaw.js#L27)
Converts RLP Data structure to raw JavaScript values (Uint8Array or nested arrays)
#### Parameters
##### data
[`BrandedRlp`](../../primitives/Rlp.mdx#brandedrlp)
RLP data structure to convert
#### Returns
`any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Raw value (Uint8Array for bytes, array for list)
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const raw = Rlp.toRaw(data);
// => Uint8Array([1, 2, 3])
const listData = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{ type: 'bytes', value: new Uint8Array([2]) }
]
};
const rawList = Rlp.toRaw(listData);
// => [Uint8Array([1]), Uint8Array([2])]
```
***
### validate()
> **validate**(`data`): `boolean`
Defined in: [src/primitives/Rlp/validate.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/validate.js#L21)
Validates if data is valid RLP encoding
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Data to validate
#### Returns
`boolean`
True if valid RLP encoding
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const valid = Rlp.validate(new Uint8Array([0x83, 1, 2, 3]));
// => true
const invalid = Rlp.validate(new Uint8Array([0x83, 1]));
// => false (incomplete)
```
## References
### Encodable
Re-exports [Encodable](../../primitives/Rlp.mdx#encodable)
***
### Error
Re-exports [Error](../../primitives/Rlp.mdx#error)
***
### ErrorType
Re-exports [ErrorType](../../primitives/Rlp.mdx#errortype-1)
***
### MAX\_DEPTH
Re-exports [MAX\_DEPTH](../../primitives/Rlp.mdx#max_depth)
***
### RlpError
Re-exports [RlpError](../../primitives/Rlp.mdx#rlperror)
# BrandedWei
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/BrandedWei
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / BrandedWei
# BrandedWei
## Type Aliases
### BrandedWei
> **BrandedWei** = [`WeiType`](#weitype)
Defined in: [src/primitives/Denomination/WeiType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/WeiType.ts#L9)
***
### WeiType
> **WeiType** = `bigint` & `object`
Defined in: [src/primitives/Denomination/WeiType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/WeiType.ts#L6)
Branded Wei type - represents Ethereum amounts in wei (smallest unit: 10^-18 ETH)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Wei"`
## Variables
### Wei
> `const` **Wei**: `object`
Defined in: [src/primitives/Denomination/wei-index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-index.ts#L19)
#### Type Declaration
##### from()
> **from**: (`value`) => [`WeiType`](#weitype)
Create Wei from bigint, number, or string
###### Parameters
###### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
###### Returns
[`WeiType`](#weitype)
Wei amount
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const wei1 = Wei.from(1000000000n);
const wei2 = Wei.from(1000000000);
const wei3 = Wei.from("1000000000");
const wei4 = Wei.from("0x3b9aca00");
```
##### fromEther()
> **fromEther**: (`ether`) => [`WeiType`](#weitype)
Convert Ether to Wei
Parses decimal ether string and converts to bigint wei value.
Alias for Ether.toWei().
###### Parameters
###### ether
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string, supports decimals like "1.5")
###### Returns
[`WeiType`](#weitype)
Amount in Wei (bigint)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If ether value has more than 18 decimal places
###### Example
```typescript theme={null}
const wei1 = Wei.fromEther(Ether.from("1")); // 1000000000000000000n
const wei2 = Wei.fromEther(Ether.from("1.5")); // 1500000000000000000n
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`WeiType`](#weitype)
Convert Gwei to Wei
Parses decimal gwei string and converts to bigint wei value.
Alias for Gwei.toWei().
###### Parameters
###### gwei
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string, supports decimals like "1.5")
###### Returns
[`WeiType`](#weitype)
Amount in Wei (bigint)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
If gwei value has more than 9 decimal places
###### Example
```typescript theme={null}
const wei1 = Wei.fromGwei(Gwei.from("5")); // 5000000000n
const wei2 = Wei.fromGwei(Gwei.from("1.5")); // 1500000000n
```
##### toEther()
> **toEther**: (`wei`) => [`EtherType`](BrandedEther.mdx#ethertype)
Convert Wei to Ether
Converts bigint wei to decimal string ether value.
###### Parameters
###### wei
[`WeiType`](#weitype)
Amount in Wei (bigint)
###### Returns
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string with decimal precision)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const ether1 = Wei.toEther(Wei.from(1000000000000000000n)); // "1"
const ether2 = Wei.toEther(Wei.from(1500000000000000000n)); // "1.5"
const ether3 = Wei.toEther(Wei.from(1000000000000000n)); // "0.001"
```
##### toGwei()
> **toGwei**: (`wei`) => [`GweiType`](BrandedGwei.mdx#gweitype)
Convert Wei to Gwei
Converts bigint wei to decimal string gwei value.
###### Parameters
###### wei
[`WeiType`](#weitype)
Amount in Wei (bigint)
###### Returns
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string with decimal precision)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const gwei1 = Wei.toGwei(Wei.from(5000000000n)); // "5"
const gwei2 = Wei.toGwei(Wei.from(1500000000n)); // "1.5"
const gwei3 = Wei.toGwei(Wei.from(1000000n)); // "0.001"
```
##### toU256()
> **toU256**: (`wei`) => [`Type`](../../primitives/Uint.mdx#type)
Convert Wei to base Uint256 type
###### Parameters
###### wei
[`WeiType`](#weitype)
Amount in Wei
###### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value (type cast, no conversion)
###### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
###### Since
0.0.0
###### Throws
###### Example
```typescript theme={null}
const wei = Wei.from(1000000000n);
const u256 = Wei.toU256(wei);
// u256 = 1000000000n (as Uint256)
```
***
### WEI\_PER\_ETHER
> `const` **WEI\_PER\_ETHER**: `1000000000000000000n` = `1_000_000_000_000_000_000n`
Defined in: [src/primitives/Denomination/wei-constants.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-constants.ts#L15)
Conversion constant: Wei per Ether (10^18)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
***
### WEI\_PER\_GWEI
> `const` **WEI\_PER\_GWEI**: `1000000000n` = `1_000_000_000n`
Defined in: [src/primitives/Denomination/wei-constants.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-constants.ts#L7)
Conversion constant: Wei per Gwei (10^9)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
## Functions
### from()
> **from**(`value`): [`WeiType`](#weitype)
Defined in: [src/primitives/Denomination/wei-from.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-from.ts#L20)
Create Wei from bigint, number, or string
#### Parameters
##### value
Value to convert (bigint, number, or string)
`string` | `number` | `bigint`
#### Returns
[`WeiType`](#weitype)
Wei amount
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const wei1 = Wei.from(1000000000n);
const wei2 = Wei.from(1000000000);
const wei3 = Wei.from("1000000000");
const wei4 = Wei.from("0x3b9aca00");
```
***
### fromEther()
> **fromEther**(`ether`): [`WeiType`](#weitype)
Defined in: [src/primitives/Denomination/wei-fromEther.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-fromEther.ts#L22)
Convert Ether to Wei
Parses decimal ether string and converts to bigint wei value.
Alias for Ether.toWei().
#### Parameters
##### ether
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string, supports decimals like "1.5")
#### Returns
[`WeiType`](#weitype)
Amount in Wei (bigint)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If ether value has more than 18 decimal places
#### Example
```typescript theme={null}
const wei1 = Wei.fromEther(Ether.from("1")); // 1000000000000000000n
const wei2 = Wei.fromEther(Ether.from("1.5")); // 1500000000000000000n
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`WeiType`](#weitype)
Defined in: [src/primitives/Denomination/wei-fromGwei.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-fromGwei.ts#L22)
Convert Gwei to Wei
Parses decimal gwei string and converts to bigint wei value.
Alias for Gwei.toWei().
#### Parameters
##### gwei
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string, supports decimals like "1.5")
#### Returns
[`WeiType`](#weitype)
Amount in Wei (bigint)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
If gwei value has more than 9 decimal places
#### Example
```typescript theme={null}
const wei1 = Wei.fromGwei(Gwei.from("5")); // 5000000000n
const wei2 = Wei.fromGwei(Gwei.from("1.5")); // 1500000000n
```
***
### toEther()
> **toEther**(`wei`): [`EtherType`](BrandedEther.mdx#ethertype)
Defined in: [src/primitives/Denomination/wei-toEther.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-toEther.ts#L23)
Convert Wei to Ether
Converts bigint wei to decimal string ether value.
#### Parameters
##### wei
[`WeiType`](#weitype)
Amount in Wei (bigint)
#### Returns
[`EtherType`](BrandedEther.mdx#ethertype)
Amount in Ether (string with decimal precision)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const ether1 = Wei.toEther(Wei.from(1000000000000000000n)); // "1"
const ether2 = Wei.toEther(Wei.from(1500000000000000000n)); // "1.5"
const ether3 = Wei.toEther(Wei.from(1000000000000000n)); // "0.001"
```
***
### toGwei()
> **toGwei**(`wei`): [`GweiType`](BrandedGwei.mdx#gweitype)
Defined in: [src/primitives/Denomination/wei-toGwei.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-toGwei.ts#L23)
Convert Wei to Gwei
Converts bigint wei to decimal string gwei value.
#### Parameters
##### wei
[`WeiType`](#weitype)
Amount in Wei (bigint)
#### Returns
[`GweiType`](BrandedGwei.mdx#gweitype)
Amount in Gwei (string with decimal precision)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const gwei1 = Wei.toGwei(Wei.from(5000000000n)); // "5"
const gwei2 = Wei.toGwei(Wei.from(1500000000n)); // "1.5"
const gwei3 = Wei.toGwei(Wei.from(1000000n)); // "0.001"
```
***
### toU256()
> **toU256**(`wei`): [`Type`](../../primitives/Uint.mdx#type)
Defined in: [src/primitives/Denomination/wei-toU256.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Denomination/wei-toU256.ts#L19)
Convert Wei to base Uint256 type
#### Parameters
##### wei
[`WeiType`](#weitype)
Amount in Wei
#### Returns
[`Type`](../../primitives/Uint.mdx#type)
Uint256 value (type cast, no conversion)
#### See
[https://voltaire.tevm.sh/primitives/denomination](https://voltaire.tevm.sh/primitives/denomination) for Denomination documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
const wei = Wei.from(1000000000n);
const u256 = Wei.toU256(wei);
// u256 = 1000000000n (as Uint256)
```
# ERC1155
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/ERC1155
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / ERC1155
# ERC1155
## Variables
### EVENTS
> `const` **EVENTS**: `object`
Defined in: [src/standards/ERC1155.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L37)
ERC-1155 event signatures
keccak256 hash of event signature
#### Type Declaration
##### ApprovalForAll
> `readonly` **ApprovalForAll**: `"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"` = `"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"`
ApprovalForAll(address indexed account, address indexed operator, bool approved)
##### TransferBatch
> `readonly` **TransferBatch**: `"0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb"` = `"0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb"`
TransferBatch(address indexed operator, address indexed from, address indexed to, uint256\[] ids, uint256\[] values)
##### TransferSingle
> `readonly` **TransferSingle**: `"0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62"` = `"0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62"`
TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)
##### URI
> `readonly` **URI**: `"0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b"` = `"0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b"`
URI(string value, uint256 indexed id)
***
### SELECTORS
> `const` **SELECTORS**: `object`
Defined in: [src/standards/ERC1155.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L15)
ERC-1155 function selectors
First 4 bytes of keccak256 hash of function signature
#### Type Declaration
##### balanceOf
> `readonly` **balanceOf**: `"0x00fdd58e"` = `"0x00fdd58e"`
balanceOf(address,uint256)
##### balanceOfBatch
> `readonly` **balanceOfBatch**: `"0x4e1273f4"` = `"0x4e1273f4"`
balanceOfBatch(address\[],uint256\[])
##### isApprovedForAll
> `readonly` **isApprovedForAll**: `"0xe985e9c5"` = `"0xe985e9c5"`
isApprovedForAll(address,address)
##### safeBatchTransferFrom
> `readonly` **safeBatchTransferFrom**: `"0x2eb2c2d6"` = `"0x2eb2c2d6"`
safeBatchTransferFrom(address,address,uint256\[],uint256\[],bytes)
##### safeTransferFrom
> `readonly` **safeTransferFrom**: `"0xf242432a"` = `"0xf242432a"`
safeTransferFrom(address,address,uint256,uint256,bytes)
##### setApprovalForAll
> `readonly` **setApprovalForAll**: `"0xa22cb465"` = `"0xa22cb465"`
setApprovalForAll(address,bool)
##### uri
> `readonly` **uri**: `"0x0e89341c"` = `"0x0e89341c"`
uri(uint256)
## Functions
### decodeApprovalForAllEvent()
> **decodeApprovalForAllEvent**(`log`): `object`
Defined in: [src/standards/ERC1155.ts:177](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L177)
Decode ApprovalForAll event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### account
> **account**: `string`
##### approved
> **approved**: `boolean`
##### operator
> **operator**: `string`
***
### decodeTransferSingleEvent()
> **decodeTransferSingleEvent**(`log`): `object`
Defined in: [src/standards/ERC1155.ts:141](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L141)
Decode TransferSingle event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### from
> **from**: `string`
##### id
> **id**: [`Type`](../../primitives/Uint.mdx#type)
##### operator
> **operator**: `string`
##### to
> **to**: `string`
##### value
> **value**: [`Type`](../../primitives/Uint.mdx#type)
***
### encodeBalanceOf()
> **encodeBalanceOf**(`account`, `id`): `string`
Defined in: [src/standards/ERC1155.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L54)
Encode balanceOf(address,uint256) calldata
#### Parameters
##### account
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### id
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeIsApprovedForAll()
> **encodeIsApprovedForAll**(`account`, `operator`): `string`
Defined in: [src/standards/ERC1155.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L113)
Encode isApprovedForAll(address,address) calldata
#### Parameters
##### account
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### operator
[`AddressType`](../../primitives/Address.mdx#addresstype)
#### Returns
`string`
***
### encodeSafeTransferFrom()
> **encodeSafeTransferFrom**(`from`, `to`, `id`, `amount`, `data`): `string`
Defined in: [src/standards/ERC1155.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L83)
Encode safeTransferFrom(address,address,uint256,uint256,bytes) calldata
#### Parameters
##### from
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### id
[`Type`](../../primitives/Uint.mdx#type)
##### amount
[`Type`](../../primitives/Uint.mdx#type)
##### data
`Uint8Array` = `...`
#### Returns
`string`
***
### encodeSetApprovalForAll()
> **encodeSetApprovalForAll**(`operator`, `approved`): `string`
Defined in: [src/standards/ERC1155.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L66)
Encode setApprovalForAll(address,bool) calldata
#### Parameters
##### operator
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### approved
`boolean`
#### Returns
`string`
***
### encodeURI()
> **encodeURI**(`id`): `string`
Defined in: [src/standards/ERC1155.ts:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC1155.ts#L133)
Encode uri(uint256) calldata
#### Parameters
##### id
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
# ERC165
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/ERC165
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / ERC165
# ERC165
## Variables
### INTERFACE\_IDS
> `const` **INTERFACE\_IDS**: `object`
Defined in: [src/standards/ERC165.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L16)
Known interface IDs (XOR of all function selectors in the interface)
#### Type Declaration
##### ERC1155
> `readonly` **ERC1155**: `"0xd9b67a26"` = `"0xd9b67a26"`
ERC-1155 Multi Token Standard
##### ERC1155MetadataURI
> `readonly` **ERC1155MetadataURI**: `"0x0e89341c"` = `"0x0e89341c"`
ERC-1155 Metadata URI Extension
##### ERC165
> `readonly` **ERC165**: `"0x01ffc9a7"` = `"0x01ffc9a7"`
ERC-165 itself
##### ERC20
> `readonly` **ERC20**: `"0x36372b07"` = `"0x36372b07"`
ERC-20 Token Standard
##### ERC2981
> `readonly` **ERC2981**: `"0x2a55205a"` = `"0x2a55205a"`
ERC-2981 NFT Royalty Standard
##### ERC4906
> `readonly` **ERC4906**: `"0x49064906"` = `"0x49064906"`
ERC-4906 Metadata Update Extension
##### ERC721
> `readonly` **ERC721**: `"0x80ac58cd"` = `"0x80ac58cd"`
ERC-721 Non-Fungible Token
##### ERC721Enumerable
> `readonly` **ERC721Enumerable**: `"0x780e9d63"` = `"0x780e9d63"`
ERC-721 Enumerable Extension
##### ERC721Metadata
> `readonly` **ERC721Metadata**: `"0x5b5e139f"` = `"0x5b5e139f"`
ERC-721 Metadata Extension
***
### SELECTOR
> `const` **SELECTOR**: `"0x01ffc9a7"` = `"0x01ffc9a7"`
Defined in: [src/standards/ERC165.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L11)
ERC-165 function selector
## Functions
### decodeSupportsInterface()
> **decodeSupportsInterface**(`data`): `boolean`
Defined in: [src/standards/ERC165.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L51)
Decode supportsInterface return value
#### Parameters
##### data
`string`
#### Returns
`boolean`
***
### detectInterfaces()
> **detectInterfaces**(`provider`, `contract`): `Promise`\<`string`\[]>
Defined in: [src/standards/ERC165.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L91)
Detect which standard interfaces a contract supports
#### Parameters
##### provider
###### request
##### contract
`string`
#### Returns
`Promise`\<`string`\[]>
***
### encodeSupportsInterface()
> **encodeSupportsInterface**(`interfaceId`): `string`
Defined in: [src/standards/ERC165.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L40)
Encode supportsInterface(bytes4) calldata
#### Parameters
##### interfaceId
`string`
#### Returns
`string`
***
### supportsInterface()
> **supportsInterface**(`provider`, `contract`, `interfaceId`): `Promise`\<`boolean`>
Defined in: [src/standards/ERC165.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC165.ts#L61)
Check if contract supports an interface
#### Parameters
##### provider
Ethereum provider (must support eth\_call)
###### request
##### contract
`string`
Contract address
##### interfaceId
`string`
Interface ID to check (e.g., INTERFACE\_IDS.ERC721)
#### Returns
`Promise`\<`boolean`>
# ERC20
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/ERC20
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / ERC20
# ERC20
Ethereum Token Standards (ERC Standards)
This module provides low-level interfaces for Ethereum token standards:
* ERC-20: Fungible tokens
* ERC-721: Non-fungible tokens (NFTs)
* ERC-1155: Multi-token standard
* ERC-165: Interface detection
Each standard exports:
* Function selectors (first 4 bytes of keccak256 of signature)
* Event signatures (keccak256 of event signature)
* Encoding helpers for calldata
* Decoding helpers for return values and events
## Variables
### EVENTS
> `const` **EVENTS**: `object`
Defined in: [src/standards/ERC20.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L47)
ERC-20 event signatures
keccak256 hash of event signature
#### Type Declaration
##### Approval
> `readonly` **Approval**: `"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"` = `"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"`
Approval(address indexed owner, address indexed spender, uint256 value)
##### Transfer
> `readonly` **Transfer**: `"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"` = `"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"`
Transfer(address indexed from, address indexed to, uint256 value)
***
### SELECTORS
> `const` **SELECTORS**: `object`
Defined in: [src/standards/ERC20.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L15)
ERC-20 function selectors
First 4 bytes of keccak256 hash of function signature
#### Type Declaration
##### allowance
> `readonly` **allowance**: `"0xdd62ed3e"` = `"0xdd62ed3e"`
allowance(address,address)
##### approve
> `readonly` **approve**: `"0x095ea7b3"` = `"0x095ea7b3"`
approve(address,uint256)
##### balanceOf
> `readonly` **balanceOf**: `"0x70a08231"` = `"0x70a08231"`
balanceOf(address)
##### decimals
> `readonly` **decimals**: `"0x313ce567"` = `"0x313ce567"`
decimals()
##### DOMAIN\_SEPARATOR
> `readonly` **DOMAIN\_SEPARATOR**: `"0x3644e515"` = `"0x3644e515"`
DOMAIN\_SEPARATOR()
##### name
> `readonly` **name**: `"0x06fdde03"` = `"0x06fdde03"`
name()
##### nonces
> `readonly` **nonces**: `"0x7ecebe00"` = `"0x7ecebe00"`
nonces(address)
##### permit
> `readonly` **permit**: `"0xd505accf"` = `"0xd505accf"`
permit(address,address,uint256,uint256,uint8,bytes32,bytes32)
##### symbol
> `readonly` **symbol**: `"0x95d89b41"` = `"0x95d89b41"`
symbol()
##### totalSupply
> `readonly` **totalSupply**: `"0x18160ddd"` = `"0x18160ddd"`
totalSupply()
##### transfer
> `readonly` **transfer**: `"0xa9059cbb"` = `"0xa9059cbb"`
transfer(address,uint256)
##### transferFrom
> `readonly` **transferFrom**: `"0x23b872dd"` = `"0x23b872dd"`
transferFrom(address,address,uint256)
## Functions
### decodeAddress()
> **decodeAddress**(`data`): `string`
Defined in: [src/standards/ERC20.ts:190](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L190)
Decode address return value
#### Parameters
##### data
`string`
#### Returns
`string`
***
### decodeApprovalEvent()
> **decodeApprovalEvent**(`log`): `object`
Defined in: [src/standards/ERC20.ts:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L158)
Decode Approval event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### owner
> **owner**: `string`
##### spender
> **spender**: `string`
##### value
> **value**: [`Type`](../../primitives/Uint.mdx#type)
***
### decodeBool()
> **decodeBool**(`data`): `boolean`
Defined in: [src/standards/ERC20.ts:198](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L198)
Decode bool return value
#### Parameters
##### data
`string`
#### Returns
`boolean`
***
### decodeString()
> **decodeString**(`data`): `string`
Defined in: [src/standards/ERC20.ts:205](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L205)
Decode string return value
#### Parameters
##### data
`string`
#### Returns
`string`
***
### decodeTransferEvent()
> **decodeTransferEvent**(`log`): `object`
Defined in: [src/standards/ERC20.ts:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L133)
Decode Transfer event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### from
> **from**: `string`
##### to
> **to**: `string`
##### value
> **value**: [`Type`](../../primitives/Uint.mdx#type)
***
### decodeUint256()
> **decodeUint256**(`data`): [`Type`](../../primitives/Uint.mdx#type)
Defined in: [src/standards/ERC20.ts:183](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L183)
Decode uint256 return value
#### Parameters
##### data
`string`
#### Returns
[`Type`](../../primitives/Uint.mdx#type)
***
### encodeAllowance()
> **encodeAllowance**(`owner`, `spender`): `string`
Defined in: [src/standards/ERC20.ts:116](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L116)
Encode allowance(address,address) calldata
#### Parameters
##### owner
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### spender
[`AddressType`](../../primitives/Address.mdx#addresstype)
#### Returns
`string`
***
### encodeApprove()
> **encodeApprove**(`spender`, `amount`): `string`
Defined in: [src/standards/ERC20.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L71)
Encode approve(address,uint256) calldata
#### Parameters
##### spender
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### amount
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeBalanceOf()
> **encodeBalanceOf**(`account`): `string`
Defined in: [src/standards/ERC20.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L105)
Encode balanceOf(address) calldata
#### Parameters
##### account
[`AddressType`](../../primitives/Address.mdx#addresstype)
#### Returns
`string`
***
### encodeTransfer()
> **encodeTransfer**(`to`, `amount`): `string`
Defined in: [src/standards/ERC20.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L59)
Encode transfer(address,uint256) calldata
#### Parameters
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### amount
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeTransferFrom()
> **encodeTransferFrom**(`from`, `to`, `amount`): `string`
Defined in: [src/standards/ERC20.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC20.ts#L86)
Encode transferFrom(address,address,uint256) calldata
#### Parameters
##### from
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### amount
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
# ERC721
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/ERC721
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / ERC721
# ERC721
## Variables
### EVENTS
> `const` **EVENTS**: `object`
Defined in: [src/standards/ERC721.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L54)
ERC-721 event signatures
keccak256 hash of event signature
#### Type Declaration
##### Approval
> `readonly` **Approval**: `"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"` = `"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"`
Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)
##### ApprovalForAll
> `readonly` **ApprovalForAll**: `"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"` = `"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"`
ApprovalForAll(address indexed owner, address indexed operator, bool approved)
##### Transfer
> `readonly` **Transfer**: `"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"` = `"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"`
Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
***
### SELECTORS
> `const` **SELECTORS**: `object`
Defined in: [src/standards/ERC721.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L15)
ERC-721 function selectors
First 4 bytes of keccak256 hash of function signature
#### Type Declaration
##### approve
> `readonly` **approve**: `"0x095ea7b3"` = `"0x095ea7b3"`
approve(address,uint256)
##### balanceOf
> `readonly` **balanceOf**: `"0x70a08231"` = `"0x70a08231"`
balanceOf(address)
##### getApproved
> `readonly` **getApproved**: `"0x081812fc"` = `"0x081812fc"`
getApproved(uint256)
##### isApprovedForAll
> `readonly` **isApprovedForAll**: `"0xe985e9c5"` = `"0xe985e9c5"`
isApprovedForAll(address,address)
##### name
> `readonly` **name**: `"0x06fdde03"` = `"0x06fdde03"`
name()
##### ownerOf
> `readonly` **ownerOf**: `"0x6352211e"` = `"0x6352211e"`
ownerOf(uint256)
##### safeTransferFrom
> `readonly` **safeTransferFrom**: `"0x42842e0e"` = `"0x42842e0e"`
safeTransferFrom(address,address,uint256)
##### safeTransferFromWithData
> `readonly` **safeTransferFromWithData**: `"0xb88d4fde"` = `"0xb88d4fde"`
safeTransferFrom(address,address,uint256,bytes)
##### setApprovalForAll
> `readonly` **setApprovalForAll**: `"0xa22cb465"` = `"0xa22cb465"`
setApprovalForAll(address,bool)
##### symbol
> `readonly` **symbol**: `"0x95d89b41"` = `"0x95d89b41"`
symbol()
##### tokenByIndex
> `readonly` **tokenByIndex**: `"0x4f6ccce7"` = `"0x4f6ccce7"`
tokenByIndex(uint256)
##### tokenOfOwnerByIndex
> `readonly` **tokenOfOwnerByIndex**: `"0x2f745c59"` = `"0x2f745c59"`
tokenOfOwnerByIndex(address,uint256)
##### tokenURI
> `readonly` **tokenURI**: `"0xc87b56dd"` = `"0xc87b56dd"`
tokenURI(uint256)
##### totalSupply
> `readonly` **totalSupply**: `"0x18160ddd"` = `"0x18160ddd"`
totalSupply()
##### transferFrom
> `readonly` **transferFrom**: `"0x23b872dd"` = `"0x23b872dd"`
transferFrom(address,address,uint256)
## Functions
### decodeApprovalEvent()
> **decodeApprovalEvent**(`log`): `object`
Defined in: [src/standards/ERC721.ts:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L178)
Decode Approval event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### approved
> **approved**: `string`
##### owner
> **owner**: `string`
##### tokenId
> **tokenId**: [`Type`](../../primitives/Uint.mdx#type)
***
### decodeApprovalForAllEvent()
> **decodeApprovalForAllEvent**(`log`): `object`
Defined in: [src/standards/ERC721.ts:204](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L204)
Decode ApprovalForAll event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### approved
> **approved**: `boolean`
##### operator
> **operator**: `string`
##### owner
> **owner**: `string`
***
### decodeTransferEvent()
> **decodeTransferEvent**(`log`): `object`
Defined in: [src/standards/ERC721.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L152)
Decode Transfer event log
#### Parameters
##### log
###### data
`string`
###### topics
`string`\[]
#### Returns
`object`
##### from
> **from**: `string`
##### to
> **to**: `string`
##### tokenId
> **tokenId**: [`Type`](../../primitives/Uint.mdx#type)
***
### encodeApprove()
> **encodeApprove**(`to`, `tokenId`): `string`
Defined in: [src/standards/ERC721.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L107)
Encode approve(address,uint256) calldata
#### Parameters
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### tokenId
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeOwnerOf()
> **encodeOwnerOf**(`tokenId`): `string`
Defined in: [src/standards/ERC721.ts:136](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L136)
Encode ownerOf(uint256) calldata
#### Parameters
##### tokenId
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeSafeTransferFrom()
> **encodeSafeTransferFrom**(`from`, `to`, `tokenId`): `string`
Defined in: [src/standards/ERC721.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L88)
Encode safeTransferFrom(address,address,uint256) calldata
#### Parameters
##### from
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### tokenId
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeSetApprovalForAll()
> **encodeSetApprovalForAll**(`operator`, `approved`): `string`
Defined in: [src/standards/ERC721.ts:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L119)
Encode setApprovalForAll(address,bool) calldata
#### Parameters
##### operator
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### approved
`boolean`
#### Returns
`string`
***
### encodeTokenURI()
> **encodeTokenURI**(`tokenId`): `string`
Defined in: [src/standards/ERC721.ts:144](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L144)
Encode tokenURI(uint256) calldata
#### Parameters
##### tokenId
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
***
### encodeTransferFrom()
> **encodeTransferFrom**(`from`, `to`, `tokenId`): `string`
Defined in: [src/standards/ERC721.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/standards/ERC721.ts#L69)
Encode transferFrom(address,address,uint256) calldata
#### Parameters
##### from
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### to
[`AddressType`](../../primitives/Address.mdx#addresstype)
##### tokenId
[`Type`](../../primitives/Uint.mdx#type)
#### Returns
`string`
# FeeMarket
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/FeeMarket
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / FeeMarket
# FeeMarket
## References
### BaseFee
Re-exports [BaseFee](BrandedFeeMarket.mdx#basefee-5)
***
### BlobBaseFee
Re-exports [BlobBaseFee](BrandedFeeMarket.mdx#blobbasefee)
***
### BlobTxFee
Re-exports [BlobTxFee](BrandedFeeMarket.mdx#blobtxfee)
***
### BlobTxFeeParams
Re-exports [BlobTxFeeParams](BrandedFeeMarket.mdx#blobtxfeeparams)
***
### BrandedState
Re-exports [BrandedState](BrandedFeeMarket.mdx#brandedstate)
***
### calculateBlobTxFee
Re-exports [calculateBlobTxFee](BrandedFeeMarket.mdx#calculateblobtxfee)
***
### calculateExcessBlobGas
Re-exports [calculateExcessBlobGas](BrandedFeeMarket.mdx#calculateexcessblobgas)
***
### calculateTxFee
Re-exports [calculateTxFee](BrandedFeeMarket.mdx#calculatetxfee)
***
### canIncludeTx
Re-exports [canIncludeTx](BrandedFeeMarket.mdx#canincludetx)
***
### Eip1559
Re-exports [Eip1559](BrandedFeeMarket.mdx#eip1559)
***
### Eip1559State
Re-exports [Eip1559State](BrandedFeeMarket.mdx#eip1559state)
***
### Eip4844
Re-exports [Eip4844](BrandedFeeMarket.mdx#eip4844)
***
### Eip4844State
Re-exports [Eip4844State](BrandedFeeMarket.mdx#eip4844state)
***
### FeeMarketType
Renames and re-exports [State](BrandedFeeMarket.mdx#state)
***
### gweiToWei
Re-exports [gweiToWei](BrandedFeeMarket.mdx#gweitowei)
***
### nextState
Re-exports [nextState](BrandedFeeMarket.mdx#nextstate)
***
### projectBaseFees
Re-exports [projectBaseFees](BrandedFeeMarket.mdx#projectbasefees)
***
### State
Re-exports [State](BrandedFeeMarket.mdx#state-1)
***
### TxFee
Re-exports [TxFee](BrandedFeeMarket.mdx#txfee)
***
### TxFeeParams
Re-exports [TxFeeParams](BrandedFeeMarket.mdx#txfeeparams)
***
### validateState
Re-exports [validateState](BrandedFeeMarket.mdx#validatestate)
***
### validateTxFeeParams
Re-exports [validateTxFeeParams](BrandedFeeMarket.mdx#validatetxfeeparams)
***
### weiToGwei
Re-exports [weiToGwei](BrandedFeeMarket.mdx#weitogwei)
# HashType
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/HashType
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / HashType
# HashType
## Type Aliases
### HashLike
> **HashLike** = [`HashType`](#hashtype) | `bigint` | `string` | `Uint8Array`
Defined in: [src/primitives/Hash/HashType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/HashType.ts#L10)
Inputs that can be converted to Hash
***
### HashType
> **HashType** = `Uint8Array` & `object`
Defined in: [src/primitives/Hash/HashType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/HashType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Hash"`
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/Hash/HashType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/HashType.ts#L12)
# precompiles
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/precompiles
Auto-generated API documentation
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / [index](../index.mdx) / precompiles
# precompiles
## Enumerations
### PrecompileAddress
Defined in: [src/evm/precompiles/precompiles.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L18)
#### Enumeration Members
##### BLAKE2F
> **BLAKE2F**: `"0x0000000000000000000000000000000000000009"`
Defined in: [src/evm/precompiles/precompiles.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L27)
##### BLS12\_G1\_ADD
> **BLS12\_G1\_ADD**: `"0x000000000000000000000000000000000000000b"`
Defined in: [src/evm/precompiles/precompiles.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L29)
##### BLS12\_G1\_MSM
> **BLS12\_G1\_MSM**: `"0x000000000000000000000000000000000000000d"`
Defined in: [src/evm/precompiles/precompiles.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L31)
##### BLS12\_G1\_MUL
> **BLS12\_G1\_MUL**: `"0x000000000000000000000000000000000000000c"`
Defined in: [src/evm/precompiles/precompiles.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L30)
##### BLS12\_G2\_ADD
> **BLS12\_G2\_ADD**: `"0x000000000000000000000000000000000000000e"`
Defined in: [src/evm/precompiles/precompiles.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L32)
##### BLS12\_G2\_MSM
> **BLS12\_G2\_MSM**: `"0x0000000000000000000000000000000000000010"`
Defined in: [src/evm/precompiles/precompiles.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L34)
##### BLS12\_G2\_MUL
> **BLS12\_G2\_MUL**: `"0x000000000000000000000000000000000000000f"`
Defined in: [src/evm/precompiles/precompiles.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L33)
##### BLS12\_MAP\_FP\_TO\_G1
> **BLS12\_MAP\_FP\_TO\_G1**: `"0x0000000000000000000000000000000000000012"`
Defined in: [src/evm/precompiles/precompiles.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L36)
##### BLS12\_MAP\_FP2\_TO\_G2
> **BLS12\_MAP\_FP2\_TO\_G2**: `"0x0000000000000000000000000000000000000013"`
Defined in: [src/evm/precompiles/precompiles.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L37)
##### BLS12\_PAIRING
> **BLS12\_PAIRING**: `"0x0000000000000000000000000000000000000011"`
Defined in: [src/evm/precompiles/precompiles.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L35)
##### BN254\_ADD
> **BN254\_ADD**: `"0x0000000000000000000000000000000000000006"`
Defined in: [src/evm/precompiles/precompiles.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L24)
##### BN254\_MUL
> **BN254\_MUL**: `"0x0000000000000000000000000000000000000007"`
Defined in: [src/evm/precompiles/precompiles.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L25)
##### BN254\_PAIRING
> **BN254\_PAIRING**: `"0x0000000000000000000000000000000000000008"`
Defined in: [src/evm/precompiles/precompiles.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L26)
##### ECRECOVER
> **ECRECOVER**: `"0x0000000000000000000000000000000000000001"`
Defined in: [src/evm/precompiles/precompiles.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L19)
##### IDENTITY
> **IDENTITY**: `"0x0000000000000000000000000000000000000004"`
Defined in: [src/evm/precompiles/precompiles.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L22)
##### MODEXP
> **MODEXP**: `"0x0000000000000000000000000000000000000005"`
Defined in: [src/evm/precompiles/precompiles.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L23)
##### POINT\_EVALUATION
> **POINT\_EVALUATION**: `"0x000000000000000000000000000000000000000a"`
Defined in: [src/evm/precompiles/precompiles.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L28)
##### RIPEMD160
> **RIPEMD160**: `"0x0000000000000000000000000000000000000003"`
Defined in: [src/evm/precompiles/precompiles.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L21)
##### SHA256
> **SHA256**: `"0x0000000000000000000000000000000000000002"`
Defined in: [src/evm/precompiles/precompiles.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L20)
## Interfaces
### PrecompileResult
Defined in: [src/evm/precompiles/precompiles.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L40)
#### Properties
##### error?
> `optional` **error**: `string`
Defined in: [src/evm/precompiles/precompiles.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L44)
##### gasUsed
> **gasUsed**: `bigint`
Defined in: [src/evm/precompiles/precompiles.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L43)
##### output
> **output**: `Uint8Array`
Defined in: [src/evm/precompiles/precompiles.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L42)
##### success
> **success**: `boolean`
Defined in: [src/evm/precompiles/precompiles.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L41)
## Functions
### blake2f()
> **blake2f**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:684](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L684)
BLAKE2F precompile (0x09)
Blake2 F compression function per EIP-152
Input format (213 bytes):
* rounds (4 bytes, big-endian) - number of compression rounds
* h (64 bytes) - state vector
* m (128 bytes) - message block
* t (16 bytes) - offset counters
* f (1 byte) - final block flag (must be 0 or 1)
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
#### See
[https://eips.ethereum.org/EIPS/eip-152](https://eips.ethereum.org/EIPS/eip-152)
***
### bls12G1Add()
> **bls12G1Add**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:811](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L811)
BLS12\_G1\_ADD precompile (0x0b)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12G1Msm()
> **bls12G1Msm**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:931](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L931)
BLS12\_G1\_MSM precompile (0x0d)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12G1Mul()
> **bls12G1Mul**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:860](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L860)
BLS12\_G1\_MUL precompile (0x0c)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12G2Add()
> **bls12G2Add**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:992](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L992)
BLS12\_G2\_ADD precompile (0x0e)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12G2Msm()
> **bls12G2Msm**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:1095](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L1095)
BLS12\_G2\_MSM precompile (0x10)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12G2Mul()
> **bls12G2Mul**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:1041](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L1041)
BLS12\_G2\_MUL precompile (0x0f)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12MapFp2ToG2()
> **bls12MapFp2ToG2**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:1292](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L1292)
BLS12\_MAP\_FP2\_TO\_G2 precompile (0x13)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12MapFpToG1()
> **bls12MapFpToG1**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:1244](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L1244)
BLS12\_MAP\_FP\_TO\_G1 precompile (0x12)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bls12Pairing()
> **bls12Pairing**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:1156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L1156)
BLS12\_PAIRING precompile (0x11)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bn254Add()
> **bn254Add**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:545](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L545)
BN254\_ADD precompile (0x06)
BN254 elliptic curve addition
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bn254Mul()
> **bn254Mul**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:583](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L583)
BN254\_MUL precompile (0x07)
BN254 elliptic curve multiplication
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### bn254Pairing()
> **bn254Pairing**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:621](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L621)
BN254\_PAIRING precompile (0x08)
BN254 pairing check
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### ecrecover()
> **ecrecover**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:354](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L354)
ECRECOVER precompile (0x01)
Recover signer address from signature
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### execute()
> **execute**(`address`, `input`, `gasLimit`, `_hardfork`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:274](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L274)
Execute a precompile
#### Parameters
##### address
`string`
Precompile address
##### input
`Uint8Array`
Input data
##### gasLimit
`bigint`
Gas limit for execution
##### \_hardfork
[`HardforkType`](../../primitives/Hardfork.mdx#hardforktype)
#### Returns
[`PrecompileResult`](#precompileresult)
Precompile execution result
***
### identity()
> **identity**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:436](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L436)
IDENTITY precompile (0x04)
Returns input data unchanged
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### isPrecompile()
> **isPrecompile**(`address`, `hardfork`): `boolean`
Defined in: [src/evm/precompiles/precompiles.ts:200](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L200)
Check if an address is a precompile for a given hardfork
#### Parameters
##### address
`string`
##### hardfork
[`HardforkType`](../../primitives/Hardfork.mdx#hardforktype)
#### Returns
`boolean`
***
### modexp()
> **modexp**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:456](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L456)
MODEXP precompile (0x05)
Modular exponentiation
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### pointEvaluation()
> **pointEvaluation**(`_input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:750](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L750)
POINT\_EVALUATION precompile (0x0a)
KZG point evaluation (EIP-4844)
Input format (192 bytes per EIP-4844):
* versioned\_hash (32 bytes) - hash of the blob commitment
* z (32 bytes) - evaluation point
* y (32 bytes) - claimed evaluation result
* commitment (48 bytes) - KZG commitment
* proof (48 bytes) - KZG proof
#### Parameters
##### \_input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### ripemd160()
> **ripemd160**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:411](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L411)
RIPEMD160 precompile (0x03)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
***
### sha256()
> **sha256**(`input`, `gasLimit`): [`PrecompileResult`](#precompileresult)
Defined in: [src/evm/precompiles/precompiles.ts:393](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/evm/precompiles/precompiles.ts#L393)
SHA256 precompile (0x02)
#### Parameters
##### input
`Uint8Array`
##### gasLimit
`bigint`
#### Returns
[`PrecompileResult`](#precompileresult)
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [index](../../index.mdx) / wasm
# wasm
## Namespaces
* [Blake2Wasm](namespaces/Blake2Wasm.mdx)
* [Bn254Wasm](namespaces/Bn254Wasm/index.mdx)
* [Ed25519Wasm](namespaces/Ed25519Wasm.mdx)
* [Eip712Wasm](namespaces/Eip712Wasm/index.mdx)
* [P256Wasm](namespaces/P256Wasm.mdx)
* [Ripemd160Wasm](namespaces/Ripemd160Wasm.mdx)
* [Secp256k1Wasm](namespaces/Secp256k1Wasm/index.mdx)
* [Sha256Wasm](namespaces/Sha256Wasm.mdx)
* [X25519Wasm](namespaces/X25519Wasm.mdx)
## Enumerations
### TransactionType
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L11)
Transaction type enumeration
#### Enumeration Members
##### EIP1559
> **EIP1559**: `2`
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L17)
EIP-1559 fee market transaction
##### EIP2930
> **EIP2930**: `1`
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L15)
EIP-2930 access list transaction
##### EIP4844
> **EIP4844**: `3`
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L19)
EIP-4844 blob transaction
##### EIP7702
> **EIP7702**: `4`
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L21)
EIP-7702 set code transaction
##### Legacy
> **Legacy**: `0`
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L13)
Legacy transaction (pre-EIP-2718)
## Interfaces
### ParsedSignature
Defined in: [src/crypto/signature.wasm.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L18)
#### Properties
##### r
> **r**: `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L12)
R component (32 bytes)
##### s
> **s**: `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L13)
S component (32 bytes)
##### v
> **v**: `number`
Defined in: [src/crypto/signature.wasm.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L14)
Recovery ID (0, 1, 27, or 28)
## Type Aliases
### ParsedSignature
> **ParsedSignature** = `undefined`
Defined in: [src/crypto/signature.wasm.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L18)
ParsedSignature type
## Variables
### Abi
> `const` **Abi**: *typeof* [`Abi`](../../../primitives/Abi/index.mdx#abi) = `AbiJS`
Defined in: [src/wasm/index.ts:234](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L234)
***
### AccessList
> `const` **AccessList**: `object` = `AccessListJS`
Defined in: [src/wasm/index.ts:236](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L236)
#### Type Declaration
##### ADDRESS\_COST
> **ADDRESS\_COST**: `bigint`
Gas cost per address in access list (EIP-2930)
##### addressCount()
> **addressCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
##### assertValid()
> **assertValid**: (`list`) => `void`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`void`
##### COLD\_ACCOUNT\_ACCESS\_COST
> **COLD\_ACCOUNT\_ACCESS\_COST**: `bigint`
Cold account access cost (pre-EIP-2930)
##### COLD\_STORAGE\_ACCESS\_COST
> **COLD\_STORAGE\_ACCESS\_COST**: `bigint`
Cold storage access cost (pre-EIP-2930)
##### create()
> **create**: () => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### deduplicate()
> **deduplicate**: (`list`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### from()
> **from**: (`value`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`> | readonly [`Item`](../../../primitives/AccessList.mdx#item)\[]
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### gasCost()
> **gasCost**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
##### gasSavings()
> **gasSavings**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
##### hasSavings()
> **hasSavings**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
##### includesAddress()
> **includesAddress**: (`list`, `address`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
##### includesStorageKey()
> **includesStorageKey**: (`list`, `address`, `storageKey`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](../HashType.mdx#hashtype)
###### Returns
`boolean`
##### is()
> **is**: (`value`) => `value is BrandedAccessList`
###### Parameters
###### value
`unknown`
###### Returns
`value is BrandedAccessList`
##### isEmpty()
> **isEmpty**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
##### isItem()
> **isItem**: (`value`) => `value is Item`
###### Parameters
###### value
`unknown`
###### Returns
`value is Item`
##### keysFor()
> **keysFor**: (`list`, `address`) => readonly [`HashType`](../HashType.mdx#hashtype)\[] | `undefined`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
readonly [`HashType`](../HashType.mdx#hashtype)\[] | `undefined`
##### merge()
> **merge**: (...`accessLists`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### accessLists
...[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)\[]
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### STORAGE\_KEY\_COST
> **STORAGE\_KEY\_COST**: `bigint`
Gas cost per storage key in access list (EIP-2930)
##### storageKeyCount()
> **storageKeyCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
##### toBytes()
> **toBytes**: (`list`) => `Uint8Array`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`Uint8Array`
##### WARM\_STORAGE\_ACCESS\_COST
> **WARM\_STORAGE\_ACCESS\_COST**: `bigint`
Warm storage access cost (post-EIP-2929)
##### withAddress()
> **withAddress**: (`list`, `address`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### withStorageKey()
> **withStorageKey**: (`list`, `address`, `storageKey`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](../HashType.mdx#hashtype)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
***
### Address
> `const` **Address**: *typeof* [`Address`](../../../primitives/Address.mdx#address) = `AddressJS`
Defined in: [src/wasm/index.ts:229](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L229)
***
### Blake2
> `const` **Blake2**: (`input`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash) & `object` & `object`
Defined in: [src/wasm/index.ts:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L172)
Blake2 with WASM acceleration
#### Type Declaration
##### from()
> **from**: (`input`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash input with BLAKE2b (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto/blake2](https://voltaire.tevm.sh/crypto/blake2) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import { Blake2Hash } from './crypto/Blake2/index.js';
const hash1 = Blake2Hash.from("hello"); // String, 64 bytes
const hash2 = Blake2Hash.from("hello", 32); // String, 32 bytes
const hash3 = Blake2Hash.from(uint8array); // Bytes, 64 bytes
const hash4 = Blake2Hash.from(uint8array, 48); // Bytes, 48 bytes
```
##### fromString()
> **fromString**: (`str`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash) = `hashString`
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
##### hash()
> **hash**: (`data`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash data with BLAKE2b
###### Parameters
###### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2.hash("hello", 32);
```
##### hashString()
> **hashString**: (`str`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
##### SIZE
> **SIZE**: `number`
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Blake2Wasm`](namespaces/Blake2Wasm.mdx) = `Blake2Wasm`
***
### Blob
> `const` **Blob**: *typeof* [`Blob`](../../../primitives/Blob.mdx#blob) = `BlobJS`
Defined in: [src/wasm/index.ts:235](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L235)
***
### BloomFilter
> `const` **BloomFilter**: *typeof* [`BloomFilter`](../../../primitives/BloomFilter.mdx#bloomfilter) = `BloomFilterJS`
Defined in: [src/wasm/index.ts:240](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L240)
***
### Bls12381
> `const` **Bls12381**: `object` = `Bls12381JS`
Defined in: [src/wasm/index.ts:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L253)
#### Type Declaration
##### aggregate()
> **aggregate**: (`signatures`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple BLS signatures into one
The aggregated signature can be verified against an aggregated public key
(when all signers signed the same message) or via batch verification
(when signers signed different messages).
###### Parameters
###### signatures
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G1 signatures (48 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (48 bytes compressed G1)
###### Throws
If aggregation fails or no signatures provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Vote for proposal');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
```
##### aggregatePublicKeys()
> **aggregatePublicKeys**: (`publicKeys`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple public keys into one
Used when multiple signers sign the same message and you want
to verify against a single aggregated public key.
###### Parameters
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G2 public keys (96 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated public key (96 bytes compressed G2)
###### Throws
If aggregation fails or no public keys provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const aggPubKey = Bls12381.aggregatePublicKeys([pubKey1, pubKey2]);
```
##### aggregateVerify()
> **aggregateVerify**: (`aggregatedSignature`, `message`, `publicKeys`) => `boolean`
Verify an aggregated signature where all signers signed the same message
This is the most common case in Ethereum consensus - multiple validators
sign the same block/attestation.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed by all parties
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys of all signers (48 bytes each)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Block attestation');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.aggregateVerify(aggSig, message, [pubKey1, pubKey2]);
console.log(isValid); // true
```
##### batchVerify()
> **batchVerify**: (`aggregatedSignature`, `messages`, `publicKeys`) => `boolean`
Verify an aggregated signature where each signer signed a different message
Uses multi-pairing verification: product of e(pk\_i, H(msg\_i)) == e(G1, aggSig)
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### messages
`Uint8Array`\<`ArrayBufferLike`>\[]
Messages that were signed (one per signer)
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys (one per signer, same order as messages)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Throws
If messages and publicKeys have different lengths
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const msg1 = new TextEncoder().encode('Message 1');
const msg2 = new TextEncoder().encode('Message 2');
const sig1 = Bls12381.sign(msg1, pk1);
const sig2 = Bls12381.sign(msg2, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.batchVerify(aggSig, [msg1, msg2], [pubKey1, pubKey2]);
console.log(isValid); // true
```
##### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Derive a BLS12-381 public key from a private key
Public key = privateKey \* G2\_generator
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
console.log(publicKey.length); // 96
```
##### derivePublicKeyPoint()
> **derivePublicKeyPoint**: (`privateKey`) => [`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Derive a BLS12-381 public key as a G1 point (uncompressed)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
[`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Throws
If private key is invalid
##### fastAggregateVerify()
> **fastAggregateVerify**: (`aggregatedSignature`, `message`, `aggregatedPublicKey`) => `boolean`
Fast aggregate verify (same message case)
Optimized for the common case where all signers signed the same message.
This is faster than aggregateVerify when you already have the aggregated public key.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed
###### aggregatedPublicKey
`Uint8Array`\<`ArrayBufferLike`>
Pre-computed aggregated public key (48 bytes)
###### Returns
`boolean`
True if valid
##### Fp
> **Fp**: [`Fp`](../../../crypto/Bls12381/namespaces/Fp.mdx)
##### Fp2
> **Fp2**: [`Fp2`](../../../crypto/Bls12381/namespaces/Fp2.mdx)
##### Fr
> **Fr**: [`Fr`](../../../crypto/Bls12381/namespaces/Fr.mdx)
##### G1
> **G1**: [`G1`](../../../crypto/Bls12381/namespaces/G1.mdx)
##### G2
> **G2**: [`G2`](../../../crypto/Bls12381/namespaces/G2.mdx)
##### isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Check if a private key is valid
A valid private key must be:
* 32 bytes
* Non-zero
* Less than the curve order (Fr modulus)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key to validate
###### Returns
`boolean`
True if valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk = Bls12381.randomPrivateKey();
console.log(Bls12381.isValidPrivateKey(pk)); // true
const invalid = new Uint8Array(32); // all zeros
console.log(Bls12381.isValidPrivateKey(invalid)); // false
```
##### Pairing
> **Pairing**: [`Pairing`](../../../crypto/Bls12381/namespaces/Pairing.mdx)
BLS12-381 Pairing Operations
Optimal Ate pairing implementation for BLS12-381.
e: G1 x G2 -> GT
NOTE: Full pairing implementation requires Fp6, Fp12 tower extensions
and Miller loop computation. For production use, the native blst
library should be used via the Zig FFI bindings.
This module provides the interface and simplified implementations
for testing and educational purposes.
###### See
[https://hackmd.io/@benjaminion/bls12-381](https://hackmd.io/@benjaminion/bls12-381) for pairing details
###### Since
0.0.0
##### randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a random BLS12-381 private key
Uses cryptographically secure random number generation.
The key is guaranteed to be valid (non-zero and less than curve order).
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
```
##### sign()
> **sign**: (`message`, `privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Sign a message using BLS12-381
Uses the Ethereum consensus "short signatures" scheme:
* Signature = privateKey \* H(message) where H maps to G1
* Signatures are 48 bytes (compressed G1 point)
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message to sign
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Signature as compressed G1 point (48 bytes)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const message = new TextEncoder().encode('Hello, Ethereum!');
const signature = Bls12381.sign(message, privateKey);
```
##### signPoint()
> **signPoint**: (`messagePoint`, `privateKey`) => [`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Sign a pre-hashed message (G2 point) using BLS12-381
For advanced use when you have already hashed the message to G2.
###### Parameters
###### messagePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Message as G2 point
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Signature as G2 point (projective)
###### Throws
If private key is invalid
###### Throws
If signing fails
##### verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify a BLS12-381 signature
Uses pairing check for verification.
###### Parameters
###### signature
`Uint8Array`\<`ArrayBufferLike`>
Compressed G1 signature (48 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message that was signed
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Returns
`boolean`
True if signature is valid
###### Throws
If verification fails due to invalid inputs
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
const message = new TextEncoder().encode('Hello!');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
console.log(isValid); // true
```
##### verifyPoint()
> **verifyPoint**: (`signaturePoint`, `messagePoint`, `publicKeyPoint`) => `boolean`
Verify a BLS signature with pre-computed points (advanced)
For use when you have already deserialized the points.
###### Parameters
###### signaturePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Signature as G2 point
###### messagePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Message hash as G2 point
###### publicKeyPoint
[`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Returns
`boolean`
True if signature is valid
***
### BN254
> `const` **BN254**: `object` & `object`
Defined in: [src/wasm/index.ts:214](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L214)
BN254 with WASM acceleration
#### Type Declaration
##### deserializeG1()
> **deserializeG1**: (`bytes`) => `G1PointType`
Deserialize G1 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### Returns
`G1PointType`
G1 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 64 bytes)
###### Example
```javascript theme={null}
import { deserializeG1 } from './crypto/bn254/deserializeG1.js';
const bytes = new Uint8Array(64);
const point = deserializeG1(bytes);
```
##### deserializeG2()
> **deserializeG2**: (`bytes`) => `G2PointType`
Deserialize G2 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### Returns
`G2PointType`
G2 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 128 bytes)
###### Example
```javascript theme={null}
import { deserializeG2 } from './crypto/bn254/deserializeG2.js';
const bytes = new Uint8Array(128);
const point = deserializeG2(bytes);
```
##### Fp
> **Fp**: `__module`
##### Fp2
> **Fp2**: `__module`
##### Fr
> **Fr**: `__module`
##### G1
> **G1**: `__module`
##### G2
> **G2**: `__module`
##### Pairing
> **Pairing**: `__module`
##### serializeG1()
> **serializeG1**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G1 point to bytes (64 bytes: x || y)
###### Parameters
###### point
`G1PointType`
G1 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG1 } from './crypto/bn254/serializeG1.js';
import * as G1 from './crypto/bn254/G1/index.js';
const point = G1.generator();
const bytes = serializeG1(point);
```
##### serializeG2()
> **serializeG2**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G2 point to bytes (128 bytes: x.c0 || x.c1 || y.c0 || y.c1)
###### Parameters
###### point
`G2PointType`
G2 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG2 } from './crypto/bn254/serializeG2.js';
import * as G2 from './crypto/bn254/G2/index.js';
const point = G2.generator();
const bytes = serializeG2(point);
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Bn254Wasm`](namespaces/Bn254Wasm/index.mdx) = `Bn254Wasm`
***
### Bytecode
> `const` **Bytecode**: *typeof* [`Bytecode`](../../../primitives/Bytecode.mdx#bytecode) = `BytecodeJS`
Defined in: [src/wasm/index.ts:237](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L237)
***
### Bytes
> `const` **Bytes**: *typeof* [`Bytes`](../../index.mdx#bytes) = `BytesJS`
Defined in: [src/wasm/index.ts:242](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L242)
***
### Bytes32
> `const` **Bytes32**: *typeof* [`Bytes32`](../BrandedBytes32.mdx#bytes32) = `Bytes32JS`
Defined in: [src/wasm/index.ts:243](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L243)
***
### Chain
> `const` **Chain**: *typeof* [`Chain`](../BrandedChain.mdx#chain-1) = `ChainJS`
Defined in: [src/wasm/index.ts:238](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L238)
***
### Ed25519
> `const` **Ed25519**: `object` & `object`
Defined in: [src/wasm/index.ts:193](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L193)
Ed25519 with WASM acceleration
#### Type Declaration
##### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => `PublicKey`
Derive Ed25519 public key from secret key.
###### Parameters
###### secretKey
`SecretKey`
32-byte Ed25519 secret key (seed)
###### Returns
`PublicKey`
32-byte Ed25519 public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is invalid or derivation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const secretKey = new Uint8Array(32); // Your secret key
const publicKey = Ed25519.derivePublicKey(secretKey);
```
##### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate Ed25519 keypair from seed deterministically.
###### Parameters
###### seed
`Seed`
32-byte seed for deterministic keypair generation
###### Returns
`object`
Object containing 32-byte secretKey and 32-byte publicKey
###### publicKey
> **publicKey**: `PublicKey`
###### secretKey
> **secretKey**: `SecretKey`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is not 32 bytes
###### Throws
If keypair generation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = Ed25519.keypairFromSeed(seed);
console.log(keypair.publicKey); // Uint8Array(32)
```
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Ed25519 public key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Ed25519/constants.js';
const publicKey = new Uint8Array(PUBLIC_KEY_SIZE);
```
##### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Ed25519 secret key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/Ed25519/constants.js';
const secretKey = new Uint8Array(SECRET_KEY_SIZE);
```
##### SEED\_SIZE
> **SEED\_SIZE**: `32`
Ed25519 seed size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SEED_SIZE } from './crypto/Ed25519/constants.js';
const seed = crypto.getRandomValues(new Uint8Array(SEED_SIZE));
```
##### sign()
> **sign**: (`message`, `secretKey`) => `Signature`
Sign message with Ed25519 secret key.
Produces deterministic signatures using EdDSA.
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message bytes to sign (any length)
###### secretKey
`SecretKey`
32-byte Ed25519 secret key
###### Returns
`Signature`
64-byte Ed25519 signature
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is not 32 bytes
###### Throws
If signing operation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, secretKey);
```
##### SIGNATURE\_SIZE
> **SIGNATURE\_SIZE**: `64`
Ed25519 signature size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIGNATURE_SIZE } from './crypto/Ed25519/constants.js';
const signature = new Uint8Array(SIGNATURE_SIZE);
```
##### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate Ed25519 public key format and curve membership.
###### Parameters
###### publicKey
`PublicKey`
Ed25519 public key to validate
###### Returns
`boolean`
True if public key is valid and on curve, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validatePublicKey(publicKey);
if (!isValid) console.log('Invalid public key');
```
##### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate Ed25519 secret key format.
Checks length and attempts public key derivation.
###### Parameters
###### secretKey
`SecretKey`
Ed25519 secret key to validate
###### Returns
`boolean`
True if secret key is valid (32 bytes and can derive public key), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validateSecretKey(secretKey);
if (!isValid) console.log('Invalid secret key');
```
##### validateSeed()
> **validateSeed**: (`seed`) => `boolean`
Validate Ed25519 seed format.
Checks if seed has correct 32-byte length.
###### Parameters
###### seed
`Seed`
Ed25519 seed to validate
###### Returns
`boolean`
True if seed is exactly 32 bytes, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const isValid = Ed25519.validateSeed(seed); // true
```
##### verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify Ed25519 signature.
Returns false on verification failure instead of throwing.
###### Parameters
###### signature
`Signature`
64-byte Ed25519 signature to verify
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message bytes that were signed
###### publicKey
`PublicKey`
32-byte Ed25519 public key
###### Returns
`boolean`
True if signature is cryptographically valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If public key length is not 32 bytes
###### Throws
If signature length is not 64 bytes
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const valid = Ed25519.verify(signature, message, publicKey);
if (valid) console.log('Signature verified');
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Ed25519Wasm`](namespaces/Ed25519Wasm.mdx) = `Ed25519Wasm`
***
### EIP712
> `const` **EIP712**: `object` & `object`
Defined in: [src/wasm/index.ts:221](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L221)
EIP712 with WASM acceleration
#### Type Declaration
##### Domain
> **Domain**: `object`
###### Domain.hash()
> **hash**: (`domain`) => [`HashType`](../HashType.mdx#hashtype) = `hashDomain`
###### Parameters
###### domain
[`Domain`](../../../crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
##### encodeData()
> **encodeData**: (`primaryType`, `data`, `types`) => `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
##### EncodeData()
> **EncodeData**: (`deps`) => (`primaryType`, `data`, `types`) => `Uint8Array`
Factory: Encode struct data according to EIP-712.
###### Parameters
###### deps
Crypto dependencies
###### encodeValue
(`type`, `value`, `types`) => `Uint8Array`
Encode value function
###### hashType
(`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash type function
###### Returns
Function that encodes data
> (`primaryType`, `data`, `types`): `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType is not found in types
###### Throws
If required field is missing from data
###### Example
```javascript theme={null}
import { EncodeData } from './crypto/EIP712/encodeData.js';
import { HashType } from './hashType.js';
import { EncodeValue } from './encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encodeData = EncodeData({ hashType, encodeValue });
const types = { Person: [{ name: 'name', type: 'string' }, { name: 'wallet', type: 'address' }] };
const encoded = encodeData('Person', { name: 'Alice', wallet: '0x...' }, types);
```
##### encodeType()
> **encodeType**: (`primaryType`, `types`) => `string`
Encode type string for EIP-712 hashing.
Produces type encoding like "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
###### Parameters
###### primaryType
`string`
Primary type name to encode
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
Type definitions mapping
###### Returns
`string`
Encoded type string with primary type followed by referenced types in alphabetical order
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType or any referenced type is not found
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const types = { Mail: [{ name: 'from', type: 'Person' }], Person: [{ name: 'name', type: 'string' }] };
const typeString = EIP712.encodeType('Mail', types);
// Returns: "Mail(Person from)Person(string name)"
```
##### encodeValue()
> **encodeValue**: (`type`, `value`, `types`) => `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](../../../crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
##### EncodeValue()
> **EncodeValue**: (`deps`) => (`type`, `value`, `types`) => `Uint8Array`
Factory: Encode single value to 32 bytes according to EIP-712.
Handles primitive types, arrays, strings, bytes, and custom structs.
Addresses must be pre-validated BrandedAddress types.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`type`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that encodes value
> (`type`, `value`, `types`): `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](../../../crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is unsupported or value format is invalid
###### Example
```javascript theme={null}
import { EncodeValue } from './crypto/EIP712/encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { HashStruct } from './hashStruct.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encoded = encodeValue('uint256', 42n, types);
```
##### format()
> **format**: (`typedData`) => `string`
Format typed data for human-readable display.
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
Typed data to format
###### Returns
`string`
Human-readable multi-line string representation
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const formatted = EIP712.format(typedData);
console.log(formatted);
```
##### HashDomain()
> **HashDomain**: (`deps`) => (`domain`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash EIP-712 domain separator.
Only includes fields that are defined in the domain object.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### Returns
Function that hashes domain
> (`domain`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### domain
[`Domain`](../../../crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If domain type encoding fails
###### Example
```javascript theme={null}
import { Hash as HashDomain } from './crypto/EIP712/Domain/hash.js';
import { HashStruct } from '../hashStruct.js';
import { hash as keccak256 } from '../../Keccak256/hash.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const hashDomain = HashDomain({ hashStruct });
const domain = { name: 'MyApp', version: '1', chainId: 1n };
const domainHash = hashDomain(domain);
```
##### hashStruct()
> **hashStruct**: (`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
##### HashStruct()
> **HashStruct**: (`deps`) => (`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash struct according to EIP-712 specification.
Computes keccak256 of the encoded struct data.
###### Parameters
###### deps
Crypto dependencies
###### encodeData
(`primaryType`, `data`, `types`) => `Uint8Array`
Encode data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes struct
> (`primaryType`, `data`, `types`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashStruct } from './crypto/EIP712/hashStruct.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { EncodeData } from './encodeData.js';
const encodeData = EncodeData({ hashType, encodeValue });
const hashStruct = HashStruct({ keccak256, encodeData });
const types = { Person: [{ name: 'name', type: 'string' }] };
const hash = hashStruct('Person', { name: 'Alice' }, types);
```
##### hashType()
> **hashType**: (`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
##### HashType()
> **HashType**: (`deps`) => (`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash type string according to EIP-712.
Computes keccak256 of the encoded type string.
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes type string
> (`primaryType`, `types`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Example
```javascript theme={null}
import { HashType } from './crypto/EIP712/hashType.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const types = { Mail: [{ name: 'contents', type: 'string' }] };
const typeHash = hashType('Mail', types);
```
##### hashTypedData()
> **hashTypedData**: (`typedData`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
##### HashTypedData()
> **HashTypedData**: (`deps`) => (`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash typed data according to EIP-712 specification.
Computes: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))
###### Parameters
###### deps
Crypto dependencies
###### hashDomain
(`domain`) => [`HashType`](../HashType.mdx#hashtype)
Hash domain function
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes typed data
> (`typedData`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If types are not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashTypedData } from './crypto/EIP712/hashTypedData.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { Hash as HashDomain } from './Domain/hash.js';
import { HashStruct } from './hashStruct.js';
const hashDomain = HashDomain({ hashStruct });
const hashStruct = HashStruct({ keccak256, encodeData });
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const hash = hashTypedData(typedData);
```
##### recoverAddress()
> **recoverAddress**: (`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
##### RecoverAddress()
> **RecoverAddress**: (`deps`) => (`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Factory: Recover Ethereum address from EIP-712 typed data signature.
Uses ECDSA public key recovery to determine the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Hash typed data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `hash`, `recoveryBit`) => `Uint8Array`
Secp256k1 public key recovery function
###### Returns
Function that recovers address
> (`signature`, `typedData`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature recovery fails or public key format is invalid
###### Example
```javascript theme={null}
import { RecoverAddress } from './crypto/EIP712/recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
import { HashTypedData } from './hashTypedData.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const address = recoverAddress(signature, typedData);
```
##### signTypedData()
> **signTypedData**: (`typedData`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
`any`
###### privateKey
`any`
###### Returns
[`Signature`](../../../crypto/EIP712.mdx#signature)
##### SignTypedData()
> **SignTypedData**: (`deps`) => (`typedData`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
Factory: Sign EIP-712 typed data with ECDSA private key.
Produces a signature that can be verified against the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Hash typed data function
###### sign
(`hash`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
Secp256k1 sign function
###### Returns
Function that signs typed data
> (`typedData`, `privateKey`): [`Signature`](../../../crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### privateKey
`Uint8Array`
###### Returns
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key length is invalid or signing fails
###### Example
```javascript theme={null}
import { SignTypedData } from './crypto/EIP712/signTypedData.js';
import { HashTypedData } from './hashTypedData.js';
import { sign } from '../Secp256k1/sign.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const signTypedData = SignTypedData({ hashTypedData, sign });
const privateKey = new Uint8Array(32);
const signature = signTypedData(typedData, privateKey);
```
##### validate()
> **validate**: (`typedData`) => `void`
Validate typed data structure against EIP-712 specification.
Checks domain, types, primaryType, and message structure.
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
Typed data to validate
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If structure is invalid or missing required fields
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
EIP712.validate(typedData); // Throws if invalid
```
##### verifyTypedData()
> **verifyTypedData**: (`signature`, `typedData`, `address`) => `boolean`
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
##### VerifyTypedData()
> **VerifyTypedData**: (`deps`) => (`signature`, `typedData`, `address`) => `boolean`
Factory: Verify EIP-712 typed data signature against expected signer address.
Uses constant-time comparison to prevent timing attacks.
###### Parameters
###### deps
Crypto dependencies
###### recoverAddress
(`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Recover address function
###### Returns
Function that verifies signature
> (`signature`, `typedData`, `address`): `boolean`
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { VerifyTypedData } from './crypto/EIP712/verifyTypedData.js';
import { RecoverAddress } from './recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const verifyTypedData = VerifyTypedData({ recoverAddress });
const valid = verifyTypedData(signature, typedData, signerAddress);
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Eip712Wasm`](namespaces/Eip712Wasm/index.mdx) = `Eip712Wasm`
***
### Ether
> `const` **Ether**: `EtherConstructor` = `EtherJS`
Defined in: [src/wasm/index.ts:247](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L247)
***
### Gwei
> `const` **Gwei**: `GweiConstructor` = `GweiJS`
Defined in: [src/wasm/index.ts:246](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L246)
***
### Hash
> `const` **Hash**: `HashConstructor` = `HashJS`
Defined in: [src/wasm/index.ts:230](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L230)
***
### Hex
> `const` **Hex**: *typeof* [`Hex`](../../index.mdx#hex) = `HexJS`
Defined in: [src/wasm/index.ts:231](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L231)
***
### Keccak256
> `const` **Keccak256**: (`input`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) & `object` & `object`
Defined in: [src/wasm/index.ts:157](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L157)
Keccak256 with WASM acceleration
Falls back to JS implementation, but WASM methods available via `_wasm`
#### Type Declaration
##### contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`\<`ArrayBufferLike`>
Compute contract address from deployer and nonce
Uses CREATE formula: keccak256(rlp(\[sender, nonce]))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const address = Keccak256.contractAddress(sender, 0n);
```
##### create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`\<`ArrayBufferLike`>
Compute CREATE2 address
Uses CREATE2 formula: keccak256(0xff ++ sender ++ salt ++ keccak256(init\_code))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### salt
`Uint8Array`\<`ArrayBufferLike`>
32-byte salt
###### initCodeHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of initialization code
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Throws
If salt is not 32 bytes
###### Throws
If initCodeHash is not 32 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const salt = new Uint8Array(32);
const initCodeHash = new Uint8Array(32);
const address = Keccak256.create2Address(sender, salt, initCodeHash);
```
##### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number`
Digest size in bytes (32 bytes = 256 bits)
###### Since
0.0.0
##### from()
> **from**: (`input`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash input with Keccak-256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/keccak256](https://voltaire.tevm.sh/crypto/keccak256) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash1 = Keccak256Hash.from("0x1234"); // Hex
const hash2 = Keccak256Hash.from("hello"); // String
const hash3 = Keccak256Hash.from(uint8array); // Bytes
```
##### fromHex()
> **fromHex**: (`hex`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `hashHex`
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
##### fromString()
> **fromString**: (`str`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `hashString`
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
##### fromTopic()
> **fromTopic**: (`signature`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `topic`
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
##### hash()
> **hash**: (`data`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash data with Keccak-256
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Data to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(data);
```
##### hashHex()
> **hashHex**: (`hex`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
##### hashMultiple()
> **hashMultiple**: (`chunks`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash multiple data chunks in sequence
Equivalent to hashing the concatenation of all chunks.
###### Parameters
###### chunks
readonly `Uint8Array`\<`ArrayBufferLike`>\[]
Array of data chunks to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(combined);
```
##### hashString()
> **hashString**: (`str`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
##### RATE
> **RATE**: `number`
Rate in bytes for Keccak256 (136 bytes = 1088 bits)
###### Since
0.0.0
##### selector()
> **selector**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Compute function selector (first 4 bytes of Keccak-256 hash)
Used for Ethereum function signatures.
###### Parameters
###### signature
`string`
Function signature string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte selector
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
```
##### STATE\_SIZE
> **STATE\_SIZE**: `number`
State size (25 u64 words = 1600 bits)
###### Since
0.0.0
##### topic()
> **topic**: (`signature`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
#### Type Declaration
##### \_wasm
> **\_wasm**: `object` = `Keccak256Wasm`
###### \_wasm.contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`
Compute CREATE contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`
Contract address (20 bytes)
###### \_wasm.create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`
Compute CREATE2 contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### salt
`Uint8Array`
Salt (32 bytes)
###### initCodeHash
`Uint8Array`
Init code hash (32 bytes)
###### Returns
`Uint8Array`
Contract address (20 bytes)
###### \_wasm.DIGEST\_SIZE
> **DIGEST\_SIZE**: `number` = `32`
###### \_wasm.hash()
> **hash**: (`data`) => [`HashType`](../HashType.mdx#hashtype)
Hash bytes using Keccak256
###### Parameters
###### data
`Uint8Array`
Input bytes to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashHex()
> **hashHex**: (`hex`) => [`HashType`](../HashType.mdx#hashtype)
Hash a hex string
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashMultiple()
> **hashMultiple**: (`chunks`) => [`HashType`](../HashType.mdx#hashtype)
Hash multiple byte arrays in sequence
###### Parameters
###### chunks
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of byte arrays to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashString()
> **hashString**: (`str`) => [`HashType`](../HashType.mdx#hashtype)
Hash a UTF-8 string
###### Parameters
###### str
`string`
String to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.init()
> **init**: () => `Promise`\<`void`>
Initialize WASM module (must be called before using any functions)
###### Returns
`Promise`\<`void`>
###### \_wasm.isReady()
> **isReady**: () => `boolean`
Check if WASM is initialized
###### Returns
`boolean`
###### \_wasm.RATE
> **RATE**: `number` = `136`
###### \_wasm.selector()
> **selector**: (`signature`) => `Uint8Array`
Compute function selector (first 4 bytes of hash)
###### Parameters
###### signature
`string`
Function signature string (e.g., "transfer(address,uint256)")
###### Returns
`Uint8Array`
4-byte function selector
###### \_wasm.STATE\_SIZE
> **STATE\_SIZE**: `number` = `25`
###### \_wasm.topic()
> **topic**: (`signature`) => [`HashType`](../HashType.mdx#hashtype)
Compute event topic (full 32-byte hash)
###### Parameters
###### signature
`string`
Event signature string (e.g., "Transfer(address,address,uint256)")
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte event topic as HashType
***
### Keccak256Wasm
> `const` **Keccak256Wasm**: `object`
Defined in: [src/crypto/keccak256.wasm.ts:238](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/keccak256.wasm.ts#L238)
#### Type Declaration
##### contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`
Compute CREATE contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`
Contract address (20 bytes)
##### create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`
Compute CREATE2 contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### salt
`Uint8Array`
Salt (32 bytes)
###### initCodeHash
`Uint8Array`
Init code hash (32 bytes)
###### Returns
`Uint8Array`
Contract address (20 bytes)
##### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number` = `32`
##### hash()
> **hash**: (`data`) => [`HashType`](../HashType.mdx#hashtype)
Hash bytes using Keccak256
###### Parameters
###### data
`Uint8Array`
Input bytes to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
##### hashHex()
> **hashHex**: (`hex`) => [`HashType`](../HashType.mdx#hashtype)
Hash a hex string
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
##### hashMultiple()
> **hashMultiple**: (`chunks`) => [`HashType`](../HashType.mdx#hashtype)
Hash multiple byte arrays in sequence
###### Parameters
###### chunks
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of byte arrays to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
##### hashString()
> **hashString**: (`str`) => [`HashType`](../HashType.mdx#hashtype)
Hash a UTF-8 string
###### Parameters
###### str
`string`
String to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
##### init()
> **init**: () => `Promise`\<`void`>
Initialize WASM module (must be called before using any functions)
###### Returns
`Promise`\<`void`>
##### isReady()
> **isReady**: () => `boolean`
Check if WASM is initialized
###### Returns
`boolean`
##### RATE
> **RATE**: `number` = `136`
##### selector()
> **selector**: (`signature`) => `Uint8Array`
Compute function selector (first 4 bytes of hash)
###### Parameters
###### signature
`string`
Function signature string (e.g., "transfer(address,uint256)")
###### Returns
`Uint8Array`
4-byte function selector
##### STATE\_SIZE
> **STATE\_SIZE**: `number` = `25`
##### topic()
> **topic**: (`signature`) => [`HashType`](../HashType.mdx#hashtype)
Compute event topic (full 32-byte hash)
###### Parameters
###### signature
`string`
Event signature string (e.g., "Transfer(address,address,uint256)")
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte event topic as HashType
***
### KZG
> `const` **KZG**: *typeof* [`KZG`](../../index.mdx#kzg) = `KZGJS`
Defined in: [src/wasm/index.ts:254](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L254)
***
### ModExp
> `const` **ModExp**: (`base`, `exp`, `modulus`) => `bigint` & `object` = `ModExpJS`
Defined in: [src/wasm/index.ts:255](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L255)
#### Type Declaration
##### calculateGas()
> **calculateGas**: (`baseLen`, `expLen`, `modLen`, `expHead`) => `bigint`
Calculate gas cost for MODEXP operation per EIP-2565
Gas formula: max(200, floor(mult\_complexity \* iteration\_count / 3))
###### Parameters
###### baseLen
`bigint`
Length of base in bytes
###### expLen
`bigint`
Length of exponent in bytes
###### modLen
`bigint`
Length of modulus in bytes
###### expHead
`bigint`
First 32 bytes of exponent as BigInt (for leading zeros calc)
###### Returns
`bigint`
Gas cost
###### See
[https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Calculate gas for 2^3 mod 5
const gas = ModExp.calculateGas(1n, 1n, 1n, 3n);
console.log(gas); // 200n (minimum)
```
##### modexp()
> **modexp**: (`base`, `exp`, `modulus`) => `bigint`
Modular exponentiation: base^exp mod modulus
Computes arbitrary-precision modular exponentiation using native BigInt.
Used by MODEXP precompile (0x05) per EIP-198.
WARNING: This implementation is for general use. For cryptographic
applications, consider timing attack resistance.
###### Parameters
###### base
`bigint`
Base value
###### exp
`bigint`
Exponent value
###### modulus
`bigint`
Modulus value (must be > 0)
###### Returns
`bigint`
Result of base^exp mod modulus
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Compute 2^10 mod 1000 = 24
const result = ModExp.modexp(2n, 10n, 1000n);
console.log(result); // 24n
// RSA verification: signature^e mod n
const verified = ModExp.modexp(signature, e, n);
```
##### modexpBytes()
> **modexpBytes**: (`baseBytes`, `expBytes`, `modBytes`) => `Uint8Array`\<`ArrayBufferLike`>
Modular exponentiation with byte array inputs/outputs
Computes base^exp mod modulus where inputs are big-endian byte arrays.
Output is padded to modulus length per EIP-198 spec.
###### Parameters
###### baseBytes
`Uint8Array`\<`ArrayBufferLike`>
Base as big-endian bytes
###### expBytes
`Uint8Array`\<`ArrayBufferLike`>
Exponent as big-endian bytes
###### modBytes
`Uint8Array`\<`ArrayBufferLike`>
Modulus as big-endian bytes
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Result as big-endian bytes, padded to modulus length
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
const base = new Uint8Array([0x02]); // 2
const exp = new Uint8Array([0x03]); // 3
const mod = new Uint8Array([0x05]); // 5
const result = ModExp.modexpBytes(base, exp, mod);
console.log(result); // Uint8Array([0x03]) = 3
```
***
### Opcode
> `const` **Opcode**: *typeof* [`Opcode`](../../index.mdx#opcode) = `OpcodeJS`
Defined in: [src/wasm/index.ts:239](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L239)
***
### P256
> `const` **P256**: [`P256Constructor`](../../../crypto/P256.mdx#p256constructor) & `object`
Defined in: [src/wasm/index.ts:200](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L200)
P256 with WASM acceleration
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`P256Wasm`](namespaces/P256Wasm.mdx) = `P256Wasm`
***
### Ripemd160
> `const` **Ripemd160**: (`input`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) & `object` & `object`
Defined in: [src/wasm/index.ts:179](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L179)
Ripemd160 with WASM acceleration
#### Type Declaration
##### from()
> **from**: (`input`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Hash input with RIPEMD160 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto/ripemd160](https://voltaire.tevm.sh/crypto/ripemd160) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash1 = Ripemd160Hash.from("hello"); // String
const hash2 = Ripemd160Hash.from(uint8array); // Bytes
```
##### fromHex()
> **fromHex**: (`hex`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) = `hashHex`
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
##### fromString()
> **fromString**: (`str`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) = `hashString`
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
##### hash()
> **hash**: (`data`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash (20 bytes)
###### Parameters
###### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hash(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 20
```
##### hashHex()
> **hashHex**: (`hex`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
##### hashString()
> **hashString**: (`str`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
##### HEX\_SIZE
> **HEX\_SIZE**: `number`
Size of RIPEMD160 hash in hex characters (without 0x prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { HEX_SIZE } from './crypto/Ripemd160/index.js';
console.log(HEX_SIZE); // 40
```
##### SIZE
> **SIZE**: `number`
Size of RIPEMD160 hash in bytes (160 bits)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIZE } from './crypto/Ripemd160/index.js';
console.log(SIZE); // 20
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Ripemd160Wasm`](namespaces/Ripemd160Wasm.mdx) = `Ripemd160Wasm`
***
### Rlp
> `const` **Rlp**: *typeof* [`Rlp`](../../../primitives/Rlp.mdx#rlp) = `RlpJS`
Defined in: [src/wasm/index.ts:233](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L233)
***
### Secp256k1
> `const` **Secp256k1**: `object` & `object`
Defined in: [src/wasm/index.ts:186](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L186)
Secp256k1 with WASM acceleration
#### Type Declaration
##### addPoints()
> **addPoints**: (`pubKey1`, `pubKey2`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Add two secp256k1 public key points
Performs elliptic curve point addition: P1 + P2.
Used in ERC-5564 stealth address generation.
###### Parameters
###### pubKey1
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
First 64-byte uncompressed public key
###### pubKey2
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Second 64-byte uncompressed public key
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If either public key is invalid
###### Throws
If point addition fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const pubKey1 = Secp256k1.derivePublicKey(privateKey1);
const pubKey2 = Secp256k1.derivePublicKey(privateKey2);
const sum = Secp256k1.addPoints(pubKey1, pubKey2);
console.log(sum.length); // 64
```
##### createKeyPair()
> **createKeyPair**: () => `object`
Generate a new secp256k1 key pair
###### Returns
`object`
Key pair with 32-byte private key and 65-byte uncompressed public key
###### privateKey
> **privateKey**: `Uint8Array`
###### publicKey
> **publicKey**: `Uint8Array`
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const { privateKey, publicKey } = Secp256k1.createKeyPair();
```
##### CURVE\_ORDER
> **CURVE\_ORDER**: `bigint`
secp256k1 curve order (number of points on the curve)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { CURVE_ORDER } from './crypto/Secp256k1/index.js';
console.log(CURVE_ORDER); // 0xffffffffffff...
```
##### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Derive public key from private key
Computes the public key point from a private key using scalar
multiplication on the secp256k1 curve.
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from(new Uint8Array(32));
const publicKey = Secp256k1.derivePublicKey(privateKey);
console.log(publicKey.length); // 64
```
##### ecdh()
> **ecdh**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`>
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
##### getSharedSecret()
> **getSharedSecret**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`> = `ecdh`
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
##### isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Validate private key
Checks that the private key is within valid range \[1, n-1] where n
is the curve order.
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
`boolean`
true if private key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const privateKey = new Uint8Array(32);
const valid = Secp256k1.isValidPrivateKey(privateKey);
```
##### isValidPublicKey()
> **isValidPublicKey**: (`publicKey`) => `publicKey is Secp256k1PublicKeyType`
Validate public key
Checks that the public key is a valid point on the secp256k1 curve.
###### Parameters
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
###### Returns
`publicKey is Secp256k1PublicKeyType`
true if public key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const publicKey = new Uint8Array(64);
if (Secp256k1.isValidPublicKey(publicKey)) {
const branded = publicKey; // now Secp256k1PublicKeyType
}
```
##### isValidSignature()
> **isValidSignature**: (`signature`) => `boolean`
Validate signature components
Checks that r and s are within valid range \[1, n-1] where n is the
curve order. Also enforces low-s values to prevent malleability.
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature to validate (r and s are HashType)
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature = { r: Hash.from(new Uint8Array(32)), s: Hash.from(new Uint8Array(32)), v: 27 };
const valid = Secp256k1.isValidSignature(signature);
```
##### PRIVATE\_KEY\_SIZE
> **PRIVATE\_KEY\_SIZE**: `number`
Private key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PRIVATE_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PRIVATE_KEY_SIZE); // 32
```
##### PrivateKey
> **PrivateKey**: `__module` = `PrivateKeyMethods`
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `number`
Uncompressed public key size in bytes (64 bytes, no prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PUBLIC_KEY_SIZE); // 64
```
##### PublicKey
> **PublicKey**: `__module` = `PublicKeyMethods`
##### randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a cryptographically secure random secp256k1 private key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const privateKey = Secp256k1.randomPrivateKey();
const publicKey = Secp256k1.derivePublicKey(privateKey);
```
##### recoverPublicKey()
> **recoverPublicKey**: (`signature`, `messageHash`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and message hash
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash that was signed
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const messageHash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
##### recoverPublicKeyFromHash()
> **recoverPublicKeyFromHash**: (`signature`, `hash`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use recoverPublicKey() instead.
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Recover public key from a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKeyFromHash(
{ r: rBytes, s: sBytes, v: 27 },
hash
);
// For comparison, recoverPublicKey() hashes internally (message-level API)
const recovered2 = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
##### scalarMultiply()
> **scalarMultiply**: (`scalar`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Multiply generator point by scalar
Performs scalar multiplication: scalar \* G (generator point).
Used in ERC-5564 stealth address generation.
###### Parameters
###### scalar
`Uint8Array`\<`ArrayBufferLike`>
32-byte scalar value
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const scalar = new Uint8Array(32);
scalar[31] = 5; // scalar = 5
const result = Secp256k1.scalarMultiply(scalar);
console.log(result.length); // 64
```
##### sign()
> **sign**: (`messageHash`, `privateKey`) => [`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash to sign
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const messageHash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.sign(messageHash, privateKey);
```
##### Signature
> **Signature**: `__module` = `SignatureMethods`
##### SIGNATURE\_COMPONENT\_SIZE
> **SIGNATURE\_COMPONENT\_SIZE**: `number`
Signature component size in bytes (r and s are each 32 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIGNATURE_COMPONENT_SIZE } from './crypto/Secp256k1/index.js';
console.log(SIGNATURE_COMPONENT_SIZE); // 32
```
##### signHash()
> **signHash**: (`hash`, `privateKey`) => [`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a pre-hashed message with a private key
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use sign() instead.
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash to sign (pre-hashed message)
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails or hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
// Sign a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.signHash(hash, privateKey);
// For comparison, sign() hashes internally (message-level API)
const signature2 = Secp256k1.sign(Hash.keccak256String('Hello!'), privateKey);
```
##### verify()
> **verify**: (`signature`, `messageHash`, `publicKey`) => `boolean`
Verify an ECDSA signature
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash that was signed
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature v is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
##### verifyHash()
> **verifyHash**: (`signature`, `hash`, `publicKey`) => `boolean`
Verify an ECDSA signature against a pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use verify() instead.
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Verify a signature against a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const valid = Secp256k1.verifyHash({ r, s, v: 27 }, hash, publicKey);
// For comparison, verify() hashes internally (message-level API)
const valid2 = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Secp256k1Wasm`](namespaces/Secp256k1Wasm/index.mdx) = `Secp256k1Wasm`
***
### SHA256
> `const` **SHA256**: (`input`) => [`SHA256Hash`](../../index.mdx#sha256hash) & `object` & `object`
Defined in: [src/wasm/index.ts:165](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L165)
SHA256 with WASM acceleration
#### Type Declaration
##### BLOCK\_SIZE
> **BLOCK\_SIZE**: `number`
SHA256 block size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { BLOCK_SIZE } from './crypto/SHA256/index.js';
console.log(BLOCK_SIZE); // 64
```
##### create()
> **create**: () => `object`
Incremental hasher for streaming data
###### Returns
`object`
Hasher instance
###### digest()
> **digest**: () => `Uint8Array`
###### Returns
`Uint8Array`
###### update()
> **update**: (`data`) => `void`
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hasher = SHA256.create();
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new Uint8Array([4, 5, 6]));
const hash = hasher.digest();
```
##### from()
> **from**: (`input`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Hash input with SHA256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/sha256](https://voltaire.tevm.sh/crypto/sha256) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash1 = SHA256Hash.from("0x1234"); // Hex
const hash2 = SHA256Hash.from("hello"); // String
const hash3 = SHA256Hash.from(uint8array); // Bytes
```
##### fromHex()
> **fromHex**: (`hex`) => [`SHA256Hash`](../../index.mdx#sha256hash) = `hashHex`
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
##### fromString()
> **fromString**: (`str`) => [`SHA256Hash`](../../index.mdx#sha256hash) = `hashString`
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
##### hash()
> **hash**: (`data`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of input data
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Input data as Uint8Array
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash = SHA256Hash.from(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 32
```
##### hashHex()
> **hashHex**: (`hex`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
##### hashString()
> **hashString**: (`str`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
##### OUTPUT\_SIZE
> **OUTPUT\_SIZE**: `number`
SHA256 output size in bytes (256 bits / 8)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { OUTPUT_SIZE } from './crypto/SHA256/index.js';
console.log(OUTPUT_SIZE); // 32
```
##### toHex()
> **toHex**: (`hash`) => `string`
Convert hash output to hex string
###### Parameters
###### hash
`Uint8Array`\<`ArrayBufferLike`>
Hash bytes
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hash(new Uint8Array([1, 2, 3]));
const hexStr = SHA256.toHex(hash);
console.log(hexStr); // "0x..."
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`Sha256Wasm`](namespaces/Sha256Wasm.mdx) = `Sha256Wasm`
***
### Siwe
> `const` **Siwe**: *typeof* [`Siwe`](../../../primitives/Siwe.mdx#siwe) = `SiweJS`
Defined in: [src/wasm/index.ts:241](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L241)
***
### StorageKey
> `const` **StorageKey**: `object` = `StorageKeyJS`
Defined in: [src/wasm/index.ts:244](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L244)
#### Type Declaration
##### create()
> **create**: (`address`, `slot`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### b
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### Parameters
###### value
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
##### fromString()
> **fromString**: (`str`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype) | `undefined`
###### Parameters
###### str
`string`
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype) | `undefined`
##### hashCode()
> **hashCode**: (`key`) => `number`
###### Parameters
###### key
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`number`
##### is()
> **is**: (`value`) => `value is StorageKeyType`
###### Parameters
###### value
`unknown`
###### Returns
`value is StorageKeyType`
##### toString()
> **toString**: (`key`) => `string`
###### Parameters
###### key
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`string`
***
### Uint
> `const` **Uint**: *typeof* [`Uint`](../../index.mdx#uint) = `UintJS`
Defined in: [src/wasm/index.ts:232](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L232)
***
### wasmAPI
> `const` **wasmAPI**: `object`
Defined in: [src/wasm/index.ts:264](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L264)
#### Type Declaration
##### Abi
> **Abi**: *typeof* [`Abi`](../../../primitives/Abi/index.mdx#abi)
##### AccessList
> **AccessList**: `object`
###### AccessList.ADDRESS\_COST
> **ADDRESS\_COST**: `bigint`
Gas cost per address in access list (EIP-2930)
###### AccessList.addressCount()
> **addressCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
###### AccessList.assertValid()
> **assertValid**: (`list`) => `void`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`void`
###### AccessList.COLD\_ACCOUNT\_ACCESS\_COST
> **COLD\_ACCOUNT\_ACCESS\_COST**: `bigint`
Cold account access cost (pre-EIP-2930)
###### AccessList.COLD\_STORAGE\_ACCESS\_COST
> **COLD\_STORAGE\_ACCESS\_COST**: `bigint`
Cold storage access cost (pre-EIP-2930)
###### AccessList.create()
> **create**: () => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.deduplicate()
> **deduplicate**: (`list`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.from()
> **from**: (`value`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`> | readonly [`Item`](../../../primitives/AccessList.mdx#item)\[]
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.gasCost()
> **gasCost**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
###### AccessList.gasSavings()
> **gasSavings**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
###### AccessList.hasSavings()
> **hasSavings**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
###### AccessList.includesAddress()
> **includesAddress**: (`list`, `address`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### AccessList.includesStorageKey()
> **includesStorageKey**: (`list`, `address`, `storageKey`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](../HashType.mdx#hashtype)
###### Returns
`boolean`
###### AccessList.is()
> **is**: (`value`) => `value is BrandedAccessList`
###### Parameters
###### value
`unknown`
###### Returns
`value is BrandedAccessList`
###### AccessList.isEmpty()
> **isEmpty**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
###### AccessList.isItem()
> **isItem**: (`value`) => `value is Item`
###### Parameters
###### value
`unknown`
###### Returns
`value is Item`
###### AccessList.keysFor()
> **keysFor**: (`list`, `address`) => readonly [`HashType`](../HashType.mdx#hashtype)\[] | `undefined`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
readonly [`HashType`](../HashType.mdx#hashtype)\[] | `undefined`
###### AccessList.merge()
> **merge**: (...`accessLists`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### accessLists
...[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)\[]
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.STORAGE\_KEY\_COST
> **STORAGE\_KEY\_COST**: `bigint`
Gas cost per storage key in access list (EIP-2930)
###### AccessList.storageKeyCount()
> **storageKeyCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
###### AccessList.toBytes()
> **toBytes**: (`list`) => `Uint8Array`
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`Uint8Array`
###### AccessList.WARM\_STORAGE\_ACCESS\_COST
> **WARM\_STORAGE\_ACCESS\_COST**: `bigint`
Warm storage access cost (post-EIP-2929)
###### AccessList.withAddress()
> **withAddress**: (`list`, `address`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.withStorageKey()
> **withStorageKey**: (`list`, `address`, `storageKey`) => [`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](../HashType.mdx#hashtype)
###### Returns
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
##### Address
> **Address**: *typeof* [`Address`](../../../primitives/Address.mdx#address)
##### Blake2
> **Blake2**: (`input`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash) & `object` & `object`
Blake2 with WASM acceleration
###### Type Declaration
###### from()
> **from**: (`input`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash input with BLAKE2b (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto/blake2](https://voltaire.tevm.sh/crypto/blake2) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import { Blake2Hash } from './crypto/Blake2/index.js';
const hash1 = Blake2Hash.from("hello"); // String, 64 bytes
const hash2 = Blake2Hash.from("hello", 32); // String, 32 bytes
const hash3 = Blake2Hash.from(uint8array); // Bytes, 64 bytes
const hash4 = Blake2Hash.from(uint8array, 48); // Bytes, 48 bytes
```
###### fromString()
> **fromString**: (`str`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash) = `hashString`
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
###### hash()
> **hash**: (`data`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash data with BLAKE2b
###### Parameters
###### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2.hash("hello", 32);
```
###### hashString()
> **hashString**: (`str`, `outputLength?`) => [`Blake2Hash`](../../index.mdx#blake2hash)
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](../../index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
###### SIZE
> **SIZE**: `number`
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Blake2Wasm`](namespaces/Blake2Wasm.mdx) = `Blake2Wasm`
##### Blob
> **Blob**: *typeof* [`Blob`](../../../primitives/Blob.mdx#blob)
##### BloomFilter
> **BloomFilter**: *typeof* [`BloomFilter`](../../../primitives/BloomFilter.mdx#bloomfilter)
##### Bls12381
> **Bls12381**: `object`
###### Bls12381.aggregate()
> **aggregate**: (`signatures`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple BLS signatures into one
The aggregated signature can be verified against an aggregated public key
(when all signers signed the same message) or via batch verification
(when signers signed different messages).
###### Parameters
###### signatures
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G1 signatures (48 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (48 bytes compressed G1)
###### Throws
If aggregation fails or no signatures provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Vote for proposal');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
```
###### Bls12381.aggregatePublicKeys()
> **aggregatePublicKeys**: (`publicKeys`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple public keys into one
Used when multiple signers sign the same message and you want
to verify against a single aggregated public key.
###### Parameters
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G2 public keys (96 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated public key (96 bytes compressed G2)
###### Throws
If aggregation fails or no public keys provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const aggPubKey = Bls12381.aggregatePublicKeys([pubKey1, pubKey2]);
```
###### Bls12381.aggregateVerify()
> **aggregateVerify**: (`aggregatedSignature`, `message`, `publicKeys`) => `boolean`
Verify an aggregated signature where all signers signed the same message
This is the most common case in Ethereum consensus - multiple validators
sign the same block/attestation.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed by all parties
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys of all signers (48 bytes each)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Block attestation');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.aggregateVerify(aggSig, message, [pubKey1, pubKey2]);
console.log(isValid); // true
```
###### Bls12381.batchVerify()
> **batchVerify**: (`aggregatedSignature`, `messages`, `publicKeys`) => `boolean`
Verify an aggregated signature where each signer signed a different message
Uses multi-pairing verification: product of e(pk\_i, H(msg\_i)) == e(G1, aggSig)
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### messages
`Uint8Array`\<`ArrayBufferLike`>\[]
Messages that were signed (one per signer)
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys (one per signer, same order as messages)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Throws
If messages and publicKeys have different lengths
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const msg1 = new TextEncoder().encode('Message 1');
const msg2 = new TextEncoder().encode('Message 2');
const sig1 = Bls12381.sign(msg1, pk1);
const sig2 = Bls12381.sign(msg2, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.batchVerify(aggSig, [msg1, msg2], [pubKey1, pubKey2]);
console.log(isValid); // true
```
###### Bls12381.derivePublicKey()
> **derivePublicKey**: (`privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Derive a BLS12-381 public key from a private key
Public key = privateKey \* G2\_generator
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
console.log(publicKey.length); // 96
```
###### Bls12381.derivePublicKeyPoint()
> **derivePublicKeyPoint**: (`privateKey`) => [`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Derive a BLS12-381 public key as a G1 point (uncompressed)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
[`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Throws
If private key is invalid
###### Bls12381.fastAggregateVerify()
> **fastAggregateVerify**: (`aggregatedSignature`, `message`, `aggregatedPublicKey`) => `boolean`
Fast aggregate verify (same message case)
Optimized for the common case where all signers signed the same message.
This is faster than aggregateVerify when you already have the aggregated public key.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed
###### aggregatedPublicKey
`Uint8Array`\<`ArrayBufferLike`>
Pre-computed aggregated public key (48 bytes)
###### Returns
`boolean`
True if valid
###### Bls12381.Fp
> **Fp**: [`Fp`](../../../crypto/Bls12381/namespaces/Fp.mdx)
###### Bls12381.Fp2
> **Fp2**: [`Fp2`](../../../crypto/Bls12381/namespaces/Fp2.mdx)
###### Bls12381.Fr
> **Fr**: [`Fr`](../../../crypto/Bls12381/namespaces/Fr.mdx)
###### Bls12381.G1
> **G1**: [`G1`](../../../crypto/Bls12381/namespaces/G1.mdx)
###### Bls12381.G2
> **G2**: [`G2`](../../../crypto/Bls12381/namespaces/G2.mdx)
###### Bls12381.isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Check if a private key is valid
A valid private key must be:
* 32 bytes
* Non-zero
* Less than the curve order (Fr modulus)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key to validate
###### Returns
`boolean`
True if valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk = Bls12381.randomPrivateKey();
console.log(Bls12381.isValidPrivateKey(pk)); // true
const invalid = new Uint8Array(32); // all zeros
console.log(Bls12381.isValidPrivateKey(invalid)); // false
```
###### Bls12381.Pairing
> **Pairing**: [`Pairing`](../../../crypto/Bls12381/namespaces/Pairing.mdx)
BLS12-381 Pairing Operations
Optimal Ate pairing implementation for BLS12-381.
e: G1 x G2 -> GT
NOTE: Full pairing implementation requires Fp6, Fp12 tower extensions
and Miller loop computation. For production use, the native blst
library should be used via the Zig FFI bindings.
This module provides the interface and simplified implementations
for testing and educational purposes.
###### See
[https://hackmd.io/@benjaminion/bls12-381](https://hackmd.io/@benjaminion/bls12-381) for pairing details
###### Since
0.0.0
###### Bls12381.randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a random BLS12-381 private key
Uses cryptographically secure random number generation.
The key is guaranteed to be valid (non-zero and less than curve order).
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
```
###### Bls12381.sign()
> **sign**: (`message`, `privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Sign a message using BLS12-381
Uses the Ethereum consensus "short signatures" scheme:
* Signature = privateKey \* H(message) where H maps to G1
* Signatures are 48 bytes (compressed G1 point)
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message to sign
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Signature as compressed G1 point (48 bytes)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const message = new TextEncoder().encode('Hello, Ethereum!');
const signature = Bls12381.sign(message, privateKey);
```
###### Bls12381.signPoint()
> **signPoint**: (`messagePoint`, `privateKey`) => [`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Sign a pre-hashed message (G2 point) using BLS12-381
For advanced use when you have already hashed the message to G2.
###### Parameters
###### messagePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Message as G2 point
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Signature as G2 point (projective)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Bls12381.verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify a BLS12-381 signature
Uses pairing check for verification.
###### Parameters
###### signature
`Uint8Array`\<`ArrayBufferLike`>
Compressed G1 signature (48 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message that was signed
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Returns
`boolean`
True if signature is valid
###### Throws
If verification fails due to invalid inputs
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
const message = new TextEncoder().encode('Hello!');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
console.log(isValid); // true
```
###### Bls12381.verifyPoint()
> **verifyPoint**: (`signaturePoint`, `messagePoint`, `publicKeyPoint`) => `boolean`
Verify a BLS signature with pre-computed points (advanced)
For use when you have already deserialized the points.
###### Parameters
###### signaturePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Signature as G2 point
###### messagePoint
[`Bls12381G2PointType`](../../index.mdx#bls12381g2pointtype)
Message hash as G2 point
###### publicKeyPoint
[`Bls12381G1PointType`](../../index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Returns
`boolean`
True if signature is valid
##### BN254
> **BN254**: `object` & `object`
BN254 with WASM acceleration
###### Type Declaration
###### deserializeG1()
> **deserializeG1**: (`bytes`) => `G1PointType`
Deserialize G1 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### Returns
`G1PointType`
G1 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 64 bytes)
###### Example
```javascript theme={null}
import { deserializeG1 } from './crypto/bn254/deserializeG1.js';
const bytes = new Uint8Array(64);
const point = deserializeG1(bytes);
```
###### deserializeG2()
> **deserializeG2**: (`bytes`) => `G2PointType`
Deserialize G2 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### Returns
`G2PointType`
G2 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 128 bytes)
###### Example
```javascript theme={null}
import { deserializeG2 } from './crypto/bn254/deserializeG2.js';
const bytes = new Uint8Array(128);
const point = deserializeG2(bytes);
```
###### Fp
> **Fp**: `__module`
###### Fp2
> **Fp2**: `__module`
###### Fr
> **Fr**: `__module`
###### G1
> **G1**: `__module`
###### G2
> **G2**: `__module`
###### Pairing
> **Pairing**: `__module`
###### serializeG1()
> **serializeG1**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G1 point to bytes (64 bytes: x || y)
###### Parameters
###### point
`G1PointType`
G1 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG1 } from './crypto/bn254/serializeG1.js';
import * as G1 from './crypto/bn254/G1/index.js';
const point = G1.generator();
const bytes = serializeG1(point);
```
###### serializeG2()
> **serializeG2**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G2 point to bytes (128 bytes: x.c0 || x.c1 || y.c0 || y.c1)
###### Parameters
###### point
`G2PointType`
G2 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG2 } from './crypto/bn254/serializeG2.js';
import * as G2 from './crypto/bn254/G2/index.js';
const point = G2.generator();
const bytes = serializeG2(point);
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Bn254Wasm`](namespaces/Bn254Wasm/index.mdx) = `Bn254Wasm`
##### Bytecode
> **Bytecode**: *typeof* [`Bytecode`](../../../primitives/Bytecode.mdx#bytecode)
##### Bytes
> **Bytes**: *typeof* [`Bytes`](../../index.mdx#bytes)
##### Bytes32
> **Bytes32**: *typeof* [`Bytes32`](../BrandedBytes32.mdx#bytes32)
##### Chain
> **Chain**: *typeof* [`Chain`](../BrandedChain.mdx#chain-1)
##### Ed25519
> **Ed25519**: `object` & `object`
Ed25519 with WASM acceleration
###### Type Declaration
###### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => `PublicKey`
Derive Ed25519 public key from secret key.
###### Parameters
###### secretKey
`SecretKey`
32-byte Ed25519 secret key (seed)
###### Returns
`PublicKey`
32-byte Ed25519 public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is invalid or derivation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const secretKey = new Uint8Array(32); // Your secret key
const publicKey = Ed25519.derivePublicKey(secretKey);
```
###### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate Ed25519 keypair from seed deterministically.
###### Parameters
###### seed
`Seed`
32-byte seed for deterministic keypair generation
###### Returns
`object`
Object containing 32-byte secretKey and 32-byte publicKey
###### publicKey
> **publicKey**: `PublicKey`
###### secretKey
> **secretKey**: `SecretKey`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is not 32 bytes
###### Throws
If keypair generation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = Ed25519.keypairFromSeed(seed);
console.log(keypair.publicKey); // Uint8Array(32)
```
###### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Ed25519 public key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Ed25519/constants.js';
const publicKey = new Uint8Array(PUBLIC_KEY_SIZE);
```
###### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Ed25519 secret key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/Ed25519/constants.js';
const secretKey = new Uint8Array(SECRET_KEY_SIZE);
```
###### SEED\_SIZE
> **SEED\_SIZE**: `32`
Ed25519 seed size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SEED_SIZE } from './crypto/Ed25519/constants.js';
const seed = crypto.getRandomValues(new Uint8Array(SEED_SIZE));
```
###### sign()
> **sign**: (`message`, `secretKey`) => `Signature`
Sign message with Ed25519 secret key.
Produces deterministic signatures using EdDSA.
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message bytes to sign (any length)
###### secretKey
`SecretKey`
32-byte Ed25519 secret key
###### Returns
`Signature`
64-byte Ed25519 signature
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is not 32 bytes
###### Throws
If signing operation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, secretKey);
```
###### SIGNATURE\_SIZE
> **SIGNATURE\_SIZE**: `64`
Ed25519 signature size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIGNATURE_SIZE } from './crypto/Ed25519/constants.js';
const signature = new Uint8Array(SIGNATURE_SIZE);
```
###### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate Ed25519 public key format and curve membership.
###### Parameters
###### publicKey
`PublicKey`
Ed25519 public key to validate
###### Returns
`boolean`
True if public key is valid and on curve, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validatePublicKey(publicKey);
if (!isValid) console.log('Invalid public key');
```
###### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate Ed25519 secret key format.
Checks length and attempts public key derivation.
###### Parameters
###### secretKey
`SecretKey`
Ed25519 secret key to validate
###### Returns
`boolean`
True if secret key is valid (32 bytes and can derive public key), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validateSecretKey(secretKey);
if (!isValid) console.log('Invalid secret key');
```
###### validateSeed()
> **validateSeed**: (`seed`) => `boolean`
Validate Ed25519 seed format.
Checks if seed has correct 32-byte length.
###### Parameters
###### seed
`Seed`
Ed25519 seed to validate
###### Returns
`boolean`
True if seed is exactly 32 bytes, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const isValid = Ed25519.validateSeed(seed); // true
```
###### verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify Ed25519 signature.
Returns false on verification failure instead of throwing.
###### Parameters
###### signature
`Signature`
64-byte Ed25519 signature to verify
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message bytes that were signed
###### publicKey
`PublicKey`
32-byte Ed25519 public key
###### Returns
`boolean`
True if signature is cryptographically valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If public key length is not 32 bytes
###### Throws
If signature length is not 64 bytes
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const valid = Ed25519.verify(signature, message, publicKey);
if (valid) console.log('Signature verified');
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Ed25519Wasm`](namespaces/Ed25519Wasm.mdx) = `Ed25519Wasm`
##### EIP712
> **EIP712**: `object` & `object`
EIP712 with WASM acceleration
###### Type Declaration
###### Domain
> **Domain**: `object`
###### Domain.hash()
> **hash**: (`domain`) => [`HashType`](../HashType.mdx#hashtype) = `hashDomain`
###### Parameters
###### domain
[`Domain`](../../../crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### encodeData()
> **encodeData**: (`primaryType`, `data`, `types`) => `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### EncodeData()
> **EncodeData**: (`deps`) => (`primaryType`, `data`, `types`) => `Uint8Array`
Factory: Encode struct data according to EIP-712.
###### Parameters
###### deps
Crypto dependencies
###### encodeValue
(`type`, `value`, `types`) => `Uint8Array`
Encode value function
###### hashType
(`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash type function
###### Returns
Function that encodes data
> (`primaryType`, `data`, `types`): `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType is not found in types
###### Throws
If required field is missing from data
###### Example
```javascript theme={null}
import { EncodeData } from './crypto/EIP712/encodeData.js';
import { HashType } from './hashType.js';
import { EncodeValue } from './encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encodeData = EncodeData({ hashType, encodeValue });
const types = { Person: [{ name: 'name', type: 'string' }, { name: 'wallet', type: 'address' }] };
const encoded = encodeData('Person', { name: 'Alice', wallet: '0x...' }, types);
```
###### encodeType()
> **encodeType**: (`primaryType`, `types`) => `string`
Encode type string for EIP-712 hashing.
Produces type encoding like "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
###### Parameters
###### primaryType
`string`
Primary type name to encode
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
Type definitions mapping
###### Returns
`string`
Encoded type string with primary type followed by referenced types in alphabetical order
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType or any referenced type is not found
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const types = { Mail: [{ name: 'from', type: 'Person' }], Person: [{ name: 'name', type: 'string' }] };
const typeString = EIP712.encodeType('Mail', types);
// Returns: "Mail(Person from)Person(string name)"
```
###### encodeValue()
> **encodeValue**: (`type`, `value`, `types`) => `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](../../../crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### EncodeValue()
> **EncodeValue**: (`deps`) => (`type`, `value`, `types`) => `Uint8Array`
Factory: Encode single value to 32 bytes according to EIP-712.
Handles primitive types, arrays, strings, bytes, and custom structs.
Addresses must be pre-validated BrandedAddress types.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`type`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that encodes value
> (`type`, `value`, `types`): `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](../../../crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is unsupported or value format is invalid
###### Example
```javascript theme={null}
import { EncodeValue } from './crypto/EIP712/encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { HashStruct } from './hashStruct.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encoded = encodeValue('uint256', 42n, types);
```
###### format()
> **format**: (`typedData`) => `string`
Format typed data for human-readable display.
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
Typed data to format
###### Returns
`string`
Human-readable multi-line string representation
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const formatted = EIP712.format(typedData);
console.log(formatted);
```
###### HashDomain()
> **HashDomain**: (`deps`) => (`domain`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash EIP-712 domain separator.
Only includes fields that are defined in the domain object.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### Returns
Function that hashes domain
> (`domain`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### domain
[`Domain`](../../../crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If domain type encoding fails
###### Example
```javascript theme={null}
import { Hash as HashDomain } from './crypto/EIP712/Domain/hash.js';
import { HashStruct } from '../hashStruct.js';
import { hash as keccak256 } from '../../Keccak256/hash.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const hashDomain = HashDomain({ hashStruct });
const domain = { name: 'MyApp', version: '1', chainId: 1n };
const domainHash = hashDomain(domain);
```
###### hashStruct()
> **hashStruct**: (`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### HashStruct()
> **HashStruct**: (`deps`) => (`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash struct according to EIP-712 specification.
Computes keccak256 of the encoded struct data.
###### Parameters
###### deps
Crypto dependencies
###### encodeData
(`primaryType`, `data`, `types`) => `Uint8Array`
Encode data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes struct
> (`primaryType`, `data`, `types`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](../../../crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashStruct } from './crypto/EIP712/hashStruct.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { EncodeData } from './encodeData.js';
const encodeData = EncodeData({ hashType, encodeValue });
const hashStruct = HashStruct({ keccak256, encodeData });
const types = { Person: [{ name: 'name', type: 'string' }] };
const hash = hashStruct('Person', { name: 'Alice' }, types);
```
###### hashType()
> **hashType**: (`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### HashType()
> **HashType**: (`deps`) => (`primaryType`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash type string according to EIP-712.
Computes keccak256 of the encoded type string.
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes type string
> (`primaryType`, `types`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](../../../crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Example
```javascript theme={null}
import { HashType } from './crypto/EIP712/hashType.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const types = { Mail: [{ name: 'contents', type: 'string' }] };
const typeHash = hashType('Mail', types);
```
###### hashTypedData()
> **hashTypedData**: (`typedData`) => [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### HashTypedData()
> **HashTypedData**: (`deps`) => (`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Factory: Hash typed data according to EIP-712 specification.
Computes: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))
###### Parameters
###### deps
Crypto dependencies
###### hashDomain
(`domain`) => [`HashType`](../HashType.mdx#hashtype)
Hash domain function
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](../HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes typed data
> (`typedData`): [`HashType`](../HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If types are not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashTypedData } from './crypto/EIP712/hashTypedData.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { Hash as HashDomain } from './Domain/hash.js';
import { HashStruct } from './hashStruct.js';
const hashDomain = HashDomain({ hashStruct });
const hashStruct = HashStruct({ keccak256, encodeData });
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const hash = hashTypedData(typedData);
```
###### recoverAddress()
> **recoverAddress**: (`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### RecoverAddress()
> **RecoverAddress**: (`deps`) => (`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Factory: Recover Ethereum address from EIP-712 typed data signature.
Uses ECDSA public key recovery to determine the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Hash typed data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `hash`, `recoveryBit`) => `Uint8Array`
Secp256k1 public key recovery function
###### Returns
Function that recovers address
> (`signature`, `typedData`): [`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature recovery fails or public key format is invalid
###### Example
```javascript theme={null}
import { RecoverAddress } from './crypto/EIP712/recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
import { HashTypedData } from './hashTypedData.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const address = recoverAddress(signature, typedData);
```
###### signTypedData()
> **signTypedData**: (`typedData`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
`any`
###### privateKey
`any`
###### Returns
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### SignTypedData()
> **SignTypedData**: (`deps`) => (`typedData`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
Factory: Sign EIP-712 typed data with ECDSA private key.
Produces a signature that can be verified against the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](../HashType.mdx#hashtype)
Hash typed data function
###### sign
(`hash`, `privateKey`) => [`Signature`](../../../crypto/EIP712.mdx#signature)
Secp256k1 sign function
###### Returns
Function that signs typed data
> (`typedData`, `privateKey`): [`Signature`](../../../crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### privateKey
`Uint8Array`
###### Returns
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key length is invalid or signing fails
###### Example
```javascript theme={null}
import { SignTypedData } from './crypto/EIP712/signTypedData.js';
import { HashTypedData } from './hashTypedData.js';
import { sign } from '../Secp256k1/sign.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const signTypedData = SignTypedData({ hashTypedData, sign });
const privateKey = new Uint8Array(32);
const signature = signTypedData(typedData, privateKey);
```
###### validate()
> **validate**: (`typedData`) => `void`
Validate typed data structure against EIP-712 specification.
Checks domain, types, primaryType, and message structure.
###### Parameters
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
Typed data to validate
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If structure is invalid or missing required fields
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
EIP712.validate(typedData); // Throws if invalid
```
###### verifyTypedData()
> **verifyTypedData**: (`signature`, `typedData`, `address`) => `boolean`
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### VerifyTypedData()
> **VerifyTypedData**: (`deps`) => (`signature`, `typedData`, `address`) => `boolean`
Factory: Verify EIP-712 typed data signature against expected signer address.
Uses constant-time comparison to prevent timing attacks.
###### Parameters
###### deps
Crypto dependencies
###### recoverAddress
(`signature`, `typedData`) => [`AddressType`](../../../primitives/Address.mdx#addresstype)
Recover address function
###### Returns
Function that verifies signature
> (`signature`, `typedData`, `address`): `boolean`
###### Parameters
###### signature
[`Signature`](../../../crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](../../../crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { VerifyTypedData } from './crypto/EIP712/verifyTypedData.js';
import { RecoverAddress } from './recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const verifyTypedData = VerifyTypedData({ recoverAddress });
const valid = verifyTypedData(signature, typedData, signerAddress);
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Eip712Wasm`](namespaces/Eip712Wasm/index.mdx) = `Eip712Wasm`
##### Ether
> **Ether**: `EtherConstructor`
##### Gwei
> **Gwei**: `GweiConstructor`
##### Hash
> **Hash**: `HashConstructor`
##### Hex
> **Hex**: *typeof* [`Hex`](../../index.mdx#hex)
##### Keccak256
> **Keccak256**: (`input`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) & `object` & `object`
Keccak256 with WASM acceleration
Falls back to JS implementation, but WASM methods available via `_wasm`
###### Type Declaration
###### contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`\<`ArrayBufferLike`>
Compute contract address from deployer and nonce
Uses CREATE formula: keccak256(rlp(\[sender, nonce]))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const address = Keccak256.contractAddress(sender, 0n);
```
###### create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`\<`ArrayBufferLike`>
Compute CREATE2 address
Uses CREATE2 formula: keccak256(0xff ++ sender ++ salt ++ keccak256(init\_code))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### salt
`Uint8Array`\<`ArrayBufferLike`>
32-byte salt
###### initCodeHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of initialization code
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Throws
If salt is not 32 bytes
###### Throws
If initCodeHash is not 32 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const salt = new Uint8Array(32);
const initCodeHash = new Uint8Array(32);
const address = Keccak256.create2Address(sender, salt, initCodeHash);
```
###### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number`
Digest size in bytes (32 bytes = 256 bits)
###### Since
0.0.0
###### from()
> **from**: (`input`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash input with Keccak-256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/keccak256](https://voltaire.tevm.sh/crypto/keccak256) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash1 = Keccak256Hash.from("0x1234"); // Hex
const hash2 = Keccak256Hash.from("hello"); // String
const hash3 = Keccak256Hash.from(uint8array); // Bytes
```
###### fromHex()
> **fromHex**: (`hex`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `hashHex`
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
###### fromString()
> **fromString**: (`str`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `hashString`
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
###### fromTopic()
> **fromTopic**: (`signature`) => [`Keccak256Hash`](../../index.mdx#keccak256hash) = `topic`
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
###### hash()
> **hash**: (`data`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash data with Keccak-256
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Data to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(data);
```
###### hashHex()
> **hashHex**: (`hex`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
###### hashMultiple()
> **hashMultiple**: (`chunks`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash multiple data chunks in sequence
Equivalent to hashing the concatenation of all chunks.
###### Parameters
###### chunks
readonly `Uint8Array`\<`ArrayBufferLike`>\[]
Array of data chunks to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(combined);
```
###### hashString()
> **hashString**: (`str`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
###### RATE
> **RATE**: `number`
Rate in bytes for Keccak256 (136 bytes = 1088 bits)
###### Since
0.0.0
###### selector()
> **selector**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Compute function selector (first 4 bytes of Keccak-256 hash)
Used for Ethereum function signatures.
###### Parameters
###### signature
`string`
Function signature string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte selector
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
```
###### STATE\_SIZE
> **STATE\_SIZE**: `number`
State size (25 u64 words = 1600 bits)
###### Since
0.0.0
###### topic()
> **topic**: (`signature`) => [`Keccak256Hash`](../../index.mdx#keccak256hash)
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](../../index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
###### Type Declaration
###### \_wasm
> **\_wasm**: `object` = `Keccak256Wasm`
###### \_wasm.contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`
Compute CREATE contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`
Contract address (20 bytes)
###### \_wasm.create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`
Compute CREATE2 contract address
###### Parameters
###### sender
`Uint8Array`
Sender address (20 bytes)
###### salt
`Uint8Array`
Salt (32 bytes)
###### initCodeHash
`Uint8Array`
Init code hash (32 bytes)
###### Returns
`Uint8Array`
Contract address (20 bytes)
###### \_wasm.DIGEST\_SIZE
> **DIGEST\_SIZE**: `number` = `32`
###### \_wasm.hash()
> **hash**: (`data`) => [`HashType`](../HashType.mdx#hashtype)
Hash bytes using Keccak256
###### Parameters
###### data
`Uint8Array`
Input bytes to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashHex()
> **hashHex**: (`hex`) => [`HashType`](../HashType.mdx#hashtype)
Hash a hex string
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashMultiple()
> **hashMultiple**: (`chunks`) => [`HashType`](../HashType.mdx#hashtype)
Hash multiple byte arrays in sequence
###### Parameters
###### chunks
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of byte arrays to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.hashString()
> **hashString**: (`str`) => [`HashType`](../HashType.mdx#hashtype)
Hash a UTF-8 string
###### Parameters
###### str
`string`
String to hash
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte Keccak256 hash
###### \_wasm.init()
> **init**: () => `Promise`\<`void`>
Initialize WASM module (must be called before using any functions)
###### Returns
`Promise`\<`void`>
###### \_wasm.isReady()
> **isReady**: () => `boolean`
Check if WASM is initialized
###### Returns
`boolean`
###### \_wasm.RATE
> **RATE**: `number` = `136`
###### \_wasm.selector()
> **selector**: (`signature`) => `Uint8Array`
Compute function selector (first 4 bytes of hash)
###### Parameters
###### signature
`string`
Function signature string (e.g., "transfer(address,uint256)")
###### Returns
`Uint8Array`
4-byte function selector
###### \_wasm.STATE\_SIZE
> **STATE\_SIZE**: `number` = `25`
###### \_wasm.topic()
> **topic**: (`signature`) => [`HashType`](../HashType.mdx#hashtype)
Compute event topic (full 32-byte hash)
###### Parameters
###### signature
`string`
Event signature string (e.g., "Transfer(address,address,uint256)")
###### Returns
[`HashType`](../HashType.mdx#hashtype)
32-byte event topic as HashType
##### KZG
> **KZG**: *typeof* [`KZG`](../../index.mdx#kzg)
##### ModExp
> **ModExp**: (`base`, `exp`, `modulus`) => `bigint` & `object`
###### Type Declaration
###### calculateGas()
> **calculateGas**: (`baseLen`, `expLen`, `modLen`, `expHead`) => `bigint`
Calculate gas cost for MODEXP operation per EIP-2565
Gas formula: max(200, floor(mult\_complexity \* iteration\_count / 3))
###### Parameters
###### baseLen
`bigint`
Length of base in bytes
###### expLen
`bigint`
Length of exponent in bytes
###### modLen
`bigint`
Length of modulus in bytes
###### expHead
`bigint`
First 32 bytes of exponent as BigInt (for leading zeros calc)
###### Returns
`bigint`
Gas cost
###### See
[https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Calculate gas for 2^3 mod 5
const gas = ModExp.calculateGas(1n, 1n, 1n, 3n);
console.log(gas); // 200n (minimum)
```
###### modexp()
> **modexp**: (`base`, `exp`, `modulus`) => `bigint`
Modular exponentiation: base^exp mod modulus
Computes arbitrary-precision modular exponentiation using native BigInt.
Used by MODEXP precompile (0x05) per EIP-198.
WARNING: This implementation is for general use. For cryptographic
applications, consider timing attack resistance.
###### Parameters
###### base
`bigint`
Base value
###### exp
`bigint`
Exponent value
###### modulus
`bigint`
Modulus value (must be > 0)
###### Returns
`bigint`
Result of base^exp mod modulus
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Compute 2^10 mod 1000 = 24
const result = ModExp.modexp(2n, 10n, 1000n);
console.log(result); // 24n
// RSA verification: signature^e mod n
const verified = ModExp.modexp(signature, e, n);
```
###### modexpBytes()
> **modexpBytes**: (`baseBytes`, `expBytes`, `modBytes`) => `Uint8Array`\<`ArrayBufferLike`>
Modular exponentiation with byte array inputs/outputs
Computes base^exp mod modulus where inputs are big-endian byte arrays.
Output is padded to modulus length per EIP-198 spec.
###### Parameters
###### baseBytes
`Uint8Array`\<`ArrayBufferLike`>
Base as big-endian bytes
###### expBytes
`Uint8Array`\<`ArrayBufferLike`>
Exponent as big-endian bytes
###### modBytes
`Uint8Array`\<`ArrayBufferLike`>
Modulus as big-endian bytes
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Result as big-endian bytes, padded to modulus length
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
const base = new Uint8Array([0x02]); // 2
const exp = new Uint8Array([0x03]); // 3
const mod = new Uint8Array([0x05]); // 5
const result = ModExp.modexpBytes(base, exp, mod);
console.log(result); // Uint8Array([0x03]) = 3
```
##### Opcode
> **Opcode**: *typeof* [`Opcode`](../../index.mdx#opcode)
##### P256
> **P256**: [`P256Constructor`](../../../crypto/P256.mdx#p256constructor) & `object`
P256 with WASM acceleration
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`P256Wasm`](namespaces/P256Wasm.mdx) = `P256Wasm`
##### Ripemd160
> **Ripemd160**: (`input`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) & `object` & `object`
Ripemd160 with WASM acceleration
###### Type Declaration
###### from()
> **from**: (`input`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Hash input with RIPEMD160 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto/ripemd160](https://voltaire.tevm.sh/crypto/ripemd160) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash1 = Ripemd160Hash.from("hello"); // String
const hash2 = Ripemd160Hash.from(uint8array); // Bytes
```
###### fromHex()
> **fromHex**: (`hex`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) = `hashHex`
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
###### fromString()
> **fromString**: (`str`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash) = `hashString`
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
###### hash()
> **hash**: (`data`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash (20 bytes)
###### Parameters
###### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hash(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 20
```
###### hashHex()
> **hashHex**: (`hex`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
###### hashString()
> **hashString**: (`str`) => [`Ripemd160Hash`](../../index.mdx#ripemd160hash)
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](../../index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
###### HEX\_SIZE
> **HEX\_SIZE**: `number`
Size of RIPEMD160 hash in hex characters (without 0x prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { HEX_SIZE } from './crypto/Ripemd160/index.js';
console.log(HEX_SIZE); // 40
```
###### SIZE
> **SIZE**: `number`
Size of RIPEMD160 hash in bytes (160 bits)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIZE } from './crypto/Ripemd160/index.js';
console.log(SIZE); // 20
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Ripemd160Wasm`](namespaces/Ripemd160Wasm.mdx) = `Ripemd160Wasm`
##### Rlp
> **Rlp**: *typeof* [`Rlp`](../../../primitives/Rlp.mdx#rlp)
##### Secp256k1
> **Secp256k1**: `object` & `object`
Secp256k1 with WASM acceleration
###### Type Declaration
###### addPoints()
> **addPoints**: (`pubKey1`, `pubKey2`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Add two secp256k1 public key points
Performs elliptic curve point addition: P1 + P2.
Used in ERC-5564 stealth address generation.
###### Parameters
###### pubKey1
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
First 64-byte uncompressed public key
###### pubKey2
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Second 64-byte uncompressed public key
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If either public key is invalid
###### Throws
If point addition fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const pubKey1 = Secp256k1.derivePublicKey(privateKey1);
const pubKey2 = Secp256k1.derivePublicKey(privateKey2);
const sum = Secp256k1.addPoints(pubKey1, pubKey2);
console.log(sum.length); // 64
```
###### createKeyPair()
> **createKeyPair**: () => `object`
Generate a new secp256k1 key pair
###### Returns
`object`
Key pair with 32-byte private key and 65-byte uncompressed public key
###### privateKey
> **privateKey**: `Uint8Array`
###### publicKey
> **publicKey**: `Uint8Array`
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const { privateKey, publicKey } = Secp256k1.createKeyPair();
```
###### CURVE\_ORDER
> **CURVE\_ORDER**: `bigint`
secp256k1 curve order (number of points on the curve)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { CURVE_ORDER } from './crypto/Secp256k1/index.js';
console.log(CURVE_ORDER); // 0xffffffffffff...
```
###### derivePublicKey()
> **derivePublicKey**: (`privateKey`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Derive public key from private key
Computes the public key point from a private key using scalar
multiplication on the secp256k1 curve.
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from(new Uint8Array(32));
const publicKey = Secp256k1.derivePublicKey(privateKey);
console.log(publicKey.length); // 64
```
###### ecdh()
> **ecdh**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`>
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
###### getSharedSecret()
> **getSharedSecret**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`> = `ecdh`
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
###### isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Validate private key
Checks that the private key is within valid range \[1, n-1] where n
is the curve order.
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
`boolean`
true if private key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const privateKey = new Uint8Array(32);
const valid = Secp256k1.isValidPrivateKey(privateKey);
```
###### isValidPublicKey()
> **isValidPublicKey**: (`publicKey`) => `publicKey is Secp256k1PublicKeyType`
Validate public key
Checks that the public key is a valid point on the secp256k1 curve.
###### Parameters
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
###### Returns
`publicKey is Secp256k1PublicKeyType`
true if public key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const publicKey = new Uint8Array(64);
if (Secp256k1.isValidPublicKey(publicKey)) {
const branded = publicKey; // now Secp256k1PublicKeyType
}
```
###### isValidSignature()
> **isValidSignature**: (`signature`) => `boolean`
Validate signature components
Checks that r and s are within valid range \[1, n-1] where n is the
curve order. Also enforces low-s values to prevent malleability.
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature to validate (r and s are HashType)
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature = { r: Hash.from(new Uint8Array(32)), s: Hash.from(new Uint8Array(32)), v: 27 };
const valid = Secp256k1.isValidSignature(signature);
```
###### PRIVATE\_KEY\_SIZE
> **PRIVATE\_KEY\_SIZE**: `number`
Private key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PRIVATE_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PRIVATE_KEY_SIZE); // 32
```
###### PrivateKey
> **PrivateKey**: `__module` = `PrivateKeyMethods`
###### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `number`
Uncompressed public key size in bytes (64 bytes, no prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PUBLIC_KEY_SIZE); // 64
```
###### PublicKey
> **PublicKey**: `__module` = `PublicKeyMethods`
###### randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a cryptographically secure random secp256k1 private key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const privateKey = Secp256k1.randomPrivateKey();
const publicKey = Secp256k1.derivePublicKey(privateKey);
```
###### recoverPublicKey()
> **recoverPublicKey**: (`signature`, `messageHash`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and message hash
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash that was signed
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const messageHash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
###### recoverPublicKeyFromHash()
> **recoverPublicKeyFromHash**: (`signature`, `hash`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use recoverPublicKey() instead.
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Recover public key from a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKeyFromHash(
{ r: rBytes, s: sBytes, v: 27 },
hash
);
// For comparison, recoverPublicKey() hashes internally (message-level API)
const recovered2 = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
###### scalarMultiply()
> **scalarMultiply**: (`scalar`) => [`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Multiply generator point by scalar
Performs scalar multiplication: scalar \* G (generator point).
Used in ERC-5564 stealth address generation.
###### Parameters
###### scalar
`Uint8Array`\<`ArrayBufferLike`>
32-byte scalar value
###### Returns
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const scalar = new Uint8Array(32);
scalar[31] = 5; // scalar = 5
const result = Secp256k1.scalarMultiply(scalar);
console.log(result.length); // 64
```
###### sign()
> **sign**: (`messageHash`, `privateKey`) => [`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash to sign
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const messageHash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.sign(messageHash, privateKey);
```
###### Signature
> **Signature**: `__module` = `SignatureMethods`
###### SIGNATURE\_COMPONENT\_SIZE
> **SIGNATURE\_COMPONENT\_SIZE**: `number`
Signature component size in bytes (r and s are each 32 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIGNATURE_COMPONENT_SIZE } from './crypto/Secp256k1/index.js';
console.log(SIGNATURE_COMPONENT_SIZE); // 32
```
###### signHash()
> **signHash**: (`hash`, `privateKey`) => [`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a pre-hashed message with a private key
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use sign() instead.
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash to sign (pre-hashed message)
###### privateKey
[`PrivateKeyType`](../../../primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails or hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
// Sign a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.signHash(hash, privateKey);
// For comparison, sign() hashes internally (message-level API)
const signature2 = Secp256k1.sign(Hash.keccak256String('Hello!'), privateKey);
```
###### verify()
> **verify**: (`signature`, `messageHash`, `publicKey`) => `boolean`
Verify an ECDSA signature
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### messageHash
[`HashType`](../HashType.mdx#hashtype)
32-byte message hash that was signed
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature v is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
###### verifyHash()
> **verifyHash**: (`signature`, `hash`, `publicKey`) => `boolean`
Verify an ECDSA signature against a pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use verify() instead.
###### Parameters
###### signature
[`Secp256k1SignatureType`](../../../crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### hash
[`HashType`](../HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### publicKey
[`Secp256k1PublicKeyType`](../../../crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Verify a signature against a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const valid = Secp256k1.verifyHash({ r, s, v: 27 }, hash, publicKey);
// For comparison, verify() hashes internally (message-level API)
const valid2 = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Secp256k1Wasm`](namespaces/Secp256k1Wasm/index.mdx) = `Secp256k1Wasm`
##### SHA256
> **SHA256**: (`input`) => [`SHA256Hash`](../../index.mdx#sha256hash) & `object` & `object`
SHA256 with WASM acceleration
###### Type Declaration
###### BLOCK\_SIZE
> **BLOCK\_SIZE**: `number`
SHA256 block size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { BLOCK_SIZE } from './crypto/SHA256/index.js';
console.log(BLOCK_SIZE); // 64
```
###### create()
> **create**: () => `object`
Incremental hasher for streaming data
###### Returns
`object`
Hasher instance
###### digest()
> **digest**: () => `Uint8Array`
###### Returns
`Uint8Array`
###### update()
> **update**: (`data`) => `void`
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hasher = SHA256.create();
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new Uint8Array([4, 5, 6]));
const hash = hasher.digest();
```
###### from()
> **from**: (`input`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Hash input with SHA256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/sha256](https://voltaire.tevm.sh/crypto/sha256) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash1 = SHA256Hash.from("0x1234"); // Hex
const hash2 = SHA256Hash.from("hello"); // String
const hash3 = SHA256Hash.from(uint8array); // Bytes
```
###### fromHex()
> **fromHex**: (`hex`) => [`SHA256Hash`](../../index.mdx#sha256hash) = `hashHex`
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
###### fromString()
> **fromString**: (`str`) => [`SHA256Hash`](../../index.mdx#sha256hash) = `hashString`
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
###### hash()
> **hash**: (`data`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of input data
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Input data as Uint8Array
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash = SHA256Hash.from(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 32
```
###### hashHex()
> **hashHex**: (`hex`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
###### hashString()
> **hashString**: (`str`) => [`SHA256Hash`](../../index.mdx#sha256hash)
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](../../index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
###### OUTPUT\_SIZE
> **OUTPUT\_SIZE**: `number`
SHA256 output size in bytes (256 bits / 8)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { OUTPUT_SIZE } from './crypto/SHA256/index.js';
console.log(OUTPUT_SIZE); // 32
```
###### toHex()
> **toHex**: (`hash`) => `string`
Convert hash output to hex string
###### Parameters
###### hash
`Uint8Array`\<`ArrayBufferLike`>
Hash bytes
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hash(new Uint8Array([1, 2, 3]));
const hexStr = SHA256.toHex(hash);
console.log(hexStr); // "0x..."
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`Sha256Wasm`](namespaces/Sha256Wasm.mdx) = `Sha256Wasm`
##### Siwe
> **Siwe**: *typeof* [`Siwe`](../../../primitives/Siwe.mdx#siwe)
##### StorageKey
> **StorageKey**: `object`
###### StorageKey.create()
> **create**: (`address`, `slot`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### Parameters
###### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### StorageKey.equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### b
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`boolean`
###### StorageKey.from()
> **from**: (`value`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### Parameters
###### value
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype)
###### StorageKey.fromString()
> **fromString**: (`str`) => [`StorageKeyType`](../../../primitives/State.mdx#storagekeytype) | `undefined`
###### Parameters
###### str
`string`
###### Returns
[`StorageKeyType`](../../../primitives/State.mdx#storagekeytype) | `undefined`
###### StorageKey.hashCode()
> **hashCode**: (`key`) => `number`
###### Parameters
###### key
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`number`
###### StorageKey.is()
> **is**: (`value`) => `value is StorageKeyType`
###### Parameters
###### value
`unknown`
###### Returns
`value is StorageKeyType`
###### StorageKey.toString()
> **toString**: (`key`) => `string`
###### Parameters
###### key
[`StorageKeyLike`](../../../primitives/State.mdx#storagekeylike)
###### Returns
`string`
##### Uint
> **Uint**: *typeof* [`Uint`](../../index.mdx#uint)
##### Wei
> **Wei**: `WeiConstructor`
##### X25519
> **X25519**: `object` & `object`
X25519 with WASM acceleration
###### Type Declaration
###### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => [`PublicKey`](../../../crypto/X25519.mdx#publickey)
Derive public key from secret key
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
32-byte secret key
###### Returns
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
32-byte public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const publicKey = X25519.derivePublicKey(secretKey);
console.log(publicKey.length); // 32
```
###### generateKeypair()
> **generateKeypair**: () => `object`
Generate random keypair
Uses crypto.getRandomValues for secure random generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](../../../crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const keypair = X25519.generateKeypair();
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
###### generateSecretKey()
> **generateSecretKey**: () => [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Generate random secret key
Uses crypto.getRandomValues for secure random generation
###### Returns
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
32-byte random secret key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = X25519.generateSecretKey();
const publicKey = X25519.derivePublicKey(secretKey);
console.log(secretKey.length); // 32
```
###### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate X25519 keypair from seed
###### Parameters
###### seed
`Uint8Array`\<`ArrayBufferLike`>
32-byte seed for deterministic generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](../../../crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = X25519.keypairFromSeed(seed);
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
###### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Public key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/X25519/index.js';
console.log(PUBLIC_KEY_SIZE); // 32
```
###### scalarmult()
> **scalarmult**: (`secretKey`, `publicKey`) => [`SharedSecret`](../../../crypto/X25519.mdx#sharedsecret)
Perform X25519 scalar multiplication (ECDH)
Computes shared secret from your secret key and their public key.
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Your 32-byte secret key
###### publicKey
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
Their 32-byte public key
###### Returns
[`SharedSecret`](../../../crypto/X25519.mdx#sharedsecret)
32-byte shared secret
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Throws
If public key is invalid
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const mySecret = crypto.getRandomValues(new Uint8Array(32));
const theirPublic = X25519.derivePublicKey(theirSecret);
const shared = X25519.scalarmult(mySecret, theirPublic);
console.log(shared.length); // 32
```
###### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Secret key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/X25519/index.js';
console.log(SECRET_KEY_SIZE); // 32
```
###### SHARED\_SECRET\_SIZE
> **SHARED\_SECRET\_SIZE**: `32`
Shared secret size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHARED_SECRET_SIZE } from './crypto/X25519/index.js';
console.log(SHARED_SECRET_SIZE); // 32
```
###### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate a public key
Checks if the public key has correct length
###### Parameters
###### publicKey
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
Public key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const publicKey = new Uint8Array(32);
const valid = X25519.validatePublicKey(publicKey);
```
###### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate a secret key
Checks if the secret key has correct length and can derive a public key
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Secret key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = new Uint8Array(32);
const valid = X25519.validateSecretKey(secretKey);
```
###### Type Declaration
###### \_wasm
> **\_wasm**: *typeof* [`X25519Wasm`](namespaces/X25519Wasm.mdx) = `X25519Wasm`
***
### Wei
> `const` **Wei**: `WeiConstructor` = `WeiJS`
Defined in: [src/wasm/index.ts:245](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L245)
***
### X25519
> `const` **X25519**: `object` & `object`
Defined in: [src/wasm/index.ts:207](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/wasm/index.ts#L207)
X25519 with WASM acceleration
#### Type Declaration
##### derivePublicKey()
> **derivePublicKey**: (`secretKey`) => [`PublicKey`](../../../crypto/X25519.mdx#publickey)
Derive public key from secret key
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
32-byte secret key
###### Returns
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
32-byte public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const publicKey = X25519.derivePublicKey(secretKey);
console.log(publicKey.length); // 32
```
##### generateKeypair()
> **generateKeypair**: () => `object`
Generate random keypair
Uses crypto.getRandomValues for secure random generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](../../../crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const keypair = X25519.generateKeypair();
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
##### generateSecretKey()
> **generateSecretKey**: () => [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Generate random secret key
Uses crypto.getRandomValues for secure random generation
###### Returns
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
32-byte random secret key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = X25519.generateSecretKey();
const publicKey = X25519.derivePublicKey(secretKey);
console.log(secretKey.length); // 32
```
##### keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate X25519 keypair from seed
###### Parameters
###### seed
`Uint8Array`\<`ArrayBufferLike`>
32-byte seed for deterministic generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](../../../crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](../../../crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = X25519.keypairFromSeed(seed);
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
##### PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Public key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/X25519/index.js';
console.log(PUBLIC_KEY_SIZE); // 32
```
##### scalarmult()
> **scalarmult**: (`secretKey`, `publicKey`) => [`SharedSecret`](../../../crypto/X25519.mdx#sharedsecret)
Perform X25519 scalar multiplication (ECDH)
Computes shared secret from your secret key and their public key.
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Your 32-byte secret key
###### publicKey
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
Their 32-byte public key
###### Returns
[`SharedSecret`](../../../crypto/X25519.mdx#sharedsecret)
32-byte shared secret
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Throws
If public key is invalid
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const mySecret = crypto.getRandomValues(new Uint8Array(32));
const theirPublic = X25519.derivePublicKey(theirSecret);
const shared = X25519.scalarmult(mySecret, theirPublic);
console.log(shared.length); // 32
```
##### SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Secret key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/X25519/index.js';
console.log(SECRET_KEY_SIZE); // 32
```
##### SHARED\_SECRET\_SIZE
> **SHARED\_SECRET\_SIZE**: `32`
Shared secret size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHARED_SECRET_SIZE } from './crypto/X25519/index.js';
console.log(SHARED_SECRET_SIZE); // 32
```
##### validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate a public key
Checks if the public key has correct length
###### Parameters
###### publicKey
[`PublicKey`](../../../crypto/X25519.mdx#publickey)
Public key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const publicKey = new Uint8Array(32);
const valid = X25519.validatePublicKey(publicKey);
```
##### validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate a secret key
Checks if the secret key has correct length and can derive a public key
###### Parameters
###### secretKey
[`SecretKey`](../../../crypto/X25519.mdx#secretkey)
Secret key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = new Uint8Array(32);
const valid = X25519.validateSecretKey(secretKey);
```
#### Type Declaration
##### \_wasm
> **\_wasm**: *typeof* [`X25519Wasm`](namespaces/X25519Wasm.mdx) = `X25519Wasm`
## Functions
### accessListGasCost()
> **accessListGasCost**(`accessList`): `bigint`
Defined in: [src/primitives/AccessList/AccessList.wasm.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessList.wasm.ts#L16)
Calculate total gas cost for access list
#### Parameters
##### accessList
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
Access list to calculate cost for
#### Returns
`bigint`
Gas cost as bigint
***
### accessListGasSavings()
> **accessListGasSavings**(`accessList`): `bigint`
Defined in: [src/primitives/AccessList/AccessList.wasm.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessList.wasm.ts#L26)
Calculate gas savings from using access list
#### Parameters
##### accessList
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
Access list to calculate savings for
#### Returns
`bigint`
Gas savings as bigint
***
### accessListIncludesAddress()
> **accessListIncludesAddress**(`accessList`, `address`): `boolean`
Defined in: [src/primitives/AccessList/AccessList.wasm.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessList.wasm.ts#L37)
Check if address is in access list
#### Parameters
##### accessList
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
Access list to check
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to look for
#### Returns
`boolean`
True if address is in list
***
### accessListIncludesStorageKey()
> **accessListIncludesStorageKey**(`accessList`, `address`, `storageKey`): `boolean`
Defined in: [src/primitives/AccessList/AccessList.wasm.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessList.wasm.ts#L52)
Check if storage key is in access list for address
#### Parameters
##### accessList
[`BrandedAccessList`](../../../primitives/AccessList.mdx#brandedaccesslist)
Access list to check
##### address
[`AddressType`](../../../primitives/Address.mdx#addresstype)
Address to look for
##### storageKey
[`HashType`](../HashType.mdx#hashtype)
Storage key to look for
#### Returns
`boolean`
True if storage key is in list for address
***
### analyzeJumpDestinations()
> **analyzeJumpDestinations**(`bytecode`): `number`\[]
Defined in: [src/primitives/Bytecode/Bytecode.wasm.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/Bytecode.wasm.ts#L32)
Analyze bytecode to find all valid JUMPDEST locations (WASM accelerated)
#### Parameters
##### bytecode
`BrandedBytecode`
EVM bytecode
#### Returns
`number`\[]
Array of valid JUMPDEST positions
#### Example
```typescript theme={null}
const code = Bytecode("0x6001...");
const jumpdests = Bytecode.analyzeJumpDestinations(code);
```
***
### blake2b()
> **blake2b**(`data`): `Uint8Array`
Defined in: [src/primitives/Hash/Hash.wasm.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.wasm.ts#L41)
Compute BLAKE2b hash
#### Parameters
##### data
Input data (string or Uint8Array)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`
64-byte BLAKE2b hash
***
### blobCalculateExcessGas()
> **blobCalculateExcessGas**(`parentExcess`, `parentUsed`): `bigint`
Defined in: [src/primitives/Blob/Blob.wasm.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L114)
Calculate excess blob gas for next block using WASM
#### Parameters
##### parentExcess
`bigint`
Parent block excess blob gas
##### parentUsed
`bigint`
Parent block blob gas used
#### Returns
`bigint`
Excess blob gas for next block
#### Example
```typescript theme={null}
const excess = calculateExcessGasWasm(0n, 524288n); // Excess from 4 blobs
```
***
### blobCalculateGas()
> **blobCalculateGas**(`blobCount`): `bigint`
Defined in: [src/primitives/Blob/Blob.wasm.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L71)
Calculate blob gas for number of blobs using WASM
#### Parameters
##### blobCount
`number`
Number of blobs
#### Returns
`bigint`
Total blob gas
#### Example
```typescript theme={null}
const gas = calculateGasWasm(3); // 393216n
```
***
### blobCalculateGasPrice()
> **blobCalculateGasPrice**(`excessBlobGas`): `bigint`
Defined in: [src/primitives/Blob/Blob.wasm.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L99)
Calculate blob gas price from excess blob gas using WASM
#### Parameters
##### excessBlobGas
`bigint`
Excess blob gas
#### Returns
`bigint`
Blob gas price
#### Example
```typescript theme={null}
const price = calculateGasPriceWasm(0n); // 1n (MIN_BLOB_BASE_FEE)
```
***
### blobEstimateCount()
> **blobEstimateCount**(`dataSize`): `number`
Defined in: [src/primitives/Blob/Blob.wasm.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L85)
Estimate number of blobs needed for data using WASM
#### Parameters
##### dataSize
`number`
Size of data in bytes
#### Returns
`number`
Number of blobs required
#### Example
```typescript theme={null}
const blobCount = estimateBlobCountWasm(200000); // 2
```
***
### blobFromData()
> **blobFromData**(`data`): `Uint8Array`
Defined in: [src/primitives/Blob/Blob.wasm.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L26)
Encode data as blob using WASM (with length prefix)
#### Parameters
##### data
`Uint8Array`
Data to encode (max \~131KB)
#### Returns
`Uint8Array`
Blob containing encoded data
#### Example
```typescript theme={null}
const data = new TextEncoder().encode("Hello, blob!");
const blob = fromDataWasm(data);
```
***
### blobIsValid()
> **blobIsValid**(`blobLen`): `boolean`
Defined in: [src/primitives/Blob/Blob.wasm.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L57)
Validate blob size using WASM
#### Parameters
##### blobLen
`number`
Length to validate
#### Returns
`boolean`
true if blob is exactly 131072 bytes
#### Example
```typescript theme={null}
if (!isValidWasm(blob.length)) {
throw new Error("Invalid blob");
}
```
***
### blobToData()
> **blobToData**(`blob`): `Uint8Array`
Defined in: [src/primitives/Blob/Blob.wasm.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/Blob.wasm.ts#L41)
Extract data from blob using WASM
#### Parameters
##### blob
`Uint8Array`
Blob data (131072 bytes)
#### Returns
`Uint8Array`
Original data
#### Example
```typescript theme={null}
const data = toDataWasm(blob);
const text = new TextDecoder().decode(data);
```
***
### bytesToHex()
> **bytesToHex**(`data`): `string`
Defined in: [src/primitives/Hex/Hex.wasm.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/Hex.wasm.ts#L22)
Convert bytes to hex string
#### Parameters
##### data
`Uint8Array`
Raw bytes
#### Returns
`string`
Hex string with 0x prefix
***
### compressPublicKey()
> **compressPublicKey**(`uncompressed`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/wallet.wasm.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/wallet.wasm.js#L21)
Compress an uncompressed public key (64 bytes) to compressed form (33 bytes)
#### Parameters
##### uncompressed
`Uint8Array`\<`ArrayBufferLike`>
Uncompressed public key (64 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed public key (33 bytes)
***
### detectTransactionType()
> **detectTransactionType**(`data`): [`TransactionType`](#transactiontype)
Defined in: [src/primitives/Transaction/Transaction.wasm.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.wasm.ts#L29)
Detect transaction type from RLP-encoded data
#### Parameters
##### data
`Uint8Array`
RLP-encoded transaction data
#### Returns
[`TransactionType`](#transactiontype)
Transaction type (0-4)
***
### eip191HashMessage()
> **eip191HashMessage**(`message`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/crypto/keccak.wasm.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/keccak.wasm.js#L29)
#### Parameters
##### message
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
***
### generatePrivateKey()
> **generatePrivateKey**(): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/wallet.wasm.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/wallet.wasm.js#L12)
Generate a random private key (32 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Random private key
***
### hexToBytes()
> **hexToBytes**(`hex`): `Uint8Array`
Defined in: [src/primitives/Hex/Hex.wasm.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/Hex.wasm.ts#L13)
Convert hex string to bytes
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
`Uint8Array`
Raw bytes
***
### isBytecodeBoundary()
> **isBytecodeBoundary**(`bytecode`, `position`): `boolean`
Defined in: [src/primitives/Bytecode/Bytecode.wasm.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/Bytecode.wasm.ts#L52)
Check if a position is at a bytecode boundary (WASM accelerated)
Position must not be inside PUSH data
#### Parameters
##### bytecode
`BrandedBytecode`
EVM bytecode
##### position
`number`
Position to check
#### Returns
`boolean`
True if position is a valid instruction boundary
#### Example
```typescript theme={null}
const code = Bytecode("0x6001...");
if (Bytecode.isBytecodeBoundary(code, 0)) {
console.log("Valid boundary");
}
```
***
### isValidJumpDest()
> **isValidJumpDest**(`bytecode`, `position`): `boolean`
Defined in: [src/primitives/Bytecode/Bytecode.wasm.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/Bytecode.wasm.ts#L74)
Check if a position contains a valid JUMPDEST (WASM accelerated)
#### Parameters
##### bytecode
`BrandedBytecode`
EVM bytecode
##### position
`number`
Position to check
#### Returns
`boolean`
True if position contains JUMPDEST opcode
#### Example
```typescript theme={null}
const code = Bytecode("0x5b..."); // 0x5b is JUMPDEST
if (Bytecode.isValidJumpDest(code, 0)) {
console.log("Valid JUMPDEST");
}
```
***
### keccak256()
> **keccak256**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
Defined in: [src/crypto/keccak.wasm.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/keccak.wasm.js#L17)
#### Parameters
##### data
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Promise`\<`Uint8Array`\<`ArrayBufferLike`>>
***
### ripemd160()
> **ripemd160**(`data`): `Uint8Array`
Defined in: [src/primitives/Hash/Hash.wasm.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.wasm.ts#L27)
Compute RIPEMD-160 hash
#### Parameters
##### data
Input data (string or Uint8Array)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`
20-byte RIPEMD-160 hash
***
### rlpEncodeBytes()
> **rlpEncodeBytes**(`data`): `Uint8Array`
Defined in: [src/primitives/Rlp/Rlp.wasm.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/Rlp.wasm.ts#L13)
Encode bytes as RLP
#### Parameters
##### data
`Uint8Array`
Data to encode
#### Returns
`Uint8Array`
RLP-encoded bytes
***
### rlpEncodeUint()
> **rlpEncodeUint**(`value`): `Uint8Array`
Defined in: [src/primitives/Rlp/Rlp.wasm.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/Rlp.wasm.ts#L23)
Encode unsigned integer (u256) as RLP
#### Parameters
##### value
`Uint8Array`
32-byte big-endian u256 value
#### Returns
`Uint8Array`
RLP-encoded bytes
***
### rlpEncodeUintFromBigInt()
> **rlpEncodeUintFromBigInt**(`value`): `Uint8Array`
Defined in: [src/primitives/Rlp/Rlp.wasm.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/Rlp.wasm.ts#L36)
Encode unsigned integer from bigint
#### Parameters
##### value
`bigint`
BigInt value
#### Returns
`Uint8Array`
RLP-encoded bytes
***
### rlpFromHex()
> **rlpFromHex**(`hex`): `Uint8Array`
Defined in: [src/primitives/Rlp/Rlp.wasm.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/Rlp.wasm.ts#L61)
Convert hex string to RLP bytes
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
`Uint8Array`
RLP bytes
***
### rlpToHex()
> **rlpToHex**(`rlpData`): `string`
Defined in: [src/primitives/Rlp/Rlp.wasm.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/Rlp.wasm.ts#L51)
Convert RLP bytes to hex string
#### Parameters
##### rlpData
`Uint8Array`
RLP-encoded data
#### Returns
`string`
Hex string with 0x prefix
***
### secp256k1PubkeyFromPrivate()
> **secp256k1PubkeyFromPrivate**(`privateKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L51)
Derive public key from private key
#### Parameters
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key (32 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Public key (64 bytes)
***
### secp256k1RecoverAddress()
> **secp256k1RecoverAddress**(`messageHash`, `signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L40)
Recover Ethereum address from signature
#### Parameters
##### messageHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of signed message
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature (r+s+v)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Recovered address (20 bytes)
***
### secp256k1RecoverPubkey()
> **secp256k1RecoverPubkey**(`messageHash`, `signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L26)
Recover public key from signature
#### Parameters
##### messageHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of signed message
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature (r+s+v)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Recovered public key (64 bytes)
***
### secp256k1ValidateSignature()
> **secp256k1ValidateSignature**(`signature`, `messageHash`, `publicKey`): `boolean`
Defined in: [src/crypto/signature.wasm.js:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L62)
Validate signature against public key
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature
##### messageHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of signed message
##### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Public key (64 bytes)
#### Returns
`boolean`
True if signature is valid
***
### sha256()
> **sha256**(`data`): `Uint8Array`
Defined in: [src/primitives/Hash/Hash.wasm.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.wasm.ts#L13)
Compute SHA-256 hash
#### Parameters
##### data
Input data (string or Uint8Array)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`
32-byte SHA-256 hash
***
### signatureIsCanonical()
> **signatureIsCanonical**(`signature`): `boolean`
Defined in: [src/crypto/signature.wasm.js:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L96)
Check if signature is in canonical form
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature
#### Returns
`boolean`
True if signature is canonical
***
### signatureNormalize()
> **signatureNormalize**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L75)
Normalize signature to low-s form
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Normalized signature
***
### signatureParse()
> **signatureParse**(`signature`): [`ParsedSignature`](#parsedsignature-1)
Defined in: [src/crypto/signature.wasm.js:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L106)
Parse signature from bytes
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature (r+s+v)
#### Returns
[`ParsedSignature`](#parsedsignature-1)
Parsed signature object
***
### signatureSerialize()
> **signatureSerialize**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/crypto/signature.wasm.js:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/signature.wasm.js#L115)
Serialize signature to bytes
#### Parameters
##### signature
[`ParsedSignature`](#parsedsignature-1)
Parsed signature object
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
65-byte signature (r+s+v)
***
### solidityKeccak256()
> **solidityKeccak256**(`packedData`): `Uint8Array`
Defined in: [src/primitives/Hash/Hash.wasm.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.wasm.ts#L55)
Compute Solidity-style Keccak-256 hash of tightly packed data
#### Parameters
##### packedData
`Uint8Array`
Pre-packed data bytes
#### Returns
`Uint8Array`
32-byte Keccak-256 hash
***
### soliditySha256()
> **soliditySha256**(`packedData`): `Uint8Array`
Defined in: [src/primitives/Hash/Hash.wasm.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/Hash.wasm.ts#L66)
Compute Solidity-style SHA-256 hash of tightly packed data
#### Parameters
##### packedData
`Uint8Array`
Pre-packed data bytes
#### Returns
`Uint8Array`
32-byte SHA-256 hash
***
### u256FromBigInt()
> **u256FromBigInt**(`value`): `Uint8Array`
Defined in: [src/primitives/Uint/Uint256.wasm.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256.wasm.ts#L46)
Convert bigint to U256 bytes
#### Parameters
##### value
`bigint`
BigInt value
#### Returns
`Uint8Array`
32-byte U256 value
#### Throws
If value is negative
#### Throws
If value exceeds maximum
***
### u256FromHex()
> **u256FromHex**(`hex`): `Uint8Array`
Defined in: [src/primitives/Uint/Uint256.wasm.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256.wasm.ts#L18)
Convert hex string to U256 (32-byte big-endian)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
`Uint8Array`
32-byte U256 value
***
### u256ToBigInt()
> **u256ToBigInt**(`value`): `bigint`
Defined in: [src/primitives/Uint/Uint256.wasm.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256.wasm.ts#L70)
Convert U256 bytes to bigint
#### Parameters
##### value
`Uint8Array`
32-byte U256 value
#### Returns
`bigint`
BigInt value
#### Throws
If value is not 32 bytes
***
### u256ToHex()
> **u256ToHex**(`value`): `string`
Defined in: [src/primitives/Uint/Uint256.wasm.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256.wasm.ts#L28)
Convert U256 to hex string
#### Parameters
##### value
`Uint8Array`
32-byte U256 value (big-endian)
#### Returns
`string`
Hex string with 0x prefix
#### Throws
If value is not 32 bytes
***
### validateBytecode()
> **validateBytecode**(`bytecode`): `void`
Defined in: [src/primitives/Bytecode/Bytecode.wasm.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/Bytecode.wasm.ts#L94)
Validate bytecode structure (WASM accelerated)
Checks that PUSH instructions have enough data bytes
#### Parameters
##### bytecode
`BrandedBytecode`
EVM bytecode
#### Returns
`void`
#### Throws
If bytecode is invalid
#### Example
```typescript theme={null}
const code = Bytecode("0x6001...");
Bytecode.validate(code); // Throws if invalid
```
## References
### AbstractError
Re-exports [AbstractError](../../index.mdx#abstracterror)
***
### AesGcm
Re-exports [AesGcm](../../../crypto/AesGcm.mdx#aesgcm)
***
### Bip39
Re-exports [Bip39](../../../crypto/Bip39.mdx#bip39)
***
### ChaCha20Poly1305
Re-exports [ChaCha20Poly1305](../../../crypto/ChaCha20Poly1305.mdx#chacha20poly1305)
***
### CryptoError
Re-exports [CryptoError](../../index.mdx#cryptoerror)
***
### DecodingError
Re-exports [DecodingError](../../index.mdx#decodingerror)
***
### EncodingError
Re-exports [EncodingError](../../index.mdx#encodingerror)
***
### ERC1155
Re-exports [ERC1155](../ERC1155.mdx)
***
### ERC165
Re-exports [ERC165](../ERC165.mdx)
***
### ERC20
Re-exports [ERC20](../ERC20.mdx)
***
### ERC721
Re-exports [ERC721](../ERC721.mdx)
***
### evm
Re-exports [evm](../../../evm/index.mdx)
***
### HDWallet
Re-exports [HDWallet](../../../HDWallet.mdx)
***
### IntegerOverflowError
Re-exports [IntegerOverflowError](../../index.mdx#integeroverflowerror)
***
### IntegerUnderflowError
Re-exports [IntegerUnderflowError](../../index.mdx#integerunderflowerror)
***
### InvalidChecksumError
Re-exports [InvalidChecksumError](../../index.mdx#invalidchecksumerror)
***
### InvalidFormatError
Re-exports [InvalidFormatError](../../index.mdx#invalidformaterror)
***
### InvalidLengthError
Re-exports [InvalidLengthError](../../index.mdx#invalidlengtherror)
***
### InvalidPrivateKeyError
Re-exports [InvalidPrivateKeyError](../../index.mdx#invalidprivatekeyerror)
***
### InvalidPublicKeyError
Re-exports [InvalidPublicKeyError](../../index.mdx#invalidpublickeyerror)
***
### InvalidRangeError
Re-exports [InvalidRangeError](../../index.mdx#invalidrangeerror)
***
### InvalidSignatureError
Re-exports [InvalidSignatureError](../../index.mdx#invalidsignatureerror)
***
### InvalidSignerError
Re-exports [InvalidSignerError](../../index.mdx#invalidsignererror)
***
### InvalidSizeError
Re-exports [InvalidSizeError](../../index.mdx#invalidsizeerror)
***
### InvalidTransactionTypeError
Re-exports [InvalidTransactionTypeError](../../index.mdx#invalidtransactiontypeerror)
***
### KeccakHash
Renames and re-exports [Hash](../../index.mdx#hash)
***
### Keystore
Renames and re-exports [crypto/Keystore](../../../crypto/Keystore.mdx)
***
### precompiles
Re-exports [precompiles](../precompiles.mdx)
***
### PrimitiveError
Re-exports [PrimitiveError](../../index.mdx#primitiveerror)
***
### SerializationError
Re-exports [SerializationError](../../index.mdx#serializationerror)
***
### TransactionError
Re-exports [TransactionError](../../index.mdx#transactionerror)
***
### ValidationError
Re-exports [ValidationError](../../index.mdx#validationerror)
# Blake2Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Blake2Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / Blake2Wasm
# Blake2Wasm
BLAKE2b operations namespace (WASM variant)
## See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
## Since
0.0.0
## Functions
### hash()
> **hash**(`data`, `outputLength`): `Uint8Array`
Defined in: [src/crypto/Blake2/Blake2.wasm.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/Blake2.wasm.ts#L31)
Hash data with BLAKE2b using WASM implementation
#### Parameters
##### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### outputLength
`number` = `64`
Output length in bytes (1-64, default 64)
#### Returns
`Uint8Array`
BLAKE2b hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If outputLength is invalid
#### Example
```typescript theme={null}
import { Blake2Wasm } from './crypto/Blake2/Blake2.wasm.js';
const hash = Blake2Wasm.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2Wasm.hash("hello", 32);
```
***
### hashString()
> **hashString**(`str`, `outputLength`): `Uint8Array`
Defined in: [src/crypto/Blake2/Blake2.wasm.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Blake2/Blake2.wasm.ts#L62)
Hash string with BLAKE2b using WASM implementation (convenience function)
#### Parameters
##### str
`string`
Input string to hash
##### outputLength
`number` = `64`
Output length in bytes (1-64, default 64)
#### Returns
`Uint8Array`
BLAKE2b hash
#### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
#### Since
0.0.0
#### Throws
If outputLength is invalid
#### Example
```typescript theme={null}
import { Blake2Wasm } from './crypto/Blake2/Blake2.wasm.js';
const hash = Blake2Wasm.hashString("hello world");
const hash48 = Blake2Wasm.hashString("hello world", 48);
```
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Bn254Wasm/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../index.mdx) / [index](../../../../index.mdx) / [wasm](../../index.mdx) / Bn254Wasm
# Bn254Wasm
BN254 WASM implementation
Uses native Zig BN254 implementation via WebAssembly
## Namespaces
* [Fr](namespaces/Fr.mdx)
* [G1](namespaces/G1.mdx)
* [G2](namespaces/G2.mdx)
* [Pairing](namespaces/Pairing.mdx)
# Fr
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Bn254Wasm/namespaces/Fr
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Bn254Wasm](../index.mdx) / Fr
# Fr
## Functions
### add()
> **add**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:157](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L157)
#### Returns
`never`
***
### inv()
> **inv**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:169](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L169)
#### Returns
`never`
***
### mul()
> **mul**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:163](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L163)
#### Returns
`never`
# G1
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Bn254Wasm/namespaces/G1
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Bn254Wasm](../index.mdx) / G1
# G1
## Functions
### add()
> **add**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L21)
#### Returns
`never`
***
### double()
> **double**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L27)
#### Returns
`never`
***
### equal()
> **equal**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L57)
#### Returns
`never`
***
### fromAffine()
> **fromAffine**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L69)
#### Returns
`never`
***
### generator()
> **generator**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L9)
#### Returns
`never`
***
### infinity()
> **infinity**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L15)
#### Returns
`never`
***
### isOnCurve()
> **isOnCurve**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L51)
#### Returns
`never`
***
### isZero()
> **isZero**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L45)
#### Returns
`never`
***
### mul()
> **mul**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L39)
#### Returns
`never`
***
### negate()
> **negate**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L33)
#### Returns
`never`
***
### toAffine()
> **toAffine**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L63)
#### Returns
`never`
# G2
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Bn254Wasm/namespaces/G2
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Bn254Wasm](../index.mdx) / G2
# G2
## Functions
### add()
> **add**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L89)
#### Returns
`never`
***
### double()
> **double**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L95)
#### Returns
`never`
***
### equal()
> **equal**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:131](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L131)
#### Returns
`never`
***
### frobenius()
> **frobenius**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:149](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L149)
#### Returns
`never`
***
### fromAffine()
> **fromAffine**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:143](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L143)
#### Returns
`never`
***
### generator()
> **generator**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L77)
#### Returns
`never`
***
### infinity()
> **infinity**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L83)
#### Returns
`never`
***
### isInSubgroup()
> **isInSubgroup**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L125)
#### Returns
`never`
***
### isOnCurve()
> **isOnCurve**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L119)
#### Returns
`never`
***
### isZero()
> **isZero**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L113)
#### Returns
`never`
***
### mul()
> **mul**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L107)
#### Returns
`never`
***
### negate()
> **negate**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:101](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L101)
#### Returns
`never`
***
### toAffine()
> **toAffine**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:137](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L137)
#### Returns
`never`
# Pairing
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Bn254Wasm/namespaces/Pairing
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Bn254Wasm](../index.mdx) / Pairing
# Pairing
## Functions
### pair()
> **pair**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:177](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L177)
#### Returns
`never`
***
### pairingCheck()
> **pairingCheck**(): `never`
Defined in: [src/crypto/bn254.wasm.ts:183](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/bn254.wasm.ts#L183)
#### Returns
`never`
# Ed25519Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Ed25519Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / Ed25519Wasm
# Ed25519Wasm
## Classes
### Ed25519Error
Defined in: [src/crypto/ed25519.wasm.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L37)
#### Extends
* `Error`
#### Extended by
* [`InvalidSignatureError`](#invalidsignatureerror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
* [`InvalidSecretKeyError`](#invalidsecretkeyerror)
* [`InvalidSeedError`](#invalidseederror)
#### Constructors
##### Constructor
> **new Ed25519Error**(`message`): [`Ed25519Error`](#ed25519error)
Defined in: [src/crypto/ed25519.wasm.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L38)
###### Parameters
###### message
`string`
###### Returns
[`Ed25519Error`](#ed25519error)
###### Overrides
`Error.constructor`
***
### InvalidPublicKeyError
Defined in: [src/crypto/ed25519.wasm.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L51)
#### Extends
* [`Ed25519Error`](#ed25519error)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/ed25519.wasm.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L52)
###### Parameters
###### message
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`Ed25519Error`](#ed25519error).[`constructor`](#constructor)
***
### InvalidSecretKeyError
Defined in: [src/crypto/ed25519.wasm.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L58)
#### Extends
* [`Ed25519Error`](#ed25519error)
#### Constructors
##### Constructor
> **new InvalidSecretKeyError**(`message`): [`InvalidSecretKeyError`](#invalidsecretkeyerror)
Defined in: [src/crypto/ed25519.wasm.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L59)
###### Parameters
###### message
`string`
###### Returns
[`InvalidSecretKeyError`](#invalidsecretkeyerror)
###### Overrides
[`Ed25519Error`](#ed25519error).[`constructor`](#constructor)
***
### InvalidSeedError
Defined in: [src/crypto/ed25519.wasm.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L65)
#### Extends
* [`Ed25519Error`](#ed25519error)
#### Constructors
##### Constructor
> **new InvalidSeedError**(`message`): [`InvalidSeedError`](#invalidseederror)
Defined in: [src/crypto/ed25519.wasm.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L66)
###### Parameters
###### message
`string`
###### Returns
[`InvalidSeedError`](#invalidseederror)
###### Overrides
[`Ed25519Error`](#ed25519error).[`constructor`](#constructor)
***
### InvalidSignatureError
Defined in: [src/crypto/ed25519.wasm.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L44)
#### Extends
* [`Ed25519Error`](#ed25519error)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/crypto/ed25519.wasm.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L45)
###### Parameters
###### message
`string`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`Ed25519Error`](#ed25519error).[`constructor`](#constructor)
## Type Aliases
### PublicKey
> **PublicKey** = `Uint8Array`
Defined in: [src/crypto/ed25519.wasm.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L20)
***
### SecretKey
> **SecretKey** = `Uint8Array`
Defined in: [src/crypto/ed25519.wasm.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L21)
***
### Seed
> **Seed** = `Uint8Array`
Defined in: [src/crypto/ed25519.wasm.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L22)
***
### Signature
> **Signature** = `Uint8Array`
Defined in: [src/crypto/ed25519.wasm.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L19)
## Variables
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/ed25519.wasm.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L29)
***
### SECRET\_KEY\_SIZE
> `const` **SECRET\_KEY\_SIZE**: `64` = `64`
Defined in: [src/crypto/ed25519.wasm.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L28)
***
### SEED\_SIZE
> `const` **SEED\_SIZE**: `32` = `32`
Defined in: [src/crypto/ed25519.wasm.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L31)
***
### SIGNATURE\_SIZE
> `const` **SIGNATURE\_SIZE**: `64` = `64`
Defined in: [src/crypto/ed25519.wasm.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L30)
## Functions
### derivePublicKey()
> **derivePublicKey**(`secretKey`): [`PublicKey`](#publickey)
Defined in: [src/crypto/ed25519.wasm.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L150)
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
#### Returns
[`PublicKey`](#publickey)
***
### keypairFromSeed()
> **keypairFromSeed**(`seed`): `object`
Defined in: [src/crypto/ed25519.wasm.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L76)
#### Parameters
##### seed
[`Seed`](#seed)
#### Returns
`object`
##### publicKey
> **publicKey**: [`PublicKey`](#publickey)
##### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
***
### sign()
> **sign**(`message`, `secretKey`): [`Signature`](#signature)
Defined in: [src/crypto/ed25519.wasm.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L102)
#### Parameters
##### message
`Uint8Array`
##### secretKey
[`SecretKey`](#secretkey)
#### Returns
[`Signature`](#signature)
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/ed25519.wasm.ts:185](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L185)
#### Parameters
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
***
### validateSecretKey()
> **validateSecretKey**(`secretKey`): `boolean`
Defined in: [src/crypto/ed25519.wasm.ts:181](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L181)
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
#### Returns
`boolean`
***
### validateSeed()
> **validateSeed**(`seed`): `boolean`
Defined in: [src/crypto/ed25519.wasm.ts:193](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L193)
#### Parameters
##### seed
[`Seed`](#seed)
#### Returns
`boolean`
***
### verify()
> **verify**(`signature`, `message`, `publicKey`): `boolean`
Defined in: [src/crypto/ed25519.wasm.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ed25519.wasm.ts#L122)
#### Parameters
##### signature
[`Signature`](#signature)
##### message
`Uint8Array`
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Eip712Wasm/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../index.mdx) / [index](../../../../index.mdx) / [wasm](../../index.mdx) / Eip712Wasm
# Eip712Wasm
## Namespaces
* [Domain](namespaces/Domain.mdx)
## Type Aliases
### Signature
> **Signature** = [`Signature`](../Secp256k1Wasm/index.mdx#signature)
Defined in: [src/crypto/eip712.wasm.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L54)
***
### Types
> **Types** = [`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Defined in: [src/crypto/eip712.wasm.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L55)
## Functions
### encodeData()
> **encodeData**(`primaryType`, `message`, `types`): `Uint8Array`
Defined in: [src/crypto/eip712.wasm.ts:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L253)
Encode data for struct
#### Parameters
##### primaryType
`string`
Name of struct type
##### message
[`Message`](../../../../../crypto/EIP712.mdx#message)
Message data
##### types
[`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Type definitions
#### Returns
`Uint8Array`
Encoded data
***
### encodeType()
> **encodeType**(`primaryType`, `types`): `string`
Defined in: [src/crypto/eip712.wasm.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L110)
Encode type string (e.g., "Mail(Person from,Person to,string contents)")
#### Parameters
##### primaryType
`string`
Name of primary type
##### types
[`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Type definitions
#### Returns
`string`
Type encoding string
***
### encodeValue()
> **encodeValue**(`type`, `value`, `types`): `Uint8Array`
Defined in: [src/crypto/eip712.wasm.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L170)
Encode single value
#### Parameters
##### type
`string`
Solidity type string
##### value
`unknown`
Value to encode
##### types
[`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Type definitions (for structs)
#### Returns
`Uint8Array`
32-byte encoded value
***
### format()
> **format**(`typedData`): `string`
Defined in: [src/crypto/eip712.wasm.ts:407](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L407)
Format typed data for display
#### Parameters
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
#### Returns
`string`
***
### hashStruct()
> **hashStruct**(`primaryType`, `message`, `types`): [`HashType`](../../../HashType.mdx#hashtype)
Defined in: [src/crypto/eip712.wasm.ts:295](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L295)
Hash struct
#### Parameters
##### primaryType
`string`
Name of struct type
##### message
[`Message`](../../../../../crypto/EIP712.mdx#message)
Message data
##### types
[`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Type definitions
#### Returns
[`HashType`](../../../HashType.mdx#hashtype)
32-byte struct hash
***
### hashType()
> **hashType**(`primaryType`, `types`): [`HashType`](../../../HashType.mdx#hashtype)
Defined in: [src/crypto/eip712.wasm.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L152)
Hash type string
#### Parameters
##### primaryType
`string`
Name of primary type
##### types
[`TypeDefinitions`](../../../../../crypto/EIP712.mdx#typedefinitions)
Type definitions
#### Returns
[`HashType`](../../../HashType.mdx#hashtype)
32-byte type hash
***
### hashTypedData()
> **hashTypedData**(`typedData`): [`HashType`](../../../HashType.mdx#hashtype)
Defined in: [src/crypto/eip712.wasm.ts:314](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L314)
Hash typed data (EIP-712 signing hash)
#### Parameters
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
Complete typed data structure
#### Returns
[`HashType`](../../../HashType.mdx#hashtype)
32-byte hash ready for signing
***
### init()
> **init**(): `Promise`\<`void`>
Defined in: [src/crypto/eip712.wasm.ts:420](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L420)
Initialize WASM modules
Must be called before using any Eip712Wasm functions.
#### Returns
`Promise`\<`void`>
***
### recoverAddress()
> **recoverAddress**(`signature`, `typedData`): [`AddressType`](../../../../../primitives/Address.mdx#addresstype)
Defined in: [src/crypto/eip712.wasm.ts:354](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L354)
Recover signer address from signature
#### Parameters
##### signature
[`Signature`](../Secp256k1Wasm/index.mdx#signature)
Signature to recover from
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
Typed data that was signed
#### Returns
[`AddressType`](../../../../../primitives/Address.mdx#addresstype)
Recovered address
***
### signTypedData()
> **signTypedData**(`typedData`, `privateKey`): [`Signature`](../Secp256k1Wasm/index.mdx#signature)
Defined in: [src/crypto/eip712.wasm.ts:339](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L339)
Sign typed data with private key
#### Parameters
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
Typed data to sign
##### privateKey
`Uint8Array`
32-byte private key
#### Returns
[`Signature`](../Secp256k1Wasm/index.mdx#signature)
Signature (r, s, v)
***
### validate()
> **validate**(`typedData`): `boolean`
Defined in: [src/crypto/eip712.wasm.ts:394](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L394)
Validate typed data structure
#### Parameters
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
#### Returns
`boolean`
***
### verifyTypedData()
> **verifyTypedData**(`signature`, `typedData`, `address`): `boolean`
Defined in: [src/crypto/eip712.wasm.ts:374](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L374)
Verify typed data signature against address
#### Parameters
##### signature
[`Signature`](../Secp256k1Wasm/index.mdx#signature)
Signature to verify
##### typedData
[`TypedData`](../../../../../crypto/EIP712.mdx#typeddata)
Typed data that was signed
##### address
[`AddressType`](../../../../../primitives/Address.mdx#addresstype)
Expected signer address
#### Returns
`boolean`
True if signature is valid
# Domain
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Eip712Wasm/namespaces/Domain
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Eip712Wasm](../index.mdx) / Domain
# Domain
## Functions
### hash()
> **hash**(`domain`): [`HashType`](../../../../HashType.mdx#hashtype)
Defined in: [src/crypto/eip712.wasm.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/eip712.wasm.ts#L68)
Hash domain separator
#### Parameters
##### domain
[`Domain`](../../../../../../crypto/EIP712.mdx#domain)
Domain separator fields
#### Returns
[`HashType`](../../../../HashType.mdx#hashtype)
32-byte domain hash
# P256Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/P256Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / P256Wasm
# P256Wasm
## Classes
### InvalidPrivateKeyError
Defined in: [src/crypto/p256.wasm.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L64)
#### Extends
* [`P256Error`](#p256error)
#### Constructors
##### Constructor
> **new InvalidPrivateKeyError**(`message`): [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
Defined in: [src/crypto/p256.wasm.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L65)
###### Parameters
###### message
`string`
###### Returns
[`InvalidPrivateKeyError`](#invalidprivatekeyerror)
###### Overrides
[`P256Error`](#p256error).[`constructor`](#constructor-3)
***
### InvalidPublicKeyError
Defined in: [src/crypto/p256.wasm.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L57)
#### Extends
* [`P256Error`](#p256error)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/p256.wasm.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L58)
###### Parameters
###### message
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`P256Error`](#p256error).[`constructor`](#constructor-3)
***
### InvalidSignatureError
Defined in: [src/crypto/p256.wasm.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L50)
#### Extends
* [`P256Error`](#p256error)
#### Constructors
##### Constructor
> **new InvalidSignatureError**(`message`): [`InvalidSignatureError`](#invalidsignatureerror)
Defined in: [src/crypto/p256.wasm.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L51)
###### Parameters
###### message
`string`
###### Returns
[`InvalidSignatureError`](#invalidsignatureerror)
###### Overrides
[`P256Error`](#p256error).[`constructor`](#constructor-3)
***
### P256Error
Defined in: [src/crypto/p256.wasm.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L43)
#### Extends
* `Error`
#### Extended by
* [`InvalidSignatureError`](#invalidsignatureerror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
* [`InvalidPrivateKeyError`](#invalidprivatekeyerror)
#### Constructors
##### Constructor
> **new P256Error**(`message`): [`P256Error`](#p256error)
Defined in: [src/crypto/p256.wasm.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L44)
###### Parameters
###### message
`string`
###### Returns
[`P256Error`](#p256error)
###### Overrides
`Error.constructor`
## Type Aliases
### PrivateKey
> **PrivateKey** = `Uint8Array`
Defined in: [src/crypto/p256.wasm.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L26)
***
### PublicKey
> **PublicKey** = `Uint8Array`
Defined in: [src/crypto/p256.wasm.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L25)
***
### Signature
> **Signature** = `object`
Defined in: [src/crypto/p256.wasm.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L20)
#### Properties
##### r
> **r**: `Uint8Array`
Defined in: [src/crypto/p256.wasm.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L21)
##### s
> **s**: `Uint8Array`
Defined in: [src/crypto/p256.wasm.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L22)
## Variables
### CURVE\_ORDER
> `const` **CURVE\_ORDER**: `115792089210356248762697446949407573529996955224135760342422259061068512044369n` = `0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n`
Defined in: [src/crypto/p256.wasm.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L32)
***
### PRIVATE\_KEY\_SIZE
> `const` **PRIVATE\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/p256.wasm.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L34)
***
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `64` = `64`
Defined in: [src/crypto/p256.wasm.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L35)
***
### SHARED\_SECRET\_SIZE
> `const` **SHARED\_SECRET\_SIZE**: `32` = `32`
Defined in: [src/crypto/p256.wasm.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L37)
***
### SIGNATURE\_COMPONENT\_SIZE
> `const` **SIGNATURE\_COMPONENT\_SIZE**: `32` = `32`
Defined in: [src/crypto/p256.wasm.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L36)
## Functions
### derivePublicKey()
> **derivePublicKey**(`privateKey`): [`PublicKey`](#publickey)
Defined in: [src/crypto/p256.wasm.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L152)
#### Parameters
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
[`PublicKey`](#publickey)
***
### ecdh()
> **ecdh**(`privateKey`, `publicKey`): `Uint8Array`
Defined in: [src/crypto/p256.wasm.ts:175](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L175)
#### Parameters
##### privateKey
[`PrivateKey`](#privatekey)
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`Uint8Array`
***
### sign()
> **sign**(`messageHash`, `privateKey`): [`Signature`](#signature)
Defined in: [src/crypto/p256.wasm.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L75)
#### Parameters
##### messageHash
[`HashType`](../../HashType.mdx#hashtype)
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
[`Signature`](#signature)
***
### validatePrivateKey()
> **validatePrivateKey**(`privateKey`): `boolean`
Defined in: [src/crypto/p256.wasm.ts:202](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L202)
#### Parameters
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
`boolean`
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/p256.wasm.ts:216](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L216)
#### Parameters
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
***
### verify()
> **verify**(`signature`, `messageHash`, `publicKey`): `boolean`
Defined in: [src/crypto/p256.wasm.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/p256.wasm.ts#L100)
#### Parameters
##### signature
[`Signature`](#signature)
##### messageHash
[`HashType`](../../HashType.mdx#hashtype)
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
# Ripemd160Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Ripemd160Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / Ripemd160Wasm
# Ripemd160Wasm
Reset memory allocator (currently unused)
## Functions
### hash()
> **hash**(`data`): `Uint8Array`
Defined in: [src/crypto/ripemd160.wasm.ts:219](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ripemd160.wasm.ts#L219)
Compute RIPEMD160 hash (20 bytes)
#### Parameters
##### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`
20-byte hash
#### Example
```typescript theme={null}
const hash = Ripemd160Wasm.hash(data);
// Uint8Array(20)
```
***
### hashString()
> **hashString**(`str`): `Uint8Array`
Defined in: [src/crypto/ripemd160.wasm.ts:259](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ripemd160.wasm.ts#L259)
Compute RIPEMD160 hash of UTF-8 string
#### Parameters
##### str
`string`
Input string
#### Returns
`Uint8Array`
20-byte hash
#### Example
```typescript theme={null}
const hash = Ripemd160Wasm.hashString("hello");
// Uint8Array(20)
```
***
### load()
> **load**(): `Promise`\<`void`>
Defined in: [src/crypto/ripemd160.wasm.ts:203](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/ripemd160.wasm.ts#L203)
Load WASM module (must be called before using other functions)
#### Returns
`Promise`\<`void`>
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Secp256k1Wasm/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../index.mdx) / [index](../../../../index.mdx) / [wasm](../../index.mdx) / Secp256k1Wasm
# Secp256k1Wasm
## Namespaces
* [Signature](namespaces/Signature.mdx)
## Type Aliases
### PrivateKey
> **PrivateKey** = `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L35)
***
### PublicKey
> **PublicKey** = `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L34)
***
### Signature
> **Signature** = `object`
Defined in: [src/crypto/secp256k1.wasm.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L28)
#### Properties
##### r
> **r**: `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L29)
##### s
> **s**: `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L30)
##### v
> **v**: `number`
Defined in: [src/crypto/secp256k1.wasm.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L31)
## Variables
### CURVE\_ORDER
> `const` **CURVE\_ORDER**: `115792089237316195423570985008687907852837564279074904382605163141518161494337n` = `0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n`
Defined in: [src/crypto/secp256k1.wasm.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L41)
***
### PRIVATE\_KEY\_SIZE
> `const` **PRIVATE\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/secp256k1.wasm.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L43)
***
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `64` = `64`
Defined in: [src/crypto/secp256k1.wasm.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L44)
***
### SIGNATURE\_COMPONENT\_SIZE
> `const` **SIGNATURE\_COMPONENT\_SIZE**: `32` = `32`
Defined in: [src/crypto/secp256k1.wasm.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L45)
## Functions
### derivePublicKey()
> **derivePublicKey**(`privateKey`): [`PublicKey`](#publickey)
Defined in: [src/crypto/secp256k1.wasm.ts:191](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L191)
#### Parameters
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
[`PublicKey`](#publickey)
***
### isValidPrivateKey()
> **isValidPrivateKey**(`privateKey`): `boolean`
Defined in: [src/crypto/secp256k1.wasm.ts:259](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L259)
#### Parameters
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
`boolean`
***
### isValidPublicKey()
> **isValidPublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/secp256k1.wasm.ts:241](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L241)
#### Parameters
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
***
### isValidSignature()
> **isValidSignature**(`signature`): `boolean`
Defined in: [src/crypto/secp256k1.wasm.ts:209](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L209)
#### Parameters
##### signature
[`Signature`](#signature)
#### Returns
`boolean`
***
### recoverPublicKey()
> **recoverPublicKey**(`signature`, `messageHash`): [`PublicKey`](#publickey)
Defined in: [src/crypto/secp256k1.wasm.ts:137](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L137)
#### Parameters
##### signature
[`Signature`](#signature)
##### messageHash
[`HashType`](../../../HashType.mdx#hashtype)
#### Returns
[`PublicKey`](#publickey)
***
### sign()
> **sign**(`messageHash`, `privateKey`): [`Signature`](#signature)
Defined in: [src/crypto/secp256k1.wasm.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L51)
#### Parameters
##### messageHash
[`HashType`](../../../HashType.mdx#hashtype)
##### privateKey
[`PrivateKey`](#privatekey)
#### Returns
[`Signature`](#signature)
***
### verify()
> **verify**(`signature`, `messageHash`, `publicKey`): `boolean`
Defined in: [src/crypto/secp256k1.wasm.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L78)
#### Parameters
##### signature
[`Signature`](#signature)
##### messageHash
[`HashType`](../../../HashType.mdx#hashtype)
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
# Signature
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Secp256k1Wasm/namespaces/Signature
Auto-generated API documentation
[**@tevm/voltaire**](../../../../../../index.mdx)
***
[@tevm/voltaire](../../../../../../index.mdx) / [index](../../../../../index.mdx) / [wasm](../../../index.mdx) / [Secp256k1Wasm](../index.mdx) / Signature
# Signature
## Functions
### fromBytes()
> **fromBytes**(`bytes`): [`Signature`](../index.mdx#signature)
Defined in: [src/crypto/secp256k1.wasm.ts:308](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L308)
#### Parameters
##### bytes
`Uint8Array`
#### Returns
[`Signature`](../index.mdx#signature)
***
### fromCompact()
> **fromCompact**(`compact`, `v`): [`Signature`](../index.mdx#signature)
Defined in: [src/crypto/secp256k1.wasm.ts:291](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L291)
#### Parameters
##### compact
`Uint8Array`
##### v
`number`
#### Returns
[`Signature`](../index.mdx#signature)
***
### toBytes()
> **toBytes**(`sig`): `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:283](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L283)
#### Parameters
##### sig
[`Signature`](../index.mdx#signature)
#### Returns
`Uint8Array`
***
### toCompact()
> **toCompact**(`sig`): `Uint8Array`
Defined in: [src/crypto/secp256k1.wasm.ts:279](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/secp256k1.wasm.ts#L279)
#### Parameters
##### sig
[`Signature`](../index.mdx#signature)
#### Returns
`Uint8Array`
# Sha256Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/Sha256Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / Sha256Wasm
# Sha256Wasm
SHA256 hash function implemented using WASM Zig code
## Variables
### BLOCK\_SIZE
> `const` **BLOCK\_SIZE**: `64` = `64`
Defined in: [src/crypto/sha256.wasm.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L20)
SHA256 block size in bytes
***
### OUTPUT\_SIZE
> `const` **OUTPUT\_SIZE**: `32` = `32`
Defined in: [src/crypto/sha256.wasm.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L15)
SHA256 output size in bytes (256 bits / 8)
## Functions
### create()
> **create**(): `object`
Defined in: [src/crypto/sha256.wasm.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L110)
Incremental hasher for streaming data
Note: This implementation uses a simple buffer accumulator.
For truly large streaming data, consider using the Noble.js implementation.
#### Returns
##### digest()
> **digest**(): `Uint8Array`
Finalize and get hash
###### Returns
`Uint8Array`
##### update()
> **update**(`data`): `void`
Update hasher with new data
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
#### Example
```typescript theme={null}
const hasher = Sha256Wasm.create();
hasher.update(chunk1);
hasher.update(chunk2);
const hash = hasher.digest();
```
***
### hash()
> **hash**(`data`): `Uint8Array`
Defined in: [src/crypto/sha256.wasm.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L34)
Compute SHA256 hash of input data
#### Parameters
##### data
`Uint8Array`
Input data as Uint8Array
#### Returns
`Uint8Array`
32-byte hash
#### Example
```typescript theme={null}
const hash = Sha256Wasm.hash(new Uint8Array([1, 2, 3]));
// Uint8Array(32) [...]
```
***
### hashHex()
> **hashHex**(`hex`): `Uint8Array`
Defined in: [src/crypto/sha256.wasm.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L68)
Compute SHA256 hash of hex string (without 0x prefix)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
`Uint8Array`
32-byte hash
#### Example
```typescript theme={null}
const hash = Sha256Wasm.hashHex("0xdeadbeef");
// Uint8Array(32) [...]
```
***
### hashString()
> **hashString**(`str`): `Uint8Array`
Defined in: [src/crypto/sha256.wasm.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L50)
Compute SHA256 hash of UTF-8 string
#### Parameters
##### str
`string`
Input string
#### Returns
`Uint8Array`
32-byte hash
#### Example
```typescript theme={null}
const hash = Sha256Wasm.hashString("hello world");
// Uint8Array(32) [0xb9, 0x4d, 0x27, ...]
```
***
### toHex()
> **toHex**(`hash`): `string`
Defined in: [src/crypto/sha256.wasm.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/sha256.wasm.ts#L90)
Convert hash output to hex string
#### Parameters
##### hash
`Uint8Array`
Hash bytes
#### Returns
`string`
Hex string with 0x prefix
#### Example
```typescript theme={null}
const hash = Sha256Wasm.hash(data);
const hexStr = Sha256Wasm.toHex(hash);
// "0x..."
```
# X25519Wasm
Source: https://voltaire.tevm.sh/generated-api/index/namespaces/wasm/namespaces/X25519Wasm
Auto-generated API documentation
[**@tevm/voltaire**](../../../../index.mdx)
***
[@tevm/voltaire](../../../../index.mdx) / [index](../../../index.mdx) / [wasm](../index.mdx) / X25519Wasm
# X25519Wasm
## Classes
### InvalidPublicKeyError
Defined in: [src/crypto/x25519.wasm.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L49)
#### Extends
* [`X25519Error`](#x25519error)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/crypto/x25519.wasm.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L50)
###### Parameters
###### message
`string`
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`X25519Error`](#x25519error).[`constructor`](#constructor-2)
***
### InvalidSecretKeyError
Defined in: [src/crypto/x25519.wasm.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L42)
#### Extends
* [`X25519Error`](#x25519error)
#### Constructors
##### Constructor
> **new InvalidSecretKeyError**(`message`): [`InvalidSecretKeyError`](#invalidsecretkeyerror)
Defined in: [src/crypto/x25519.wasm.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L43)
###### Parameters
###### message
`string`
###### Returns
[`InvalidSecretKeyError`](#invalidsecretkeyerror)
###### Overrides
[`X25519Error`](#x25519error).[`constructor`](#constructor-2)
***
### X25519Error
Defined in: [src/crypto/x25519.wasm.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L35)
#### Extends
* `Error`
#### Extended by
* [`InvalidSecretKeyError`](#invalidsecretkeyerror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
#### Constructors
##### Constructor
> **new X25519Error**(`message`): [`X25519Error`](#x25519error)
Defined in: [src/crypto/x25519.wasm.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L36)
###### Parameters
###### message
`string`
###### Returns
[`X25519Error`](#x25519error)
###### Overrides
`Error.constructor`
## Type Aliases
### PublicKey
> **PublicKey** = `Uint8Array`
Defined in: [src/crypto/x25519.wasm.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L20)
***
### SecretKey
> **SecretKey** = `Uint8Array`
Defined in: [src/crypto/x25519.wasm.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L19)
***
### SharedSecret
> **SharedSecret** = `Uint8Array`
Defined in: [src/crypto/x25519.wasm.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L21)
## Variables
### PUBLIC\_KEY\_SIZE
> `const` **PUBLIC\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/x25519.wasm.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L28)
***
### SECRET\_KEY\_SIZE
> `const` **SECRET\_KEY\_SIZE**: `32` = `32`
Defined in: [src/crypto/x25519.wasm.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L27)
***
### SHARED\_SECRET\_SIZE
> `const` **SHARED\_SECRET\_SIZE**: `32` = `32`
Defined in: [src/crypto/x25519.wasm.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L29)
## Functions
### derivePublicKey()
> **derivePublicKey**(`secretKey`): [`PublicKey`](#publickey)
Defined in: [src/crypto/x25519.wasm.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L60)
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
#### Returns
[`PublicKey`](#publickey)
***
### keypairFromSeed()
> **keypairFromSeed**(`seed`): `object`
Defined in: [src/crypto/x25519.wasm.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L105)
#### Parameters
##### seed
`Uint8Array`
#### Returns
`object`
##### publicKey
> **publicKey**: [`PublicKey`](#publickey)
##### secretKey
> **secretKey**: [`SecretKey`](#secretkey)
***
### scalarmult()
> **scalarmult**(`secretKey`, `publicKey`): [`SharedSecret`](#sharedsecret)
Defined in: [src/crypto/x25519.wasm.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L78)
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
##### publicKey
[`PublicKey`](#publickey)
#### Returns
[`SharedSecret`](#sharedsecret)
***
### validatePublicKey()
> **validatePublicKey**(`publicKey`): `boolean`
Defined in: [src/crypto/x25519.wasm.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L130)
#### Parameters
##### publicKey
[`PublicKey`](#publickey)
#### Returns
`boolean`
***
### validateSecretKey()
> **validateSecretKey**(`secretKey`): `boolean`
Defined in: [src/crypto/x25519.wasm.ts:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/x25519.wasm.ts#L126)
#### Parameters
##### secretKey
[`SecretKey`](#secretkey)
#### Returns
`boolean`
# native
Source: https://voltaire.tevm.sh/generated-api/native
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / native
# native
## Enumerations
### NativeErrorCode
Defined in: [src/native-loader/types.ts:204](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L204)
Runtime error codes from native library
#### Enumeration Members
##### BUFFER\_TOO\_SMALL
> **BUFFER\_TOO\_SMALL**: `-4`
Defined in: [src/native-loader/types.ts:209](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L209)
##### DECODING\_ERROR
> **DECODING\_ERROR**: `-10`
Defined in: [src/native-loader/types.ts:215](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L215)
##### ENCODING\_ERROR
> **ENCODING\_ERROR**: `-9`
Defined in: [src/native-loader/types.ts:214](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L214)
##### INVALID\_CHECKSUM
> **INVALID\_CHECKSUM**: `-3`
Defined in: [src/native-loader/types.ts:208](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L208)
##### INVALID\_HEX
> **INVALID\_HEX**: `-1`
Defined in: [src/native-loader/types.ts:206](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L206)
##### INVALID\_LENGTH
> **INVALID\_LENGTH**: `-2`
Defined in: [src/native-loader/types.ts:207](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L207)
##### INVALID\_PRIVATE\_KEY
> **INVALID\_PRIVATE\_KEY**: `-7`
Defined in: [src/native-loader/types.ts:212](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L212)
##### INVALID\_PUBLIC\_KEY
> **INVALID\_PUBLIC\_KEY**: `-8`
Defined in: [src/native-loader/types.ts:213](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L213)
##### INVALID\_RECOVERY\_ID
> **INVALID\_RECOVERY\_ID**: `-6`
Defined in: [src/native-loader/types.ts:211](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L211)
##### INVALID\_SIGNATURE
> **INVALID\_SIGNATURE**: `-5`
Defined in: [src/native-loader/types.ts:210](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L210)
##### NULL\_POINTER
> **NULL\_POINTER**: `-11`
Defined in: [src/native-loader/types.ts:216](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L216)
##### OUT\_OF\_MEMORY
> **OUT\_OF\_MEMORY**: `-12`
Defined in: [src/native-loader/types.ts:217](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L217)
##### SUCCESS
> **SUCCESS**: `0`
Defined in: [src/native-loader/types.ts:205](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L205)
##### UNKNOWN\_ERROR
> **UNKNOWN\_ERROR**: `-99`
Defined in: [src/native-loader/types.ts:218](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L218)
## Type Aliases
### Platform
> **Platform** = `"darwin-arm64"` | `"darwin-x64"` | `"linux-arm64"` | `"linux-x64"` | `"win32-x64"`
Defined in: [src/native-loader/platform.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/platform.ts#L5)
Platform detection utilities for native bindings
## Variables
### Keccak256
> `const` **Keccak256**: (`input`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> & `object` = `Keccak256Hash`
Defined in: [src/crypto/Keccak256/Keccak256.native.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/Keccak256.native.ts#L150)
#### Type Declaration
##### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number` = `32`
##### from()
> **from**: (`input`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Universal constructor - accepts hex, string, or bytes
###### Parameters
###### input
Hex string, UTF-8 string, or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### fromHex()
> **fromHex**: (`hex`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> = `hashHex`
Hash hex string with Keccak-256 using native implementation
###### Parameters
###### hex
`string`
Hex string to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### fromString()
> **fromString**: (`str`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> = `hashString`
Hash UTF-8 string with Keccak-256 using native implementation
###### Parameters
###### str
`string`
String to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hash()
> **hash**: (`data`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash data with Keccak-256 using native implementation
###### Parameters
###### data
`Uint8Array`
Data to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashHex()
> **hashHex**: (`hex`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash hex string with Keccak-256 using native implementation
###### Parameters
###### hex
`string`
Hex string to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashString()
> **hashString**: (`str`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash UTF-8 string with Keccak-256 using native implementation
###### Parameters
###### str
`string`
String to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashSync()
> **hashSync**: (`data`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Synchronous hash (for backward compatibility)
Throws if native library not loaded
###### Parameters
###### data
`Uint8Array`
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
##### RATE
> **RATE**: `number` = `136`
##### selector()
> **selector**: (`signature`) => `Promise`\<`string`>
Compute function selector (first 4 bytes of keccak256)
###### Parameters
###### signature
`string`
Function signature (e.g., "transfer(address,uint256)")
###### Returns
`Promise`\<`string`>
First 4 bytes of hash as hex string
##### STATE\_SIZE
> **STATE\_SIZE**: `number` = `200`
##### topic()
> **topic**: (`signature`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Compute event topic hash
###### Parameters
###### signature
`string`
Event signature (e.g., "Transfer(address,address,uint256)")
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte topic hash
***
### Keccak256HashNative
> `const` **Keccak256HashNative**: (`input`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> & `object`
Defined in: [src/crypto/Keccak256/Keccak256.native.ts:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/crypto/Keccak256/Keccak256.native.ts#L134)
Native Keccak256 namespace object
#### Type Declaration
##### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number` = `32`
##### from()
> **from**: (`input`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Universal constructor - accepts hex, string, or bytes
###### Parameters
###### input
Hex string, UTF-8 string, or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### fromHex()
> **fromHex**: (`hex`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> = `hashHex`
Hash hex string with Keccak-256 using native implementation
###### Parameters
###### hex
`string`
Hex string to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### fromString()
> **fromString**: (`str`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)> = `hashString`
Hash UTF-8 string with Keccak-256 using native implementation
###### Parameters
###### str
`string`
String to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hash()
> **hash**: (`data`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash data with Keccak-256 using native implementation
###### Parameters
###### data
`Uint8Array`
Data to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashHex()
> **hashHex**: (`hex`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash hex string with Keccak-256 using native implementation
###### Parameters
###### hex
`string`
Hex string to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashString()
> **hashString**: (`str`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Hash UTF-8 string with Keccak-256 using native implementation
###### Parameters
###### str
`string`
String to hash
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte hash
###### Throws
Error if native operation fails
##### hashSync()
> **hashSync**: (`data`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Synchronous hash (for backward compatibility)
Throws if native library not loaded
###### Parameters
###### data
`Uint8Array`
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
##### RATE
> **RATE**: `number` = `136`
##### selector()
> **selector**: (`signature`) => `Promise`\<`string`>
Compute function selector (first 4 bytes of keccak256)
###### Parameters
###### signature
`string`
Function signature (e.g., "transfer(address,uint256)")
###### Returns
`Promise`\<`string`>
First 4 bytes of hash as hex string
##### STATE\_SIZE
> **STATE\_SIZE**: `number` = `200`
##### topic()
> **topic**: (`signature`) => `Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
Compute event topic hash
###### Parameters
###### signature
`string`
Event signature (e.g., "Transfer(address,address,uint256)")
###### Returns
`Promise`\<[`Keccak256Hash`](index/index.mdx#keccak256hash)>
32-byte topic hash
***
### nativeAPI
> `const` **nativeAPI**: `object`
Defined in: [src/native/index.ts:376](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native/index.ts#L376)
Native API object - satisfies VoltaireAPI interface
This ensures compile-time errors if the native API doesn't have all required namespaces.
Note: The actual Keccak256 export is the native async version from Keccak256.native.js,
but we use JS Keccak256 here for type checking since native methods are async.
#### Type Declaration
##### Abi
> **Abi**: *typeof* [`Abi`](primitives/Abi/index.mdx#abi)
##### AccessList
> **AccessList**: `object`
Namespace for AccessList operations
###### AccessList.ADDRESS\_COST
> **ADDRESS\_COST**: `bigint`
Gas cost per address in access list (EIP-2930)
###### AccessList.addressCount()
> **addressCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
###### AccessList.assertValid()
> **assertValid**: (`list`) => `void`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`void`
###### AccessList.COLD\_ACCOUNT\_ACCESS\_COST
> **COLD\_ACCOUNT\_ACCESS\_COST**: `bigint`
Cold account access cost (pre-EIP-2930)
###### AccessList.COLD\_STORAGE\_ACCESS\_COST
> **COLD\_STORAGE\_ACCESS\_COST**: `bigint`
Cold storage access cost (pre-EIP-2930)
###### AccessList.create()
> **create**: () => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.deduplicate()
> **deduplicate**: (`list`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.from()
> **from**: (`value`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`> | readonly [`Item`](primitives/AccessList.mdx#item)\[]
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.gasCost()
> **gasCost**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
###### AccessList.gasSavings()
> **gasSavings**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`bigint`
###### AccessList.hasSavings()
> **hasSavings**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
###### AccessList.includesAddress()
> **includesAddress**: (`list`, `address`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### AccessList.includesStorageKey()
> **includesStorageKey**: (`list`, `address`, `storageKey`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Returns
`boolean`
###### AccessList.is()
> **is**: (`value`) => `value is BrandedAccessList`
###### Parameters
###### value
`unknown`
###### Returns
`value is BrandedAccessList`
###### AccessList.isEmpty()
> **isEmpty**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`boolean`
###### AccessList.isItem()
> **isItem**: (`value`) => `value is Item`
###### Parameters
###### value
`unknown`
###### Returns
`value is Item`
###### AccessList.keysFor()
> **keysFor**: (`list`, `address`) => readonly [`HashType`](index/namespaces/HashType.mdx#hashtype)\[] | `undefined`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### Returns
readonly [`HashType`](index/namespaces/HashType.mdx#hashtype)\[] | `undefined`
###### AccessList.merge()
> **merge**: (...`accessLists`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### accessLists
...[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)\[]
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.STORAGE\_KEY\_COST
> **STORAGE\_KEY\_COST**: `bigint`
Gas cost per storage key in access list (EIP-2930)
###### AccessList.storageKeyCount()
> **storageKeyCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`number`
###### AccessList.toBytes()
> **toBytes**: (`list`) => `Uint8Array`
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Returns
`Uint8Array`
###### AccessList.WARM\_STORAGE\_ACCESS\_COST
> **WARM\_STORAGE\_ACCESS\_COST**: `bigint`
Warm storage access cost (post-EIP-2929)
###### AccessList.withAddress()
> **withAddress**: (`list`, `address`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### AccessList.withStorageKey()
> **withStorageKey**: (`list`, `address`, `storageKey`) => [`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### storageKey
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Returns
[`BrandedAccessList`](primitives/AccessList.mdx#brandedaccesslist)
##### Address
> **Address**: *typeof* [`Address`](primitives/Address.mdx#address)
##### ~~Blake2~~
> **Blake2**: (`input`, `outputLength?`) => [`Blake2Hash`](index/index.mdx#blake2hash) & `object`
###### Type Declaration
###### ~~from()~~
> **from**: (`input`, `outputLength?`) => [`Blake2Hash`](index/index.mdx#blake2hash)
Hash input with BLAKE2b (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto/blake2](https://voltaire.tevm.sh/crypto/blake2) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import { Blake2Hash } from './crypto/Blake2/index.js';
const hash1 = Blake2Hash.from("hello"); // String, 64 bytes
const hash2 = Blake2Hash.from("hello", 32); // String, 32 bytes
const hash3 = Blake2Hash.from(uint8array); // Bytes, 64 bytes
const hash4 = Blake2Hash.from(uint8array, 48); // Bytes, 48 bytes
```
###### ~~fromString()~~
> **fromString**: (`str`, `outputLength?`) => [`Blake2Hash`](index/index.mdx#blake2hash) = `hashString`
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
###### ~~hash()~~
> **hash**: (`data`, `outputLength?`) => [`Blake2Hash`](index/index.mdx#blake2hash)
Hash data with BLAKE2b
###### Parameters
###### data
Input data to hash (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hash(new Uint8Array([1, 2, 3]));
const hash32 = Blake2.hash("hello", 32);
```
###### ~~hashString()~~
> **hashString**: (`str`, `outputLength?`) => [`Blake2Hash`](index/index.mdx#blake2hash)
Hash string with BLAKE2b (convenience function)
###### Parameters
###### str
`string`
Input string to hash
###### outputLength?
`number` = `64`
Output length in bytes (1-64, default 64)
###### Returns
[`Blake2Hash`](index/index.mdx#blake2hash)
BLAKE2b hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If outputLength is invalid
###### Example
```javascript theme={null}
import * as Blake2 from './crypto/Blake2/index.js';
const hash = Blake2.hashString("hello world");
const hash48 = Blake2.hashString("hello world", 48);
```
###### ~~SIZE~~
> **SIZE**: `number`
###### Deprecated
Use Blake2Hash instead
Blake2 alias maintained for backward compatibility
##### Blob
> **Blob**: *typeof* [`Blob`](primitives/Blob.mdx#blob)
##### BloomFilter
> **BloomFilter**: *typeof* [`BloomFilter`](primitives/BloomFilter.mdx#bloomfilter)
##### Bls12381
> **Bls12381**: `object`
Bls12381 main export
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
// Generate keypair
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
// Sign and verify
const message = new TextEncoder().encode('Hello');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
```
###### Bls12381.aggregate()
> **aggregate**: (`signatures`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple BLS signatures into one
The aggregated signature can be verified against an aggregated public key
(when all signers signed the same message) or via batch verification
(when signers signed different messages).
###### Parameters
###### signatures
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G1 signatures (48 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (48 bytes compressed G1)
###### Throws
If aggregation fails or no signatures provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Vote for proposal');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
```
###### Bls12381.aggregatePublicKeys()
> **aggregatePublicKeys**: (`publicKeys`) => `Uint8Array`\<`ArrayBufferLike`>
Aggregate multiple public keys into one
Used when multiple signers sign the same message and you want
to verify against a single aggregated public key.
###### Parameters
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of compressed G2 public keys (96 bytes each)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Aggregated public key (96 bytes compressed G2)
###### Throws
If aggregation fails or no public keys provided
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const aggPubKey = Bls12381.aggregatePublicKeys([pubKey1, pubKey2]);
```
###### Bls12381.aggregateVerify()
> **aggregateVerify**: (`aggregatedSignature`, `message`, `publicKeys`) => `boolean`
Verify an aggregated signature where all signers signed the same message
This is the most common case in Ethereum consensus - multiple validators
sign the same block/attestation.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed by all parties
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys of all signers (48 bytes each)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const message = new TextEncoder().encode('Block attestation');
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const sig1 = Bls12381.sign(message, pk1);
const sig2 = Bls12381.sign(message, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.aggregateVerify(aggSig, message, [pubKey1, pubKey2]);
console.log(isValid); // true
```
###### Bls12381.batchVerify()
> **batchVerify**: (`aggregatedSignature`, `messages`, `publicKeys`) => `boolean`
Verify an aggregated signature where each signer signed a different message
Uses multi-pairing verification: product of e(pk\_i, H(msg\_i)) == e(G1, aggSig)
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### messages
`Uint8Array`\<`ArrayBufferLike`>\[]
Messages that were signed (one per signer)
###### publicKeys
`Uint8Array`\<`ArrayBufferLike`>\[]
Public keys (one per signer, same order as messages)
###### Returns
`boolean`
True if the aggregated signature is valid
###### Throws
If messages and publicKeys have different lengths
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk1 = Bls12381.randomPrivateKey();
const pk2 = Bls12381.randomPrivateKey();
const pubKey1 = Bls12381.derivePublicKey(pk1);
const pubKey2 = Bls12381.derivePublicKey(pk2);
const msg1 = new TextEncoder().encode('Message 1');
const msg2 = new TextEncoder().encode('Message 2');
const sig1 = Bls12381.sign(msg1, pk1);
const sig2 = Bls12381.sign(msg2, pk2);
const aggSig = Bls12381.aggregate([sig1, sig2]);
const isValid = Bls12381.batchVerify(aggSig, [msg1, msg2], [pubKey1, pubKey2]);
console.log(isValid); // true
```
###### Bls12381.derivePublicKey()
> **derivePublicKey**: (`privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Derive a BLS12-381 public key from a private key
Public key = privateKey \* G2\_generator
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
console.log(publicKey.length); // 96
```
###### Bls12381.derivePublicKeyPoint()
> **derivePublicKeyPoint**: (`privateKey`) => [`Bls12381G1PointType`](index/index.mdx#bls12381g1pointtype)
Derive a BLS12-381 public key as a G1 point (uncompressed)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
[`Bls12381G1PointType`](index/index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Throws
If private key is invalid
###### Bls12381.fastAggregateVerify()
> **fastAggregateVerify**: (`aggregatedSignature`, `message`, `aggregatedPublicKey`) => `boolean`
Fast aggregate verify (same message case)
Optimized for the common case where all signers signed the same message.
This is faster than aggregateVerify when you already have the aggregated public key.
###### Parameters
###### aggregatedSignature
`Uint8Array`\<`ArrayBufferLike`>
Aggregated signature (96 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
The message that was signed
###### aggregatedPublicKey
`Uint8Array`\<`ArrayBufferLike`>
Pre-computed aggregated public key (48 bytes)
###### Returns
`boolean`
True if valid
###### Bls12381.Fp
> **Fp**: [`Fp`](crypto/Bls12381/namespaces/Fp.mdx)
###### Bls12381.Fp2
> **Fp2**: [`Fp2`](crypto/Bls12381/namespaces/Fp2.mdx)
###### Bls12381.Fr
> **Fr**: [`Fr`](crypto/Bls12381/namespaces/Fr.mdx)
###### Bls12381.G1
> **G1**: [`G1`](crypto/Bls12381/namespaces/G1.mdx)
###### Bls12381.G2
> **G2**: [`G2`](crypto/Bls12381/namespaces/G2.mdx)
###### Bls12381.isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Check if a private key is valid
A valid private key must be:
* 32 bytes
* Non-zero
* Less than the curve order (Fr modulus)
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key to validate
###### Returns
`boolean`
True if valid
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const pk = Bls12381.randomPrivateKey();
console.log(Bls12381.isValidPrivateKey(pk)); // true
const invalid = new Uint8Array(32); // all zeros
console.log(Bls12381.isValidPrivateKey(invalid)); // false
```
###### Bls12381.Pairing
> **Pairing**: [`Pairing`](crypto/Bls12381/namespaces/Pairing.mdx)
BLS12-381 Pairing Operations
Optimal Ate pairing implementation for BLS12-381.
e: G1 x G2 -> GT
NOTE: Full pairing implementation requires Fp6, Fp12 tower extensions
and Miller loop computation. For production use, the native blst
library should be used via the Zig FFI bindings.
This module provides the interface and simplified implementations
for testing and educational purposes.
###### See
[https://hackmd.io/@benjaminion/bls12-381](https://hackmd.io/@benjaminion/bls12-381) for pairing details
###### Since
0.0.0
###### Bls12381.randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a random BLS12-381 private key
Uses cryptographically secure random number generation.
The key is guaranteed to be valid (non-zero and less than curve order).
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
```
###### Bls12381.sign()
> **sign**: (`message`, `privateKey`) => `Uint8Array`\<`ArrayBufferLike`>
Sign a message using BLS12-381
Uses the Ethereum consensus "short signatures" scheme:
* Signature = privateKey \* H(message) where H maps to G1
* Signatures are 48 bytes (compressed G1 point)
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message to sign
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Signature as compressed G1 point (48 bytes)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const message = new TextEncoder().encode('Hello, Ethereum!');
const signature = Bls12381.sign(message, privateKey);
```
###### Bls12381.signPoint()
> **signPoint**: (`messagePoint`, `privateKey`) => [`Bls12381G2PointType`](index/index.mdx#bls12381g2pointtype)
Sign a pre-hashed message (G2 point) using BLS12-381
For advanced use when you have already hashed the message to G2.
###### Parameters
###### messagePoint
[`Bls12381G2PointType`](index/index.mdx#bls12381g2pointtype)
Message as G2 point
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key (scalar in Fr)
###### Returns
[`Bls12381G2PointType`](index/index.mdx#bls12381g2pointtype)
Signature as G2 point (projective)
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Bls12381.verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify a BLS12-381 signature
Uses pairing check for verification.
###### Parameters
###### signature
`Uint8Array`\<`ArrayBufferLike`>
Compressed G1 signature (48 bytes)
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message that was signed
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
Compressed G2 public key (96 bytes)
###### Returns
`boolean`
True if signature is valid
###### Throws
If verification fails due to invalid inputs
###### Example
```javascript theme={null}
import { Bls12381 } from './crypto/Bls12381/index.js';
const privateKey = Bls12381.randomPrivateKey();
const publicKey = Bls12381.derivePublicKey(privateKey);
const message = new TextEncoder().encode('Hello!');
const signature = Bls12381.sign(message, privateKey);
const isValid = Bls12381.verify(signature, message, publicKey);
console.log(isValid); // true
```
###### Bls12381.verifyPoint()
> **verifyPoint**: (`signaturePoint`, `messagePoint`, `publicKeyPoint`) => `boolean`
Verify a BLS signature with pre-computed points (advanced)
For use when you have already deserialized the points.
###### Parameters
###### signaturePoint
[`Bls12381G2PointType`](index/index.mdx#bls12381g2pointtype)
Signature as G2 point
###### messagePoint
[`Bls12381G2PointType`](index/index.mdx#bls12381g2pointtype)
Message hash as G2 point
###### publicKeyPoint
[`Bls12381G1PointType`](index/index.mdx#bls12381g1pointtype)
Public key as G1 point
###### Returns
`boolean`
True if signature is valid
##### BN254
> **BN254**: `object`
BN254 main export
###### BN254.deserializeG1()
> **deserializeG1**: (`bytes`) => `G1PointType`
Deserialize G1 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### Returns
`G1PointType`
G1 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 64 bytes)
###### Example
```javascript theme={null}
import { deserializeG1 } from './crypto/bn254/deserializeG1.js';
const bytes = new Uint8Array(64);
const point = deserializeG1(bytes);
```
###### BN254.deserializeG2()
> **deserializeG2**: (`bytes`) => `G2PointType`
Deserialize G2 point from bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### Returns
`G2PointType`
G2 point
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
If bytes length is invalid (must be 128 bytes)
###### Example
```javascript theme={null}
import { deserializeG2 } from './crypto/bn254/deserializeG2.js';
const bytes = new Uint8Array(128);
const point = deserializeG2(bytes);
```
###### BN254.Fp
> **Fp**: `__module`
###### BN254.Fp2
> **Fp2**: `__module`
###### BN254.Fr
> **Fr**: `__module`
###### BN254.G1
> **G1**: `__module`
###### BN254.G2
> **G2**: `__module`
###### BN254.Pairing
> **Pairing**: `__module`
###### BN254.serializeG1()
> **serializeG1**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G1 point to bytes (64 bytes: x || y)
###### Parameters
###### point
`G1PointType`
G1 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG1 } from './crypto/bn254/serializeG1.js';
import * as G1 from './crypto/bn254/G1/index.js';
const point = G1.generator();
const bytes = serializeG1(point);
```
###### BN254.serializeG2()
> **serializeG2**: (`point`) => `Uint8Array`\<`ArrayBufferLike`>
Serialize G2 point to bytes (128 bytes: x.c0 || x.c1 || y.c0 || y.c1)
###### Parameters
###### point
`G2PointType`
G2 point
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
128-byte serialization
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for BN254 cryptography documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { serializeG2 } from './crypto/bn254/serializeG2.js';
import * as G2 from './crypto/bn254/G2/index.js';
const point = G2.generator();
const bytes = serializeG2(point);
```
##### Bytecode
> **Bytecode**: *typeof* [`Bytecode`](primitives/Bytecode.mdx#bytecode)
##### Bytes
> **Bytes**: *typeof* [`Bytes`](index/index.mdx#bytes)
##### Bytes32
> **Bytes32**: *typeof* [`Bytes32`](index/namespaces/BrandedBytes32.mdx#bytes32)
##### Chain
> **Chain**: *typeof* [`Chain`](index/namespaces/BrandedChain.mdx#chain-1)
##### Ed25519
> **Ed25519**: `object`
Ed25519 Digital Signature Algorithm
Edwards-curve Digital Signature Algorithm (EdDSA) using Curve25519.
Fast, secure, and deterministic signatures without requiring a hash function.
Used in many modern protocols including SSH, TLS 1.3, and cryptocurrency.
###### Example
```typescript theme={null}
import { Ed25519 } from './Ed25519/index.js';
// Generate keypair from seed
const seed = new Uint8Array(32); // Random seed
const keypair = Ed25519.keypairFromSeed(seed);
// Sign a message
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, keypair.secretKey);
// Verify signature
const valid = Ed25519.verify(signature, message, keypair.publicKey);
```
###### Ed25519.derivePublicKey()
> **derivePublicKey**: (`secretKey`) => `PublicKey`
Derive Ed25519 public key from secret key.
###### Parameters
###### secretKey
`SecretKey`
32-byte Ed25519 secret key (seed)
###### Returns
`PublicKey`
32-byte Ed25519 public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is invalid or derivation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const secretKey = new Uint8Array(32); // Your secret key
const publicKey = Ed25519.derivePublicKey(secretKey);
```
###### Ed25519.keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate Ed25519 keypair from seed deterministically.
###### Parameters
###### seed
`Seed`
32-byte seed for deterministic keypair generation
###### Returns
`object`
Object containing 32-byte secretKey and 32-byte publicKey
###### publicKey
> **publicKey**: `PublicKey`
###### secretKey
> **secretKey**: `SecretKey`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is not 32 bytes
###### Throws
If keypair generation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = Ed25519.keypairFromSeed(seed);
console.log(keypair.publicKey); // Uint8Array(32)
```
###### Ed25519.PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Ed25519 public key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Ed25519/constants.js';
const publicKey = new Uint8Array(PUBLIC_KEY_SIZE);
```
###### Ed25519.SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Ed25519 secret key size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/Ed25519/constants.js';
const secretKey = new Uint8Array(SECRET_KEY_SIZE);
```
###### Ed25519.SEED\_SIZE
> **SEED\_SIZE**: `32`
Ed25519 seed size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SEED_SIZE } from './crypto/Ed25519/constants.js';
const seed = crypto.getRandomValues(new Uint8Array(SEED_SIZE));
```
###### Ed25519.sign()
> **sign**: (`message`, `secretKey`) => `Signature`
Sign message with Ed25519 secret key.
Produces deterministic signatures using EdDSA.
###### Parameters
###### message
`Uint8Array`\<`ArrayBufferLike`>
Message bytes to sign (any length)
###### secretKey
`SecretKey`
32-byte Ed25519 secret key
###### Returns
`Signature`
64-byte Ed25519 signature
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key length is not 32 bytes
###### Throws
If signing operation fails
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const message = new TextEncoder().encode('Hello, world!');
const signature = Ed25519.sign(message, secretKey);
```
###### Ed25519.SIGNATURE\_SIZE
> **SIGNATURE\_SIZE**: `64`
Ed25519 signature size in bytes.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIGNATURE_SIZE } from './crypto/Ed25519/constants.js';
const signature = new Uint8Array(SIGNATURE_SIZE);
```
###### Ed25519.validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate Ed25519 public key format and curve membership.
###### Parameters
###### publicKey
`PublicKey`
Ed25519 public key to validate
###### Returns
`boolean`
True if public key is valid and on curve, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validatePublicKey(publicKey);
if (!isValid) console.log('Invalid public key');
```
###### Ed25519.validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate Ed25519 secret key format.
Checks length and attempts public key derivation.
###### Parameters
###### secretKey
`SecretKey`
Ed25519 secret key to validate
###### Returns
`boolean`
True if secret key is valid (32 bytes and can derive public key), false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const isValid = Ed25519.validateSecretKey(secretKey);
if (!isValid) console.log('Invalid secret key');
```
###### Ed25519.validateSeed()
> **validateSeed**: (`seed`) => `boolean`
Validate Ed25519 seed format.
Checks if seed has correct 32-byte length.
###### Parameters
###### seed
`Seed`
Ed25519 seed to validate
###### Returns
`boolean`
True if seed is exactly 32 bytes, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const isValid = Ed25519.validateSeed(seed); // true
```
###### Ed25519.verify()
> **verify**: (`signature`, `message`, `publicKey`) => `boolean`
Verify Ed25519 signature.
Returns false on verification failure instead of throwing.
###### Parameters
###### signature
`Signature`
64-byte Ed25519 signature to verify
###### message
`Uint8Array`\<`ArrayBufferLike`>
Original message bytes that were signed
###### publicKey
`PublicKey`
32-byte Ed25519 public key
###### Returns
`boolean`
True if signature is cryptographically valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If public key length is not 32 bytes
###### Throws
If signature length is not 64 bytes
###### Example
```javascript theme={null}
import * as Ed25519 from './crypto/Ed25519/index.js';
const valid = Ed25519.verify(signature, message, publicKey);
if (valid) console.log('Signature verified');
```
##### EIP712
> **EIP712**: `object`
EIP-712 Typed Data Signing
Complete implementation of EIP-712 typed structured data hashing and signing.
###### Example
```typescript theme={null}
import { EIP712 } from './EIP712.js';
// Define typed data
const typedData = {
domain: {
name: 'MyApp',
version: '1',
chainId: 1n,
verifyingContract: contractAddress,
},
types: {
Person: [
{ name: 'name', type: 'string' },
{ name: 'wallet', type: 'address' },
],
Mail: [
{ name: 'from', type: 'Person' },
{ name: 'to', type: 'Person' },
{ name: 'contents', type: 'string' },
],
},
primaryType: 'Mail',
message: {
from: { name: 'Alice', wallet: '0x...' },
to: { name: 'Bob', wallet: '0x...' },
contents: 'Hello!',
},
};
// Hash typed data
const hash = EIP712.hashTypedData(typedData);
// Sign typed data
const signature = EIP712.signTypedData(typedData, privateKey);
// Verify signature
const valid = EIP712.verifyTypedData(signature, typedData, address);
```
###### EIP712.Domain
> **Domain**: `object`
###### EIP712.Domain.hash()
> **hash**: (`domain`) => [`HashType`](index/namespaces/HashType.mdx#hashtype) = `hashDomain`
###### Parameters
###### domain
[`Domain`](crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### EIP712.encodeData()
> **encodeData**: (`primaryType`, `data`, `types`) => `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### EIP712.EncodeData()
> **EncodeData**: (`deps`) => (`primaryType`, `data`, `types`) => `Uint8Array`
Factory: Encode struct data according to EIP-712.
###### Parameters
###### deps
Crypto dependencies
###### encodeValue
(`type`, `value`, `types`) => `Uint8Array`
Encode value function
###### hashType
(`primaryType`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash type function
###### Returns
Function that encodes data
> (`primaryType`, `data`, `types`): `Uint8Array`
###### Parameters
###### primaryType
`string`
###### data
[`Message`](crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType is not found in types
###### Throws
If required field is missing from data
###### Example
```javascript theme={null}
import { EncodeData } from './crypto/EIP712/encodeData.js';
import { HashType } from './hashType.js';
import { EncodeValue } from './encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encodeData = EncodeData({ hashType, encodeValue });
const types = { Person: [{ name: 'name', type: 'string' }, { name: 'wallet', type: 'address' }] };
const encoded = encodeData('Person', { name: 'Alice', wallet: '0x...' }, types);
```
###### EIP712.encodeType()
> **encodeType**: (`primaryType`, `types`) => `string`
Encode type string for EIP-712 hashing.
Produces type encoding like "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
###### Parameters
###### primaryType
`string`
Primary type name to encode
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
Type definitions mapping
###### Returns
`string`
Encoded type string with primary type followed by referenced types in alphabetical order
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If primaryType or any referenced type is not found
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const types = { Mail: [{ name: 'from', type: 'Person' }], Person: [{ name: 'name', type: 'string' }] };
const typeString = EIP712.encodeType('Mail', types);
// Returns: "Mail(Person from)Person(string name)"
```
###### EIP712.encodeValue()
> **encodeValue**: (`type`, `value`, `types`) => `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### EIP712.EncodeValue()
> **EncodeValue**: (`deps`) => (`type`, `value`, `types`) => `Uint8Array`
Factory: Encode single value to 32 bytes according to EIP-712.
Handles primitive types, arrays, strings, bytes, and custom structs.
Addresses must be pre-validated BrandedAddress types.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`type`, `data`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that encodes value
> (`type`, `value`, `types`): `Uint8Array`
###### Parameters
###### type
`string`
###### value
[`MessageValue`](crypto/EIP712.mdx#messagevalue)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is unsupported or value format is invalid
###### Example
```javascript theme={null}
import { EncodeValue } from './crypto/EIP712/encodeValue.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { HashStruct } from './hashStruct.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const encodeValue = EncodeValue({ keccak256, hashStruct });
const encoded = encodeValue('uint256', 42n, types);
```
###### EIP712.format()
> **format**: (`typedData`) => `string`
Format typed data for human-readable display.
###### Parameters
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
Typed data to format
###### Returns
`string`
Human-readable multi-line string representation
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
const formatted = EIP712.format(typedData);
console.log(formatted);
```
###### EIP712.HashDomain()
> **HashDomain**: (`deps`) => (`domain`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Factory: Hash EIP-712 domain separator.
Only includes fields that are defined in the domain object.
###### Parameters
###### deps
Crypto dependencies
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### Returns
Function that hashes domain
> (`domain`): [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### domain
[`Domain`](crypto/EIP712.mdx#domain)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If domain type encoding fails
###### Example
```javascript theme={null}
import { Hash as HashDomain } from './crypto/EIP712/Domain/hash.js';
import { HashStruct } from '../hashStruct.js';
import { hash as keccak256 } from '../../Keccak256/hash.js';
const hashStruct = HashStruct({ keccak256, encodeData });
const hashDomain = HashDomain({ hashStruct });
const domain = { name: 'MyApp', version: '1', chainId: 1n };
const domainHash = hashDomain(domain);
```
###### EIP712.hashStruct()
> **hashStruct**: (`primaryType`, `data`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### EIP712.HashStruct()
> **HashStruct**: (`deps`) => (`primaryType`, `data`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Factory: Hash struct according to EIP-712 specification.
Computes keccak256 of the encoded struct data.
###### Parameters
###### deps
Crypto dependencies
###### encodeData
(`primaryType`, `data`, `types`) => `Uint8Array`
Encode data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes struct
> (`primaryType`, `data`, `types`): [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### data
[`Message`](crypto/EIP712.mdx#message)
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashStruct } from './crypto/EIP712/hashStruct.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { EncodeData } from './encodeData.js';
const encodeData = EncodeData({ hashType, encodeValue });
const hashStruct = HashStruct({ keccak256, encodeData });
const types = { Person: [{ name: 'name', type: 'string' }] };
const hash = hashStruct('Person', { name: 'Alice' }, types);
```
###### EIP712.hashType()
> **hashType**: (`primaryType`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### EIP712.HashType()
> **HashType**: (`deps`) => (`primaryType`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Factory: Hash type string according to EIP-712.
Computes keccak256 of the encoded type string.
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes type string
> (`primaryType`, `types`): [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### primaryType
`string`
###### types
[`TypeDefinitions`](crypto/EIP712.mdx#typedefinitions)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If type is not found
###### Example
```javascript theme={null}
import { HashType } from './crypto/EIP712/hashType.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashType = HashType({ keccak256 });
const types = { Mail: [{ name: 'contents', type: 'string' }] };
const typeHash = hashType('Mail', types);
```
###### EIP712.hashTypedData()
> **hashTypedData**: (`typedData`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### EIP712.HashTypedData()
> **HashTypedData**: (`deps`) => (`typedData`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Factory: Hash typed data according to EIP-712 specification.
Computes: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))
###### Parameters
###### deps
Crypto dependencies
###### hashDomain
(`domain`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash domain function
###### hashStruct
(`primaryType`, `data`, `types`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash struct function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### Returns
Function that hashes typed data
> (`typedData`): [`HashType`](index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### Returns
[`HashType`](index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If types are not found
###### Throws
If message data is invalid
###### Example
```javascript theme={null}
import { HashTypedData } from './crypto/EIP712/hashTypedData.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { Hash as HashDomain } from './Domain/hash.js';
import { HashStruct } from './hashStruct.js';
const hashDomain = HashDomain({ hashStruct });
const hashStruct = HashStruct({ keccak256, encodeData });
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const hash = hashTypedData(typedData);
```
###### EIP712.recoverAddress()
> **recoverAddress**: (`signature`, `typedData`) => [`AddressType`](primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](primitives/Address.mdx#addresstype)
###### EIP712.RecoverAddress()
> **RecoverAddress**: (`deps`) => (`signature`, `typedData`) => [`AddressType`](primitives/Address.mdx#addresstype)
Factory: Recover Ethereum address from EIP-712 typed data signature.
Uses ECDSA public key recovery to determine the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `hash`, `recoveryBit`) => `Uint8Array`
Secp256k1 public key recovery function
###### Returns
Function that recovers address
> (`signature`, `typedData`): [`AddressType`](primitives/Address.mdx#addresstype)
###### Parameters
###### signature
[`Signature`](crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### Returns
[`AddressType`](primitives/Address.mdx#addresstype)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature recovery fails or public key format is invalid
###### Example
```javascript theme={null}
import { RecoverAddress } from './crypto/EIP712/recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
import { HashTypedData } from './hashTypedData.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const address = recoverAddress(signature, typedData);
```
###### EIP712.signTypedData()
> **signTypedData**: (`typedData`, `privateKey`) => [`Signature`](crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
`any`
###### privateKey
`any`
###### Returns
[`Signature`](crypto/EIP712.mdx#signature)
###### EIP712.SignTypedData()
> **SignTypedData**: (`deps`) => (`typedData`, `privateKey`) => [`Signature`](crypto/EIP712.mdx#signature)
Factory: Sign EIP-712 typed data with ECDSA private key.
Produces a signature that can be verified against the signer's address.
###### Parameters
###### deps
Crypto dependencies
###### hashTypedData
(`typedData`) => [`HashType`](index/namespaces/HashType.mdx#hashtype)
Hash typed data function
###### sign
(`hash`, `privateKey`) => [`Signature`](crypto/EIP712.mdx#signature)
Secp256k1 sign function
###### Returns
Function that signs typed data
> (`typedData`, `privateKey`): [`Signature`](crypto/EIP712.mdx#signature)
###### Parameters
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### privateKey
`Uint8Array`
###### Returns
[`Signature`](crypto/EIP712.mdx#signature)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key length is invalid or signing fails
###### Example
```javascript theme={null}
import { SignTypedData } from './crypto/EIP712/signTypedData.js';
import { HashTypedData } from './hashTypedData.js';
import { sign } from '../Secp256k1/sign.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
const hashTypedData = HashTypedData({ keccak256, hashDomain, hashStruct });
const signTypedData = SignTypedData({ hashTypedData, sign });
const privateKey = new Uint8Array(32);
const signature = signTypedData(typedData, privateKey);
```
###### EIP712.validate()
> **validate**: (`typedData`) => `void`
Validate typed data structure against EIP-712 specification.
Checks domain, types, primaryType, and message structure.
###### Parameters
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
Typed data to validate
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If structure is invalid or missing required fields
###### Example
```javascript theme={null}
import * as EIP712 from './crypto/EIP712/index.js';
EIP712.validate(typedData); // Throws if invalid
```
###### EIP712.verifyTypedData()
> **verifyTypedData**: (`signature`, `typedData`, `address`) => `boolean`
###### Parameters
###### signature
[`Signature`](crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### EIP712.VerifyTypedData()
> **VerifyTypedData**: (`deps`) => (`signature`, `typedData`, `address`) => `boolean`
Factory: Verify EIP-712 typed data signature against expected signer address.
Uses constant-time comparison to prevent timing attacks.
###### Parameters
###### deps
Crypto dependencies
###### recoverAddress
(`signature`, `typedData`) => [`AddressType`](primitives/Address.mdx#addresstype)
Recover address function
###### Returns
Function that verifies signature
> (`signature`, `typedData`, `address`): `boolean`
###### Parameters
###### signature
[`Signature`](crypto/EIP712.mdx#signature)
###### typedData
[`TypedData`](crypto/EIP712.mdx#typeddata)
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### Returns
`boolean`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { VerifyTypedData } from './crypto/EIP712/verifyTypedData.js';
import { RecoverAddress } from './recoverAddress.js';
import { hash as keccak256 } from '../Keccak256/hash.js';
import { recoverPublicKey } from '../Secp256k1/recoverPublicKey.js';
const recoverAddress = RecoverAddress({ keccak256, recoverPublicKey, hashTypedData });
const verifyTypedData = VerifyTypedData({ recoverAddress });
const valid = verifyTypedData(signature, typedData, signerAddress);
```
##### Ether
> **Ether**: `EtherConstructor`
##### Gwei
> **Gwei**: `GweiConstructor`
##### Hash
> **Hash**: `HashConstructor`
##### Hex
> **Hex**: *typeof* [`Hex`](index/index.mdx#hex)
##### Keccak256
> **Keccak256**: (`input`) => [`Keccak256Hash`](index/index.mdx#keccak256hash) & `object` = `Keccak256JS`
###### Type Declaration
###### contractAddress()
> **contractAddress**: (`sender`, `nonce`) => `Uint8Array`\<`ArrayBufferLike`>
Compute contract address from deployer and nonce
Uses CREATE formula: keccak256(rlp(\[sender, nonce]))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### nonce
`bigint`
Transaction nonce
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const address = Keccak256.contractAddress(sender, 0n);
```
###### create2Address()
> **create2Address**: (`sender`, `salt`, `initCodeHash`) => `Uint8Array`\<`ArrayBufferLike`>
Compute CREATE2 address
Uses CREATE2 formula: keccak256(0xff ++ sender ++ salt ++ keccak256(init\_code))\[12:]
###### Parameters
###### sender
`Uint8Array`\<`ArrayBufferLike`>
Deployer address (20 bytes)
###### salt
`Uint8Array`\<`ArrayBufferLike`>
32-byte salt
###### initCodeHash
`Uint8Array`\<`ArrayBufferLike`>
Hash of initialization code
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Contract address (20 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If sender is not 20 bytes
###### Throws
If salt is not 32 bytes
###### Throws
If initCodeHash is not 32 bytes
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const sender = new Uint8Array(20);
const salt = new Uint8Array(32);
const initCodeHash = new Uint8Array(32);
const address = Keccak256.create2Address(sender, salt, initCodeHash);
```
###### DIGEST\_SIZE
> **DIGEST\_SIZE**: `number`
Digest size in bytes (32 bytes = 256 bits)
###### Since
0.0.0
###### from()
> **from**: (`input`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Hash input with Keccak-256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/keccak256](https://voltaire.tevm.sh/crypto/keccak256) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash1 = Keccak256Hash.from("0x1234"); // Hex
const hash2 = Keccak256Hash.from("hello"); // String
const hash3 = Keccak256Hash.from(uint8array); // Bytes
```
###### fromHex()
> **fromHex**: (`hex`) => [`Keccak256Hash`](index/index.mdx#keccak256hash) = `hashHex`
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
###### fromString()
> **fromString**: (`str`) => [`Keccak256Hash`](index/index.mdx#keccak256hash) = `hashString`
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
###### fromTopic()
> **fromTopic**: (`signature`) => [`Keccak256Hash`](index/index.mdx#keccak256hash) = `topic`
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
###### hash()
> **hash**: (`data`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Hash data with Keccak-256
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Data to hash
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(data);
```
###### hashHex()
> **hashHex**: (`hex`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Hash hex string with Keccak-256
###### Parameters
###### hex
`string`
Hex string to hash (with or without 0x prefix)
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or has odd length
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromHex('0x1234abcd');
```
###### hashMultiple()
> **hashMultiple**: (`chunks`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Hash multiple data chunks in sequence
Equivalent to hashing the concatenation of all chunks.
###### Parameters
###### chunks
readonly `Uint8Array`\<`ArrayBufferLike`>\[]
Array of data chunks to hash
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.from(combined);
```
###### hashString()
> **hashString**: (`str`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Hash string with Keccak-256
String is UTF-8 encoded before hashing.
###### Parameters
###### str
`string`
String to hash
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const hash = Keccak256Hash.fromString('hello');
```
###### RATE
> **RATE**: `number`
Rate in bytes for Keccak256 (136 bytes = 1088 bits)
###### Since
0.0.0
###### selector()
> **selector**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Compute function selector (first 4 bytes of Keccak-256 hash)
Used for Ethereum function signatures.
###### Parameters
###### signature
`string`
Function signature string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte selector
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Keccak256 from './crypto/Keccak256/index.js';
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
```
###### STATE\_SIZE
> **STATE\_SIZE**: `number`
State size (25 u64 words = 1600 bits)
###### Since
0.0.0
###### topic()
> **topic**: (`signature`) => [`Keccak256Hash`](index/index.mdx#keccak256hash)
Compute event topic (32-byte Keccak-256 hash)
Used for Ethereum event signatures.
###### Parameters
###### signature
`string`
Event signature string
###### Returns
[`Keccak256Hash`](index/index.mdx#keccak256hash)
32-byte topic
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Keccak256Hash } from './crypto/Keccak256/index.js';
const topic = Keccak256Hash.fromTopic('Transfer(address,address,uint256)');
```
##### KZG
> **KZG**: *typeof* [`KZG`](index/index.mdx#kzg)
##### ModExp
> **ModExp**: (`base`, `exp`, `modulus`) => `bigint` & `object`
ModExp - Modular Exponentiation
Computes base^exp mod modulus for arbitrary-precision integers.
Used by MODEXP precompile (0x05) per EIP-198/EIP-2565.
###### Type Declaration
###### calculateGas()
> **calculateGas**: (`baseLen`, `expLen`, `modLen`, `expHead`) => `bigint`
Calculate gas cost for MODEXP operation per EIP-2565
Gas formula: max(200, floor(mult\_complexity \* iteration\_count / 3))
###### Parameters
###### baseLen
`bigint`
Length of base in bytes
###### expLen
`bigint`
Length of exponent in bytes
###### modLen
`bigint`
Length of modulus in bytes
###### expHead
`bigint`
First 32 bytes of exponent as BigInt (for leading zeros calc)
###### Returns
`bigint`
Gas cost
###### See
[https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Calculate gas for 2^3 mod 5
const gas = ModExp.calculateGas(1n, 1n, 1n, 3n);
console.log(gas); // 200n (minimum)
```
###### modexp()
> **modexp**: (`base`, `exp`, `modulus`) => `bigint`
Modular exponentiation: base^exp mod modulus
Computes arbitrary-precision modular exponentiation using native BigInt.
Used by MODEXP precompile (0x05) per EIP-198.
WARNING: This implementation is for general use. For cryptographic
applications, consider timing attack resistance.
###### Parameters
###### base
`bigint`
Base value
###### exp
`bigint`
Exponent value
###### modulus
`bigint`
Modulus value (must be > 0)
###### Returns
`bigint`
Result of base^exp mod modulus
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Compute 2^10 mod 1000 = 24
const result = ModExp.modexp(2n, 10n, 1000n);
console.log(result); // 24n
// RSA verification: signature^e mod n
const verified = ModExp.modexp(signature, e, n);
```
###### modexpBytes()
> **modexpBytes**: (`baseBytes`, `expBytes`, `modBytes`) => `Uint8Array`\<`ArrayBufferLike`>
Modular exponentiation with byte array inputs/outputs
Computes base^exp mod modulus where inputs are big-endian byte arrays.
Output is padded to modulus length per EIP-198 spec.
###### Parameters
###### baseBytes
`Uint8Array`\<`ArrayBufferLike`>
Base as big-endian bytes
###### expBytes
`Uint8Array`\<`ArrayBufferLike`>
Exponent as big-endian bytes
###### modBytes
`Uint8Array`\<`ArrayBufferLike`>
Modulus as big-endian bytes
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Result as big-endian bytes, padded to modulus length
###### See
[https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198)
###### Since
0.0.0
###### Throws
If modulus is zero
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
const base = new Uint8Array([0x02]); // 2
const exp = new Uint8Array([0x03]); // 3
const mod = new Uint8Array([0x05]); // 5
const result = ModExp.modexpBytes(base, exp, mod);
console.log(result); // Uint8Array([0x03]) = 3
```
###### See
* [https://eips.ethereum.org/EIPS/eip-198](https://eips.ethereum.org/EIPS/eip-198) - ModExp precompile
* [https://eips.ethereum.org/EIPS/eip-2565](https://eips.ethereum.org/EIPS/eip-2565) - Gas cost repricing
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ModExp } from './crypto/ModExp/index.js';
// Using BigInt directly
const result = ModExp.modexp(2n, 10n, 1000n); // 24n
// Using byte arrays (EIP-198 format)
const base = new Uint8Array([0x02]);
const exp = new Uint8Array([0x0a]);
const mod = new Uint8Array([0x03, 0xe8]);
const resultBytes = ModExp.modexpBytes(base, exp, mod);
// Calculate gas cost
const gas = ModExp.calculateGas(1n, 1n, 2n, 10n);
```
##### Opcode
> **Opcode**: *typeof* [`Opcode`](index/index.mdx#opcode)
##### P256
> **P256**: [`P256Constructor`](crypto/P256.mdx#p256constructor)
P256 namespace with cryptographic operations
##### ~~Ripemd160~~
> **Ripemd160**: (`input`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash) & `object`
###### Type Declaration
###### ~~from()~~
> **from**: (`input`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash)
Hash input with RIPEMD160 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto/ripemd160](https://voltaire.tevm.sh/crypto/ripemd160) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160Hash } from './crypto/Ripemd160/index.js';
const hash1 = Ripemd160Hash.from("hello"); // String
const hash2 = Ripemd160Hash.from(uint8array); // Bytes
```
###### ~~fromHex()~~
> **fromHex**: (`hex`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash) = `hashHex`
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
###### ~~fromString()~~
> **fromString**: (`str`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash) = `hashString`
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
###### ~~hash()~~
> **hash**: (`data`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash (20 bytes)
###### Parameters
###### data
Input data (Uint8Array or string)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hash(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 20
```
###### ~~hashHex()~~
> **hashHex**: (`hex`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashHex("0xdeadbeef");
console.log(hash.length); // 20
```
###### ~~hashString()~~
> **hashString**: (`str`) => [`Ripemd160Hash`](index/index.mdx#ripemd160hash)
Compute RIPEMD160 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`Ripemd160Hash`](index/index.mdx#ripemd160hash)
20-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Ripemd160 } from './crypto/Ripemd160/index.js';
const hash = Ripemd160.hashString("hello");
console.log(hash.length); // 20
```
###### ~~HEX\_SIZE~~
> **HEX\_SIZE**: `number`
Size of RIPEMD160 hash in hex characters (without 0x prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { HEX_SIZE } from './crypto/Ripemd160/index.js';
console.log(HEX_SIZE); // 40
```
###### ~~SIZE~~
> **SIZE**: `number`
Size of RIPEMD160 hash in bytes (160 bits)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIZE } from './crypto/Ripemd160/index.js';
console.log(SIZE); // 20
```
###### Deprecated
Use Ripemd160Hash instead
Ripemd160 alias maintained for backward compatibility
##### Rlp
> **Rlp**: *typeof* [`Rlp`](primitives/Rlp.mdx#rlp)
##### Secp256k1
> **Secp256k1**: `object`
secp256k1/ECDSA Cryptography namespace
Complete ECDSA signing and verification using the secp256k1 elliptic curve.
All operations use the audited @noble/curves library for security.
Full Ethereum compatibility with v = 27/28 recovery IDs.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Sign a message hash
const messageHash = Hash.keccak256String('Hello, Ethereum!');
const privateKey = new Uint8Array(32);
const signature = Secp256k1.sign(messageHash, privateKey);
// Verify signature
const publicKey = Secp256k1.derivePublicKey(privateKey);
const valid = Secp256k1.verify(signature, messageHash, publicKey);
// Recover public key from signature
const recovered = Secp256k1.recoverPublicKey(signature, messageHash);
// Hash-level API for interop with other libraries
const hash = Hash.keccak256String('Hello');
const hashSig = Secp256k1.signHash(hash, privateKey);
const hashValid = Secp256k1.verifyHash(hashSig, hash, publicKey);
```
###### Secp256k1.addPoints()
> **addPoints**: (`pubKey1`, `pubKey2`) => [`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Add two secp256k1 public key points
Performs elliptic curve point addition: P1 + P2.
Used in ERC-5564 stealth address generation.
###### Parameters
###### pubKey1
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
First 64-byte uncompressed public key
###### pubKey2
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Second 64-byte uncompressed public key
###### Returns
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If either public key is invalid
###### Throws
If point addition fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const pubKey1 = Secp256k1.derivePublicKey(privateKey1);
const pubKey2 = Secp256k1.derivePublicKey(privateKey2);
const sum = Secp256k1.addPoints(pubKey1, pubKey2);
console.log(sum.length); // 64
```
###### Secp256k1.createKeyPair()
> **createKeyPair**: () => `object`
Generate a new secp256k1 key pair
###### Returns
`object`
Key pair with 32-byte private key and 65-byte uncompressed public key
###### privateKey
> **privateKey**: `Uint8Array`
###### publicKey
> **publicKey**: `Uint8Array`
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const { privateKey, publicKey } = Secp256k1.createKeyPair();
```
###### Secp256k1.CURVE\_ORDER
> **CURVE\_ORDER**: `bigint`
secp256k1 curve order (number of points on the curve)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { CURVE_ORDER } from './crypto/Secp256k1/index.js';
console.log(CURVE_ORDER); // 0xffffffffffff...
```
###### Secp256k1.derivePublicKey()
> **derivePublicKey**: (`privateKey`) => [`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Derive public key from private key
Computes the public key point from a private key using scalar
multiplication on the secp256k1 curve.
###### Parameters
###### privateKey
[`PrivateKeyType`](primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const privateKey = PrivateKey.from(new Uint8Array(32));
const publicKey = Secp256k1.derivePublicKey(privateKey);
console.log(publicKey.length); // 64
```
###### Secp256k1.ecdh()
> **ecdh**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`>
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
###### Secp256k1.getSharedSecret()
> **getSharedSecret**: (`privateKey`, `publicKey`) => `Uint8Array`\<`ArrayBufferLike`> = `ecdh`
Perform ECDH key exchange
Computes shared secret from your private key and their public key.
Returns the x-coordinate of the shared point (32 bytes).
###### Parameters
###### privateKey
[`PrivateKeyType`](primitives/PrivateKey.mdx#privatekeytype)
Your 32-byte private key
###### publicKey
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Their 64-byte uncompressed public key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte shared secret (x-coordinate)
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If public key is invalid
###### Throws
If ECDH computation fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const myPrivateKey = new Uint8Array(32);
const theirPublicKey = Secp256k1.derivePublicKey(theirPrivateKey);
const sharedSecret = Secp256k1.ecdh(myPrivateKey, theirPublicKey);
console.log(sharedSecret.length); // 32
```
###### Secp256k1.isValidPrivateKey()
> **isValidPrivateKey**: (`privateKey`) => `boolean`
Validate private key
Checks that the private key is within valid range \[1, n-1] where n
is the curve order.
###### Parameters
###### privateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Returns
`boolean`
true if private key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const privateKey = new Uint8Array(32);
const valid = Secp256k1.isValidPrivateKey(privateKey);
```
###### Secp256k1.isValidPublicKey()
> **isValidPublicKey**: (`publicKey`) => `publicKey is Secp256k1PublicKeyType`
Validate public key
Checks that the public key is a valid point on the secp256k1 curve.
###### Parameters
###### publicKey
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
###### Returns
`publicKey is Secp256k1PublicKeyType`
true if public key is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const publicKey = new Uint8Array(64);
if (Secp256k1.isValidPublicKey(publicKey)) {
const branded = publicKey; // now Secp256k1PublicKeyType
}
```
###### Secp256k1.isValidSignature()
> **isValidSignature**: (`signature`) => `boolean`
Validate signature components
Checks that r and s are within valid range \[1, n-1] where n is the
curve order. Also enforces low-s values to prevent malleability.
###### Parameters
###### signature
[`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature to validate (r and s are HashType)
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const signature = { r: Hash.from(new Uint8Array(32)), s: Hash.from(new Uint8Array(32)), v: 27 };
const valid = Secp256k1.isValidSignature(signature);
```
###### Secp256k1.PRIVATE\_KEY\_SIZE
> **PRIVATE\_KEY\_SIZE**: `number`
Private key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PRIVATE_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PRIVATE_KEY_SIZE); // 32
```
###### Secp256k1.PrivateKey
> **PrivateKey**: `__module` = `PrivateKeyMethods`
###### Secp256k1.PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `number`
Uncompressed public key size in bytes (64 bytes, no prefix)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/Secp256k1/index.js';
console.log(PUBLIC_KEY_SIZE); // 64
```
###### Secp256k1.PublicKey
> **PublicKey**: `__module` = `PublicKeyMethods`
###### Secp256k1.randomPrivateKey()
> **randomPrivateKey**: () => `Uint8Array`\<`ArrayBufferLike`>
Generate a cryptographically secure random secp256k1 private key
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte private key
###### Example
```javascript theme={null}
import { Secp256k1 } from './crypto/Secp256k1/index.js';
const privateKey = Secp256k1.randomPrivateKey();
const publicKey = Secp256k1.derivePublicKey(privateKey);
```
###### Secp256k1.recoverPublicKey()
> **recoverPublicKey**: (`signature`, `messageHash`) => [`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and message hash
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### messageHash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
###### Returns
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const messageHash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
###### Secp256k1.recoverPublicKeyFromHash()
> **recoverPublicKeyFromHash**: (`signature`, `hash`) => [`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Recover public key from signature and pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use recoverPublicKey() instead.
Uses the recovery id (v) to recover the exact public key that created
the signature. This is what enables Ethereum's address recovery from
transaction signatures.
###### Parameters
###### signature
ECDSA signature components
###### r
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component r
###### s
`Uint8Array`\<`ArrayBufferLike`>
32-byte signature component s
###### v
`number`
Recovery id (27/28 or 0/1)
###### hash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### Returns
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature or recovery fails
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Recover public key from a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello');
const recovered = Secp256k1.recoverPublicKeyFromHash(
{ r: rBytes, s: sBytes, v: 27 },
hash
);
// For comparison, recoverPublicKey() hashes internally (message-level API)
const recovered2 = Secp256k1.recoverPublicKey(
{ r: rBytes, s: sBytes, v: 27 },
messageHash
);
```
###### Secp256k1.scalarMultiply()
> **scalarMultiply**: (`scalar`) => [`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Multiply generator point by scalar
Performs scalar multiplication: scalar \* G (generator point).
Used in ERC-5564 stealth address generation.
###### Parameters
###### scalar
`Uint8Array`\<`ArrayBufferLike`>
32-byte scalar value
###### Returns
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
Result 64-byte uncompressed public key
###### See
* [https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
* [https://eips.ethereum.org/EIPS/eip-5564](https://eips.ethereum.org/EIPS/eip-5564) for ERC-5564 stealth addresses
###### Since
0.0.0
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const scalar = new Uint8Array(32);
scalar[31] = 5; // scalar = 5
const result = Secp256k1.scalarMultiply(scalar);
console.log(result.length); // 64
```
###### Secp256k1.sign()
> **sign**: (`messageHash`, `privateKey`) => [`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a message hash with a private key
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### messageHash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte message hash to sign
###### privateKey
[`PrivateKeyType`](primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
const messageHash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.sign(messageHash, privateKey);
```
###### Secp256k1.Signature
> **Signature**: `__module` = `SignatureMethods`
###### Secp256k1.SIGNATURE\_COMPONENT\_SIZE
> **SIGNATURE\_COMPONENT\_SIZE**: `number`
Signature component size in bytes (r and s are each 32 bytes)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SIGNATURE_COMPONENT_SIZE } from './crypto/Secp256k1/index.js';
console.log(SIGNATURE_COMPONENT_SIZE); // 32
```
###### Secp256k1.signHash()
> **signHash**: (`hash`, `privateKey`) => [`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
Sign a pre-hashed message with a private key
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use sign() instead.
Uses deterministic ECDSA (RFC 6979) for signature generation.
Returns signature with Ethereum-compatible v value (27 or 28).
###### Parameters
###### hash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte hash to sign (pre-hashed message)
###### privateKey
[`PrivateKeyType`](primitives/PrivateKey.mdx#privatekeytype)
32-byte private key
###### Returns
[`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If private key is invalid
###### Throws
If signing fails or hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
import * as PrivateKey from './primitives/PrivateKey/index.js';
// Sign a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const privateKey = PrivateKey.from(new Uint8Array(32));
const signature = Secp256k1.signHash(hash, privateKey);
// For comparison, sign() hashes internally (message-level API)
const signature2 = Secp256k1.sign(Hash.keccak256String('Hello!'), privateKey);
```
###### Secp256k1.verify()
> **verify**: (`signature`, `messageHash`, `publicKey`) => `boolean`
Verify an ECDSA signature
###### Parameters
###### signature
[`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### messageHash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte message hash that was signed
###### publicKey
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If signature v is invalid
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
const r = Hash.from(rBytes);
const s = Hash.from(sBytes);
const valid = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
###### Secp256k1.verifyHash()
> **verifyHash**: (`signature`, `hash`, `publicKey`) => `boolean`
Verify an ECDSA signature against a pre-hashed message
This is the hash-level API that operates directly on a 32-byte hash.
Use this when you need custom hashing schemes or interop with other libraries.
For standard Ethereum signing, use verify() instead.
###### Parameters
###### signature
[`Secp256k1SignatureType`](crypto/Secp256k1.mdx#secp256k1signaturetype)
ECDSA signature with r, s, v components (r and s are HashType)
###### hash
[`HashType`](index/namespaces/HashType.mdx#hashtype)
32-byte hash that was signed (pre-hashed message)
###### publicKey
[`Secp256k1PublicKeyType`](crypto/Secp256k1.mdx#secp256k1publickeytype)
64-byte uncompressed public key
###### Returns
`boolean`
true if signature is valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If hash is not 32 bytes
###### Example
```javascript theme={null}
import * as Secp256k1 from './crypto/Secp256k1/index.js';
import * as Hash from './primitives/Hash/index.js';
// Verify a signature against a pre-hashed message (hash-level API)
const hash = Hash.keccak256String('Hello!');
const valid = Secp256k1.verifyHash({ r, s, v: 27 }, hash, publicKey);
// For comparison, verify() hashes internally (message-level API)
const valid2 = Secp256k1.verify({ r, s, v: 27 }, messageHash, publicKey);
```
##### ~~SHA256~~
> **SHA256**: (`input`) => [`SHA256Hash`](index/index.mdx#sha256hash) & `object`
###### Type Declaration
###### ~~BLOCK\_SIZE~~
> **BLOCK\_SIZE**: `number`
SHA256 block size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { BLOCK_SIZE } from './crypto/SHA256/index.js';
console.log(BLOCK_SIZE); // 64
```
###### ~~create()~~
> **create**: () => `object`
Incremental hasher for streaming data
###### Returns
`object`
Hasher instance
###### ~~digest()~~
> **digest**: () => `Uint8Array`
###### Returns
`Uint8Array`
###### ~~update()~~
> **update**: (`data`) => `void`
###### Parameters
###### data
`Uint8Array`
###### Returns
`void`
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hasher = SHA256.create();
hasher.update(new Uint8Array([1, 2, 3]));
hasher.update(new Uint8Array([4, 5, 6]));
const hash = hasher.digest();
```
###### ~~from()~~
> **from**: (`input`) => [`SHA256Hash`](index/index.mdx#sha256hash)
Hash input with SHA256 (constructor pattern)
Auto-detects input type and hashes accordingly:
* Uint8Array: hash directly
* string starting with 0x: parse as hex
* string: UTF-8 encode then hash
###### Parameters
###### input
Data to hash
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto/sha256](https://voltaire.tevm.sh/crypto/sha256) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash1 = SHA256Hash.from("0x1234"); // Hex
const hash2 = SHA256Hash.from("hello"); // String
const hash3 = SHA256Hash.from(uint8array); // Bytes
```
###### ~~fromHex()~~
> **fromHex**: (`hex`) => [`SHA256Hash`](index/index.mdx#sha256hash) = `hashHex`
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
###### ~~fromString()~~
> **fromString**: (`str`) => [`SHA256Hash`](index/index.mdx#sha256hash) = `hashString`
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
###### ~~hash()~~
> **hash**: (`data`) => [`SHA256Hash`](index/index.mdx#sha256hash)
Compute SHA256 hash of input data
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Input data as Uint8Array
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256Hash } from './crypto/SHA256/index.js';
const hash = SHA256Hash.from(new Uint8Array([1, 2, 3]));
console.log(hash.length); // 32
```
###### ~~hashHex()~~
> **hashHex**: (`hex`) => [`SHA256Hash`](index/index.mdx#sha256hash)
Compute SHA256 hash of hex string (without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashHex("0xdeadbeef");
console.log(hash.length); // 32
```
###### ~~hashString()~~
> **hashString**: (`str`) => [`SHA256Hash`](index/index.mdx#sha256hash)
Compute SHA256 hash of UTF-8 string
###### Parameters
###### str
`string`
Input string
###### Returns
[`SHA256Hash`](index/index.mdx#sha256hash)
32-byte hash
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hashString("hello world");
console.log(hash.length); // 32
```
###### ~~OUTPUT\_SIZE~~
> **OUTPUT\_SIZE**: `number`
SHA256 output size in bytes (256 bits / 8)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { OUTPUT_SIZE } from './crypto/SHA256/index.js';
console.log(OUTPUT_SIZE); // 32
```
###### ~~toHex()~~
> **toHex**: (`hash`) => `string`
Convert hash output to hex string
###### Parameters
###### hash
`Uint8Array`\<`ArrayBufferLike`>
Hash bytes
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHA256 } from './crypto/SHA256/index.js';
const hash = SHA256.hash(new Uint8Array([1, 2, 3]));
const hexStr = SHA256.toHex(hash);
console.log(hexStr); // "0x..."
```
###### Deprecated
Use SHA256Hash instead
SHA256 alias maintained for backward compatibility
##### Siwe
> **Siwe**: *typeof* [`Siwe`](primitives/Siwe.mdx#siwe)
##### StorageKey
> **StorageKey**: `object`
###### StorageKey.create()
> **create**: (`address`, `slot`) => [`StorageKeyType`](primitives/State.mdx#storagekeytype)
###### Parameters
###### address
[`AddressType`](primitives/Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
[`StorageKeyType`](primitives/State.mdx#storagekeytype)
###### StorageKey.equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`StorageKeyLike`](primitives/State.mdx#storagekeylike)
###### b
[`StorageKeyLike`](primitives/State.mdx#storagekeylike)
###### Returns
`boolean`
###### StorageKey.from()
> **from**: (`value`) => [`StorageKeyType`](primitives/State.mdx#storagekeytype)
###### Parameters
###### value
[`StorageKeyLike`](primitives/State.mdx#storagekeylike)
###### Returns
[`StorageKeyType`](primitives/State.mdx#storagekeytype)
###### StorageKey.fromString()
> **fromString**: (`str`) => [`StorageKeyType`](primitives/State.mdx#storagekeytype) | `undefined`
###### Parameters
###### str
`string`
###### Returns
[`StorageKeyType`](primitives/State.mdx#storagekeytype) | `undefined`
###### StorageKey.hashCode()
> **hashCode**: (`key`) => `number`
###### Parameters
###### key
[`StorageKeyLike`](primitives/State.mdx#storagekeylike)
###### Returns
`number`
###### StorageKey.is()
> **is**: (`value`) => `value is StorageKeyType`
###### Parameters
###### value
`unknown`
###### Returns
`value is StorageKeyType`
###### StorageKey.toString()
> **toString**: (`key`) => `string`
###### Parameters
###### key
[`StorageKeyLike`](primitives/State.mdx#storagekeylike)
###### Returns
`string`
##### Uint
> **Uint**: *typeof* [`Uint`](index/index.mdx#uint)
##### Wei
> **Wei**: `WeiConstructor`
##### X25519
> **X25519**: `object`
X25519 Elliptic Curve Diffie-Hellman
Curve25519 key exchange algorithm for secure shared secret generation.
Fast, simple, and designed for ECDH key agreement.
Used in modern protocols like TLS 1.3, WireGuard, Signal, and SSH.
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
// Generate two keypairs
const seed1 = crypto.getRandomValues(new Uint8Array(32));
const seed2 = crypto.getRandomValues(new Uint8Array(32));
const keypair1 = X25519.keypairFromSeed(seed1);
const keypair2 = X25519.keypairFromSeed(seed2);
// Perform key exchange
const shared1 = X25519.scalarmult(keypair1.secretKey, keypair2.publicKey);
const shared2 = X25519.scalarmult(keypair2.secretKey, keypair1.publicKey);
// shared1 === shared2 (same shared secret from both sides)
```
###### X25519.derivePublicKey()
> **derivePublicKey**: (`secretKey`) => [`PublicKey`](crypto/X25519.mdx#publickey)
Derive public key from secret key
###### Parameters
###### secretKey
[`SecretKey`](crypto/X25519.mdx#secretkey)
32-byte secret key
###### Returns
[`PublicKey`](crypto/X25519.mdx#publickey)
32-byte public key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const publicKey = X25519.derivePublicKey(secretKey);
console.log(publicKey.length); // 32
```
###### X25519.generateKeypair()
> **generateKeypair**: () => `object`
Generate random keypair
Uses crypto.getRandomValues for secure random generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const keypair = X25519.generateKeypair();
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
###### X25519.generateSecretKey()
> **generateSecretKey**: () => [`SecretKey`](crypto/X25519.mdx#secretkey)
Generate random secret key
Uses crypto.getRandomValues for secure random generation
###### Returns
[`SecretKey`](crypto/X25519.mdx#secretkey)
32-byte random secret key
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = X25519.generateSecretKey();
const publicKey = X25519.derivePublicKey(secretKey);
console.log(secretKey.length); // 32
```
###### X25519.keypairFromSeed()
> **keypairFromSeed**: (`seed`) => `object`
Generate X25519 keypair from seed
###### Parameters
###### seed
`Uint8Array`\<`ArrayBufferLike`>
32-byte seed for deterministic generation
###### Returns
`object`
Object with secretKey and publicKey
###### publicKey
> **publicKey**: [`PublicKey`](crypto/X25519.mdx#publickey)
###### secretKey
> **secretKey**: [`SecretKey`](crypto/X25519.mdx#secretkey)
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If seed length is invalid
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const seed = crypto.getRandomValues(new Uint8Array(32));
const keypair = X25519.keypairFromSeed(seed);
console.log(keypair.secretKey.length); // 32
console.log(keypair.publicKey.length); // 32
```
###### X25519.PUBLIC\_KEY\_SIZE
> **PUBLIC\_KEY\_SIZE**: `32`
Public key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { PUBLIC_KEY_SIZE } from './crypto/X25519/index.js';
console.log(PUBLIC_KEY_SIZE); // 32
```
###### X25519.scalarmult()
> **scalarmult**: (`secretKey`, `publicKey`) => [`SharedSecret`](crypto/X25519.mdx#sharedsecret)
Perform X25519 scalar multiplication (ECDH)
Computes shared secret from your secret key and their public key.
###### Parameters
###### secretKey
[`SecretKey`](crypto/X25519.mdx#secretkey)
Your 32-byte secret key
###### publicKey
[`PublicKey`](crypto/X25519.mdx#publickey)
Their 32-byte public key
###### Returns
[`SharedSecret`](crypto/X25519.mdx#sharedsecret)
32-byte shared secret
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
If secret key is invalid
###### Throws
If public key is invalid
###### Throws
If scalar multiplication fails
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const mySecret = crypto.getRandomValues(new Uint8Array(32));
const theirPublic = X25519.derivePublicKey(theirSecret);
const shared = X25519.scalarmult(mySecret, theirPublic);
console.log(shared.length); // 32
```
###### X25519.SECRET\_KEY\_SIZE
> **SECRET\_KEY\_SIZE**: `32`
Secret key size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SECRET_KEY_SIZE } from './crypto/X25519/index.js';
console.log(SECRET_KEY_SIZE); // 32
```
###### X25519.SHARED\_SECRET\_SIZE
> **SHARED\_SECRET\_SIZE**: `32`
Shared secret size in bytes
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { SHARED_SECRET_SIZE } from './crypto/X25519/index.js';
console.log(SHARED_SECRET_SIZE); // 32
```
###### X25519.validatePublicKey()
> **validatePublicKey**: (`publicKey`) => `boolean`
Validate a public key
Checks if the public key has correct length
###### Parameters
###### publicKey
[`PublicKey`](crypto/X25519.mdx#publickey)
Public key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const publicKey = new Uint8Array(32);
const valid = X25519.validatePublicKey(publicKey);
```
###### X25519.validateSecretKey()
> **validateSecretKey**: (`secretKey`) => `boolean`
Validate a secret key
Checks if the secret key has correct length and can derive a public key
###### Parameters
###### secretKey
[`SecretKey`](crypto/X25519.mdx#secretkey)
Secret key to validate
###### Returns
`boolean`
True if valid, false otherwise
###### See
[https://voltaire.tevm.sh/crypto](https://voltaire.tevm.sh/crypto) for crypto documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { X25519 } from './crypto/X25519/index.js';
const secretKey = new Uint8Array(32);
const valid = X25519.validateSecretKey(secretKey);
```
## Functions
### allocateOutput()
> **allocateOutput**(`size`): `Uint8Array`
Defined in: [src/native-loader/index.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L64)
Helper to allocate buffer for output
#### Parameters
##### size
`number`
#### Returns
`Uint8Array`
***
### allocateStringOutput()
> **allocateStringOutput**(`size`): `object`
Defined in: [src/native-loader/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L71)
Helper to allocate buffer for string output
#### Parameters
##### size
`number`
#### Returns
`object`
##### buffer
> **buffer**: `Uint8Array`
##### ptr
> **ptr**: `Uint8Array`
***
### checkError()
> **checkError**(`code`, `operation`): `void`
Defined in: [src/native-loader/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L53)
Check error code and throw if non-zero
#### Parameters
##### code
`number`
##### operation
`string`
#### Returns
`void`
***
### getNativeErrorMessage()
> **getNativeErrorMessage**(`code`): `string`
Defined in: [src/native-loader/types.ts:224](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/types.ts#L224)
Convert native error code to error message
#### Parameters
##### code
`number`
#### Returns
`string`
***
### getNativeExtension()
> **getNativeExtension**(): `string`
Defined in: [src/native-loader/platform.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/platform.ts#L45)
Get file extension for native libraries on current platform
#### Returns
`string`
***
### getPlatform()
> **getPlatform**(): [`Platform`](#platform)
Defined in: [src/native-loader/platform.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/platform.ts#L15)
Get current platform identifier
#### Returns
[`Platform`](#platform)
***
### isBun()
> **isBun**(): `boolean`
Defined in: [src/native-loader/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L19)
Runtime environment detection
#### Returns
`boolean`
***
### isNativeSupported()
> **isNativeSupported**(): `boolean`
Defined in: [src/native-loader/platform.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/platform.ts#L63)
Check if native bindings are supported on current platform
#### Returns
`boolean`
***
### isNode()
> **isNode**(): `boolean`
Defined in: [src/native-loader/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L23)
#### Returns
`boolean`
***
### loadNative()
> **loadNative**(): `Promise`\<`NativeModule` | `ConvertFns`\<\{ `primitives_abi_compute_selector`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_equals`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `bool`; }; `primitives_address_from_hex`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_is_zero`: \{ `args`: readonly \[`ptr`]; `returns`: `bool`; }; `primitives_address_to_checksum_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_to_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_blake2b`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_bytes_to_hex`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_hash_equals`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `bool`; }; `primitives_hash_from_hex`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_hash_to_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_hex_to_bytes`: \{ `args`: readonly \[`cstring`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_keccak256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_ripemd160`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_secp256k1_recover_address`: \{ `args`: readonly \[`ptr`, `int32_t`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_sha256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_solidity_keccak256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_solidity_sha256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `secp256k1DerivePublicKey`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `secp256k1Sign`: \{ `args`: readonly \[`ptr`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `secp256k1Verify`: \{ `args`: readonly \[`ptr`, `ptr`, `ptr`]; `returns`: `bool`; }; }>>
Defined in: [src/native-loader/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/native-loader/index.ts#L34)
Load native library using appropriate loader
#### Returns
`Promise`\<`NativeModule` | `ConvertFns`\<\{ `primitives_abi_compute_selector`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_equals`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `bool`; }; `primitives_address_from_hex`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_is_zero`: \{ `args`: readonly \[`ptr`]; `returns`: `bool`; }; `primitives_address_to_checksum_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_address_to_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_blake2b`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_bytes_to_hex`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_hash_equals`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `bool`; }; `primitives_hash_from_hex`: \{ `args`: readonly \[`cstring`, `ptr`]; `returns`: `int32_t`; }; `primitives_hash_to_hex`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_hex_to_bytes`: \{ `args`: readonly \[`cstring`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_keccak256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_ripemd160`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_secp256k1_recover_address`: \{ `args`: readonly \[`ptr`, `int32_t`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `primitives_sha256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_solidity_keccak256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `primitives_solidity_sha256`: \{ `args`: readonly \[`ptr`, `uint64_t`, `ptr`]; `returns`: `int32_t`; }; `secp256k1DerivePublicKey`: \{ `args`: readonly \[`ptr`, `ptr`]; `returns`: `int32_t`; }; `secp256k1Sign`: \{ `args`: readonly \[`ptr`, `ptr`, `ptr`]; `returns`: `int32_t`; }; `secp256k1Verify`: \{ `args`: readonly \[`ptr`, `ptr`, `ptr`]; `returns`: `bool`; }; }>>
## References
### Abi
Re-exports [Abi](primitives/Abi/index.mdx#abi)
***
### AbstractError
Re-exports [AbstractError](index/index.mdx#abstracterror)
***
### AccessList
Re-exports [AccessList](primitives/AccessList.mdx#accesslist)
***
### Address
Re-exports [Address](primitives/Address.mdx#address)
***
### AesGcm
Re-exports [AesGcm](crypto/AesGcm.mdx#aesgcm)
***
### Authorization
Renames and re-exports [primitives/Authorization](primitives/Authorization.mdx)
***
### Base64
Renames and re-exports [primitives/Base64](primitives/Base64.mdx)
***
### BeaconBlockRoot
Renames and re-exports [primitives/BeaconBlockRoot](primitives/BeaconBlockRoot.mdx)
***
### BinaryTree
Renames and re-exports [primitives/BinaryTree](primitives/BinaryTree.mdx)
***
### Bip39
Re-exports [Bip39](crypto/Bip39.mdx#bip39)
***
### Blake2
Re-exports [Blake2](crypto/Blake2.mdx#blake2)
***
### Blake2Hash
Re-exports [Blake2Hash](index/index.mdx#blake2hash)
***
### Blake2HashType
Renames and re-exports [Blake2Hash](index/index.mdx#blake2hash)
***
### Blob
Re-exports [Blob](primitives/Blob.mdx#blob)
***
### Block
Renames and re-exports [primitives/Block](primitives/Block.mdx)
***
### BlockBody
Renames and re-exports [primitives/BlockBody](primitives/BlockBody.mdx)
***
### BlockFilter
Renames and re-exports [primitives/BlockFilter](primitives/BlockFilter.mdx)
***
### BlockHash
Renames and re-exports [primitives/BlockHash](primitives/BlockHash.mdx)
***
### BlockHeader
Renames and re-exports [primitives/BlockHeader](primitives/BlockHeader.mdx)
***
### BlockNumber
Renames and re-exports [primitives/BlockNumber](primitives/BlockNumber.mdx)
***
### BloomFilter
Re-exports [BloomFilter](primitives/BloomFilter.mdx#bloomfilter)
***
### Bls12381
Re-exports [Bls12381](crypto/Bls12381/index.mdx#bls12381)
***
### Bls12381Fp2Type
Re-exports [Bls12381Fp2Type](index/index.mdx#bls12381fp2type)
***
### Bls12381G1PointType
Re-exports [Bls12381G1PointType](index/index.mdx#bls12381g1pointtype)
***
### Bls12381G2PointType
Re-exports [Bls12381G2PointType](index/index.mdx#bls12381g2pointtype)
***
### BN254
Re-exports [BN254](index/index.mdx#bn254)
***
### BrandedAbi
Renames and re-exports [primitives/Abi](primitives/Abi/index.mdx)
***
### BrandedAccessList
Renames and re-exports [primitives/AccessList](primitives/AccessList.mdx)
***
### BrandedAddress
Re-exports [BrandedAddress](index/namespaces/BrandedAddress/index.mdx)
***
### BrandedAuthorization
Renames and re-exports [primitives/Authorization](primitives/Authorization.mdx)
***
### BrandedBase64
Re-exports [BrandedBase64](index/namespaces/BrandedBase64.mdx)
***
### BrandedBinaryTree
Renames and re-exports [primitives/BinaryTree](primitives/BinaryTree.mdx)
***
### BrandedBlob
Renames and re-exports [primitives/Blob](primitives/Blob.mdx)
***
### BrandedBloomFilter
Renames and re-exports [primitives/BloomFilter](primitives/BloomFilter.mdx)
***
### BrandedBytecode
Renames and re-exports [primitives/Bytecode](primitives/Bytecode.mdx)
***
### BrandedBytes
Re-exports [BrandedBytes](index/namespaces/BrandedBytes.mdx)
***
### BrandedBytes1
Re-exports [BrandedBytes1](index/namespaces/BrandedBytes1.mdx)
***
### BrandedBytes16
Re-exports [BrandedBytes16](index/namespaces/BrandedBytes16.mdx)
***
### BrandedBytes2
Re-exports [BrandedBytes2](index/namespaces/BrandedBytes2.mdx)
***
### BrandedBytes3
Re-exports [BrandedBytes3](index/namespaces/BrandedBytes3.mdx)
***
### BrandedBytes32
Re-exports [BrandedBytes32](index/namespaces/BrandedBytes32.mdx)
***
### BrandedBytes4
Re-exports [BrandedBytes4](index/namespaces/BrandedBytes4.mdx)
***
### BrandedBytes5
Re-exports [BrandedBytes5](index/namespaces/BrandedBytes5.mdx)
***
### BrandedBytes6
Re-exports [BrandedBytes6](index/namespaces/BrandedBytes6.mdx)
***
### BrandedBytes64
Re-exports [BrandedBytes64](index/namespaces/BrandedBytes64.mdx)
***
### BrandedBytes7
Re-exports [BrandedBytes7](index/namespaces/BrandedBytes7.mdx)
***
### BrandedBytes8
Re-exports [BrandedBytes8](index/namespaces/BrandedBytes8.mdx)
***
### BrandedChain
Re-exports [BrandedChain](index/namespaces/BrandedChain.mdx)
***
### BrandedEther
Re-exports [BrandedEther](index/namespaces/BrandedEther.mdx)
***
### BrandedEventLog
Renames and re-exports [primitives/EventLog](primitives/EventLog.mdx)
***
### BrandedFeeMarket
Re-exports [BrandedFeeMarket](index/namespaces/BrandedFeeMarket.mdx)
***
### BrandedGwei
Re-exports [BrandedGwei](index/namespaces/BrandedGwei.mdx)
***
### BrandedHash
Renames and re-exports [primitives/Hash](primitives/Hash.mdx)
***
### BrandedHex
Re-exports [BrandedHex](index/namespaces/BrandedHex.mdx)
***
### BrandedInt128
Renames and re-exports [primitives/Int128](primitives/Int128.mdx)
***
### BrandedInt16
Renames and re-exports [primitives/Int16](primitives/Int16.mdx)
***
### BrandedInt256
Renames and re-exports [primitives/Int256](primitives/Int256.mdx)
***
### BrandedInt32
Renames and re-exports [primitives/Int32](primitives/Int32.mdx)
***
### BrandedInt64
Renames and re-exports [primitives/Int64](primitives/Int64.mdx)
***
### BrandedInt8
Renames and re-exports [primitives/Int8](primitives/Int8.mdx)
***
### BrandedOpcode
Re-exports [BrandedOpcode](index/namespaces/BrandedOpcode.mdx)
***
### BrandedRlp
Re-exports [BrandedRlp](index/namespaces/BrandedRlp.mdx)
***
### BrandedSiwe
Renames and re-exports [primitives/Siwe](primitives/Siwe.mdx)
***
### BrandedStorageKey
Renames and re-exports [primitives/State](primitives/State.mdx)
***
### BrandedUint
Renames and re-exports [primitives/Uint](primitives/Uint.mdx)
***
### BrandedUint128
Renames and re-exports [primitives/Uint128](primitives/Uint128.mdx)
***
### BrandedUint16
Renames and re-exports [primitives/Uint16](primitives/Uint16.mdx)
***
### BrandedUint32
Renames and re-exports [primitives/Uint32](primitives/Uint32.mdx)
***
### BrandedUint64
Renames and re-exports [primitives/Uint64](primitives/Uint64.mdx)
***
### BrandedUint8
Renames and re-exports [primitives/Uint8](primitives/Uint8.mdx)
***
### BrandedWei
Re-exports [BrandedWei](index/namespaces/BrandedWei.mdx)
***
### Bytecode
Re-exports [Bytecode](primitives/Bytecode.mdx#bytecode)
***
### Bytes
Re-exports [Bytes](index/index.mdx#bytes)
***
### Bytes1
Re-exports [Bytes1](index/namespaces/BrandedBytes1.mdx#bytes1)
***
### Bytes16
Re-exports [Bytes16](index/namespaces/BrandedBytes16.mdx#bytes16)
***
### Bytes2
Re-exports [Bytes2](index/index.mdx#bytes2)
***
### Bytes3
Re-exports [Bytes3](index/index.mdx#bytes3)
***
### Bytes32
Re-exports [Bytes32](index/namespaces/BrandedBytes32.mdx#bytes32)
***
### Bytes4
Re-exports [Bytes4](index/namespaces/BrandedBytes4.mdx#bytes4)
***
### Bytes5
Re-exports [Bytes5](index/index.mdx#bytes5)
***
### Bytes6
Re-exports [Bytes6](index/index.mdx#bytes6)
***
### Bytes64
Re-exports [Bytes64](index/namespaces/BrandedBytes64.mdx#bytes64)
***
### Bytes7
Re-exports [Bytes7](index/index.mdx#bytes7)
***
### Bytes8
Re-exports [Bytes8](index/namespaces/BrandedBytes8.mdx#bytes8)
***
### CallTrace
Renames and re-exports [primitives/CallTrace](primitives/CallTrace.mdx)
***
### ChaCha20Poly1305
Re-exports [ChaCha20Poly1305](crypto/ChaCha20Poly1305.mdx#chacha20poly1305)
***
### Chain
Re-exports [Chain](index/namespaces/BrandedChain.mdx#chain-1)
***
### ChainHead
Renames and re-exports [primitives/ChainHead](primitives/ChainHead.mdx)
***
### CompilerVersion
Renames and re-exports [primitives/CompilerVersion](primitives/CompilerVersion.mdx)
***
### ContractCode
Renames and re-exports [primitives/ContractCode](primitives/ContractCode.mdx)
***
### ContractResult
Renames and re-exports [primitives/ContractResult](primitives/ContractResult.mdx)
***
### ContractSignature
Renames and re-exports [primitives/ContractSignature](primitives/ContractSignature.mdx)
***
### CryptoError
Re-exports [CryptoError](index/index.mdx#cryptoerror)
***
### DecodedData
Renames and re-exports [primitives/DecodedData](primitives/DecodedData.mdx)
***
### DecodingError
Re-exports [DecodingError](index/index.mdx#decodingerror)
***
### Domain
Renames and re-exports [primitives/Domain](primitives/Domain.mdx)
***
### DomainSeparator
Renames and re-exports [primitives/DomainSeparator](primitives/DomainSeparator.mdx)
***
### Ed25519
Re-exports [Ed25519](crypto/Ed25519.mdx#ed25519)
***
### EIP712
Re-exports [EIP712](crypto/EIP712.mdx#eip712)
***
### EncodedData
Renames and re-exports [primitives/EncodedData](primitives/EncodedData.mdx)
***
### EncodingError
Re-exports [EncodingError](index/index.mdx#encodingerror)
***
### Ens
Renames and re-exports [primitives/Ens](primitives/Ens.mdx)
***
### Epoch
Renames and re-exports [primitives/Epoch](primitives/Epoch.mdx)
***
### ERC1155
Re-exports [ERC1155](index/namespaces/ERC1155.mdx)
***
### ERC165
Re-exports [ERC165](index/namespaces/ERC165.mdx)
***
### ERC20
Re-exports [ERC20](index/namespaces/ERC20.mdx)
***
### ERC721
Re-exports [ERC721](index/namespaces/ERC721.mdx)
***
### ErrorSignature
Renames and re-exports [primitives/ErrorSignature](primitives/ErrorSignature.mdx)
***
### Ether
Re-exports [Ether](index/index.mdx#ether-1)
***
### EventLog
Renames and re-exports [primitives/EventLog](primitives/EventLog.mdx)
***
### EventSignature
Renames and re-exports [primitives/EventSignature](primitives/EventSignature.mdx)
***
### evm
Re-exports [evm](evm/index.mdx)
***
### FeeMarket
Re-exports [FeeMarket](index/namespaces/FeeMarket.mdx)
***
### FilterId
Renames and re-exports [primitives/FilterId](primitives/FilterId.mdx)
***
### ForkId
Renames and re-exports [primitives/ForkId](primitives/ForkId.mdx)
***
### FunctionSignature
Renames and re-exports [primitives/FunctionSignature](primitives/FunctionSignature.mdx)
***
### Gas
Renames and re-exports [primitives/Gas](primitives/Gas.mdx)
***
### GasConstants
Renames and re-exports [primitives/GasConstants](primitives/GasConstants/index.mdx)
***
### GasCosts
Re-exports [GasCosts](GasCosts.mdx)
***
### GasEstimate
Renames and re-exports [primitives/GasEstimate](primitives/GasEstimate.mdx)
***
### GasRefund
Renames and re-exports [primitives/GasRefund](primitives/GasRefund.mdx)
***
### GasUsed
Renames and re-exports [primitives/GasUsed](primitives/GasUsed.mdx)
***
### Gwei
Re-exports [Gwei](index/index.mdx#gwei-1)
***
### Hardfork
Renames and re-exports [primitives/Hardfork](primitives/Hardfork.mdx)
***
### Hash
Re-exports [Hash](index/index.mdx#hash)
***
### HashType
Re-exports [HashType](index/namespaces/HashType.mdx)
***
### HDWallet
Re-exports [HDWallet](HDWallet.mdx)
***
### Hex
Re-exports [Hex](index/index.mdx#hex)
***
### InitCode
Renames and re-exports [primitives/InitCode](primitives/InitCode.mdx)
***
### Int128
Re-exports [Int128](index/index.mdx#int128)
***
### Int16
Re-exports [Int16](index/index.mdx#int16)
***
### Int256
Re-exports [Int256](index/index.mdx#int256)
***
### Int32
Re-exports [Int32](index/index.mdx#int32)
***
### Int64
Re-exports [Int64](index/index.mdx#int64)
***
### Int8
Re-exports [Int8](index/index.mdx#int8)
***
### IntegerOverflowError
Re-exports [IntegerOverflowError](index/index.mdx#integeroverflowerror)
***
### IntegerUnderflowError
Re-exports [IntegerUnderflowError](index/index.mdx#integerunderflowerror)
***
### InvalidChecksumError
Re-exports [InvalidChecksumError](index/index.mdx#invalidchecksumerror)
***
### InvalidFormatError
Re-exports [InvalidFormatError](index/index.mdx#invalidformaterror)
***
### InvalidLengthError
Re-exports [InvalidLengthError](index/index.mdx#invalidlengtherror)
***
### InvalidPrivateKeyError
Re-exports [InvalidPrivateKeyError](index/index.mdx#invalidprivatekeyerror)
***
### InvalidPublicKeyError
Re-exports [InvalidPublicKeyError](index/index.mdx#invalidpublickeyerror)
***
### InvalidRangeError
Re-exports [InvalidRangeError](index/index.mdx#invalidrangeerror)
***
### InvalidSignatureError
Re-exports [InvalidSignatureError](index/index.mdx#invalidsignatureerror)
***
### InvalidSignerError
Re-exports [InvalidSignerError](index/index.mdx#invalidsignererror)
***
### InvalidSizeError
Re-exports [InvalidSizeError](index/index.mdx#invalidsizeerror)
***
### InvalidTransactionTypeError
Re-exports [InvalidTransactionTypeError](index/index.mdx#invalidtransactiontypeerror)
***
### Keccak256Hash
Re-exports [Keccak256Hash](index/index.mdx#keccak256hash)
***
### Keccak256HashType
Renames and re-exports [Keccak256Hash](index/index.mdx#keccak256hash)
***
### Keccak256Native
Renames and re-exports [Keccak256](#keccak256)
***
### Keystore
Renames and re-exports [crypto/Keystore](crypto/Keystore.mdx)
***
### KZG
Re-exports [KZG](index/index.mdx#kzg)
***
### KzgBlobType
Renames and re-exports [BlobType](crypto/KZG.mdx#blobtype)
***
### KzgCommitmentType
Re-exports [KzgCommitmentType](crypto/KZG.mdx#kzgcommitmenttype)
***
### KzgProofType
Re-exports [KzgProofType](crypto/KZG.mdx#kzgprooftype)
***
### License
Renames and re-exports [primitives/License](primitives/License.mdx)
***
### LogFilter
Renames and re-exports [primitives/LogFilter](primitives/LogFilter.mdx)
***
### LogIndex
Renames and re-exports [primitives/LogIndex](primitives/LogIndex.mdx)
***
### MemoryDump
Renames and re-exports [primitives/MemoryDump](primitives/MemoryDump.mdx)
***
### Metadata
Renames and re-exports [primitives/Metadata](primitives/Metadata.mdx)
***
### ModExp
Re-exports [ModExp](crypto/ModExp.mdx#modexp)
***
### NativeErrorCodeType
Renames and re-exports [NativeErrorCode](#nativeerrorcode)
***
### NetworkId
Renames and re-exports [primitives/NetworkId](primitives/NetworkId.mdx)
***
### NodeInfo
Renames and re-exports [primitives/NodeInfo](primitives/NodeInfo.mdx)
***
### Opcode
Re-exports [Opcode](index/index.mdx#opcode)
***
### OpStep
Renames and re-exports [primitives/OpStep](primitives/OpStep.mdx)
***
### P256
Re-exports [P256](crypto/P256.mdx#p256)
***
### PeerId
Renames and re-exports [primitives/PeerId](primitives/PeerId.mdx)
***
### PeerInfo
Renames and re-exports [primitives/PeerInfo](primitives/PeerInfo.mdx)
***
### PendingTransactionFilter
Renames and re-exports [primitives/PendingTransactionFilter](primitives/PendingTransactionFilter.mdx)
***
### Permit
Renames and re-exports [primitives/Permit](primitives/Permit/index.mdx)
***
### precompiles
Re-exports [precompiles](index/namespaces/precompiles.mdx)
***
### PrimitiveError
Re-exports [PrimitiveError](index/index.mdx#primitiveerror)
***
### ProtocolVersion
Renames and re-exports [primitives/ProtocolVersion](primitives/ProtocolVersion.mdx)
***
### Proxy
Re-exports [Proxy](Proxy.mdx)
***
### Receipt
Renames and re-exports [primitives/Receipt](primitives/Receipt.mdx)
***
### ReturnData
Renames and re-exports [primitives/ReturnData](primitives/ReturnData.mdx)
***
### RevertReason
Renames and re-exports [primitives/RevertReason](primitives/RevertReason.mdx)
***
### Ripemd160
Re-exports [Ripemd160](crypto/Ripemd160.mdx#ripemd160)
***
### Ripemd160Hash
Re-exports [Ripemd160Hash](index/index.mdx#ripemd160hash)
***
### Ripemd160HashType
Renames and re-exports [Ripemd160Hash](index/index.mdx#ripemd160hash)
***
### Rlp
Re-exports [Rlp](primitives/Rlp.mdx#rlp)
***
### RuntimeCode
Renames and re-exports [primitives/RuntimeCode](primitives/RuntimeCode.mdx)
***
### Secp256k1
Re-exports [Secp256k1](crypto/Secp256k1.mdx#secp256k1)
***
### Selector
Renames and re-exports [primitives/Selector](primitives/Selector.mdx)
***
### SerializationError
Re-exports [SerializationError](index/index.mdx#serializationerror)
***
### SHA256
Re-exports [SHA256](crypto/SHA256.mdx#sha256)
***
### SHA256Hash
Re-exports [SHA256Hash](index/index.mdx#sha256hash)
***
### SHA256HashType
Renames and re-exports [SHA256Hash](index/index.mdx#sha256hash)
***
### SignedData
Renames and re-exports [primitives/SignedData](primitives/SignedData.mdx)
***
### Siwe
Re-exports [Siwe](primitives/Siwe.mdx#siwe)
***
### Slot
Renames and re-exports [primitives/Slot](primitives/Slot.mdx)
***
### SourceMap
Renames and re-exports [primitives/SourceMap](primitives/SourceMap.mdx)
***
### Ssz
Re-exports [Ssz](Ssz.mdx)
***
### State
Renames and re-exports [primitives/State](primitives/State.mdx)
***
### StateDiff
Renames and re-exports [primitives/StateDiff](primitives/StateDiff.mdx)
***
### StealthAddress
Renames and re-exports [primitives/StealthAddress](primitives/StealthAddress.mdx)
***
### Storage
Re-exports [Storage](Storage.mdx)
***
### StorageDiff
Renames and re-exports [primitives/StorageDiff](primitives/StorageDiff.mdx)
***
### StorageKey
Re-exports [StorageKey](primitives/State.mdx#storagekey)
***
### StructLog
Renames and re-exports [primitives/StructLog](primitives/StructLog.mdx)
***
### SyncStatus
Renames and re-exports [primitives/SyncStatus](primitives/SyncStatus.mdx)
***
### TopicFilter
Renames and re-exports [primitives/TopicFilter](primitives/TopicFilter.mdx)
***
### TraceConfig
Renames and re-exports [primitives/TraceConfig](primitives/TraceConfig.mdx)
***
### TraceResult
Renames and re-exports [primitives/TraceResult](primitives/TraceResult.mdx)
***
### Transaction
Renames and re-exports [primitives/Transaction](primitives/Transaction/index.mdx)
***
### TransactionError
Re-exports [TransactionError](index/index.mdx#transactionerror)
***
### TransactionHash
Renames and re-exports [primitives/TransactionHash](primitives/TransactionHash.mdx)
***
### TransactionIndex
Renames and re-exports [primitives/TransactionIndex](primitives/TransactionIndex.mdx)
***
### TransactionStatus
Renames and re-exports [primitives/TransactionStatus](primitives/TransactionStatus.mdx)
***
### TransactionUrl
Re-exports [TransactionUrl](TransactionUrl.mdx)
***
### TypedData
Renames and re-exports [primitives/TypedData](primitives/TypedData.mdx)
***
### Uint
Re-exports [Uint](index/index.mdx#uint)
***
### Uint128
Re-exports [Uint128](index/index.mdx#uint128)
***
### Uint16
Re-exports [Uint16](index/index.mdx#uint16)
***
### Uint256
Renames and re-exports [primitives/Uint](primitives/Uint.mdx)
***
### Uint32
Re-exports [Uint32](index/index.mdx#uint32)
***
### Uint64
Re-exports [Uint64](index/index.mdx#uint64)
***
### Uint8
Re-exports [Uint8](index/index.mdx#uint8)
***
### Uncle
Renames and re-exports [primitives/Uncle](primitives/Uncle.mdx)
***
### ValidationError
Re-exports [ValidationError](index/index.mdx#validationerror)
***
### ValidatorIndex
Renames and re-exports [primitives/ValidatorIndex](primitives/ValidatorIndex.mdx)
***
### wasm
Re-exports [wasm](index/namespaces/wasm/index.mdx)
***
### Wei
Re-exports [Wei](index/index.mdx#wei-1)
***
### Withdrawal
Renames and re-exports [primitives/Withdrawal](primitives/Withdrawal.mdx)
***
### WithdrawalIndex
Renames and re-exports [primitives/WithdrawalIndex](primitives/WithdrawalIndex.mdx)
***
### X25519
Re-exports [X25519](crypto/X25519.mdx#x25519)
# primitives
Source: https://voltaire.tevm.sh/generated-api/primitives
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / primitives
# primitives
## References
### Abi
Re-exports [Abi](primitives/Abi/index.mdx#abi)
***
### AbstractError
Re-exports [AbstractError](index/index.mdx#abstracterror)
***
### AccessList
Re-exports [AccessList](primitives/AccessList.mdx#accesslist)
***
### Address
Re-exports [Address](primitives/Address.mdx#address)
***
### Authorization
Renames and re-exports [primitives/Authorization](primitives/Authorization.mdx)
***
### Base64
Renames and re-exports [primitives/Base64](primitives/Base64.mdx)
***
### BeaconBlockRoot
Renames and re-exports [primitives/BeaconBlockRoot](primitives/BeaconBlockRoot.mdx)
***
### BinaryTree
Renames and re-exports [primitives/BinaryTree](primitives/BinaryTree.mdx)
***
### Blob
Re-exports [Blob](primitives/Blob.mdx#blob)
***
### Block
Renames and re-exports [primitives/Block](primitives/Block.mdx)
***
### BlockBody
Renames and re-exports [primitives/BlockBody](primitives/BlockBody.mdx)
***
### BlockFilter
Renames and re-exports [primitives/BlockFilter](primitives/BlockFilter.mdx)
***
### BlockHash
Renames and re-exports [primitives/BlockHash](primitives/BlockHash.mdx)
***
### BlockHeader
Renames and re-exports [primitives/BlockHeader](primitives/BlockHeader.mdx)
***
### BlockNumber
Renames and re-exports [primitives/BlockNumber](primitives/BlockNumber.mdx)
***
### BloomFilter
Re-exports [BloomFilter](primitives/BloomFilter.mdx#bloomfilter)
***
### BrandedAbi
Renames and re-exports [primitives/Abi](primitives/Abi/index.mdx)
***
### BrandedAccessList
Renames and re-exports [primitives/AccessList](primitives/AccessList.mdx)
***
### BrandedAddress
Re-exports [BrandedAddress](index/namespaces/BrandedAddress/index.mdx)
***
### BrandedAuthorization
Renames and re-exports [primitives/Authorization](primitives/Authorization.mdx)
***
### BrandedBase64
Re-exports [BrandedBase64](index/namespaces/BrandedBase64.mdx)
***
### BrandedBinaryTree
Renames and re-exports [primitives/BinaryTree](primitives/BinaryTree.mdx)
***
### BrandedBlob
Renames and re-exports [primitives/Blob](primitives/Blob.mdx)
***
### BrandedBloomFilter
Renames and re-exports [primitives/BloomFilter](primitives/BloomFilter.mdx)
***
### BrandedBytecode
Renames and re-exports [primitives/Bytecode](primitives/Bytecode.mdx)
***
### BrandedBytes
Re-exports [BrandedBytes](index/namespaces/BrandedBytes.mdx)
***
### BrandedBytes1
Re-exports [BrandedBytes1](index/namespaces/BrandedBytes1.mdx)
***
### BrandedBytes16
Re-exports [BrandedBytes16](index/namespaces/BrandedBytes16.mdx)
***
### BrandedBytes2
Re-exports [BrandedBytes2](index/namespaces/BrandedBytes2.mdx)
***
### BrandedBytes3
Re-exports [BrandedBytes3](index/namespaces/BrandedBytes3.mdx)
***
### BrandedBytes32
Re-exports [BrandedBytes32](index/namespaces/BrandedBytes32.mdx)
***
### BrandedBytes4
Re-exports [BrandedBytes4](index/namespaces/BrandedBytes4.mdx)
***
### BrandedBytes5
Re-exports [BrandedBytes5](index/namespaces/BrandedBytes5.mdx)
***
### BrandedBytes6
Re-exports [BrandedBytes6](index/namespaces/BrandedBytes6.mdx)
***
### BrandedBytes64
Re-exports [BrandedBytes64](index/namespaces/BrandedBytes64.mdx)
***
### BrandedBytes7
Re-exports [BrandedBytes7](index/namespaces/BrandedBytes7.mdx)
***
### BrandedBytes8
Re-exports [BrandedBytes8](index/namespaces/BrandedBytes8.mdx)
***
### BrandedChain
Re-exports [BrandedChain](index/namespaces/BrandedChain.mdx)
***
### BrandedEther
Re-exports [BrandedEther](index/namespaces/BrandedEther.mdx)
***
### BrandedEventLog
Renames and re-exports [primitives/EventLog](primitives/EventLog.mdx)
***
### BrandedFeeMarket
Re-exports [BrandedFeeMarket](index/namespaces/BrandedFeeMarket.mdx)
***
### BrandedGwei
Re-exports [BrandedGwei](index/namespaces/BrandedGwei.mdx)
***
### BrandedHash
Renames and re-exports [primitives/Hash](primitives/Hash.mdx)
***
### BrandedHex
Re-exports [BrandedHex](index/namespaces/BrandedHex.mdx)
***
### BrandedInt128
Renames and re-exports [primitives/Int128](primitives/Int128.mdx)
***
### BrandedInt16
Renames and re-exports [primitives/Int16](primitives/Int16.mdx)
***
### BrandedInt256
Renames and re-exports [primitives/Int256](primitives/Int256.mdx)
***
### BrandedInt32
Renames and re-exports [primitives/Int32](primitives/Int32.mdx)
***
### BrandedInt64
Renames and re-exports [primitives/Int64](primitives/Int64.mdx)
***
### BrandedInt8
Renames and re-exports [primitives/Int8](primitives/Int8.mdx)
***
### BrandedOpcode
Re-exports [BrandedOpcode](index/namespaces/BrandedOpcode.mdx)
***
### BrandedRlp
Re-exports [BrandedRlp](index/namespaces/BrandedRlp.mdx)
***
### BrandedSiwe
Renames and re-exports [primitives/Siwe](primitives/Siwe.mdx)
***
### BrandedStorageKey
Renames and re-exports [primitives/State](primitives/State.mdx)
***
### BrandedUint
Renames and re-exports [primitives/Uint](primitives/Uint.mdx)
***
### BrandedUint128
Renames and re-exports [primitives/Uint128](primitives/Uint128.mdx)
***
### BrandedUint16
Renames and re-exports [primitives/Uint16](primitives/Uint16.mdx)
***
### BrandedUint32
Renames and re-exports [primitives/Uint32](primitives/Uint32.mdx)
***
### BrandedUint64
Renames and re-exports [primitives/Uint64](primitives/Uint64.mdx)
***
### BrandedUint8
Renames and re-exports [primitives/Uint8](primitives/Uint8.mdx)
***
### BrandedWei
Re-exports [BrandedWei](index/namespaces/BrandedWei.mdx)
***
### Bytecode
Re-exports [Bytecode](primitives/Bytecode.mdx#bytecode)
***
### Bytes
Re-exports [Bytes](index/index.mdx#bytes)
***
### Bytes1
Re-exports [Bytes1](index/namespaces/BrandedBytes1.mdx#bytes1)
***
### Bytes16
Re-exports [Bytes16](index/namespaces/BrandedBytes16.mdx#bytes16)
***
### Bytes2
Re-exports [Bytes2](index/index.mdx#bytes2)
***
### Bytes3
Re-exports [Bytes3](index/index.mdx#bytes3)
***
### Bytes32
Re-exports [Bytes32](index/namespaces/BrandedBytes32.mdx#bytes32)
***
### Bytes4
Re-exports [Bytes4](index/namespaces/BrandedBytes4.mdx#bytes4)
***
### Bytes5
Re-exports [Bytes5](index/index.mdx#bytes5)
***
### Bytes6
Re-exports [Bytes6](index/index.mdx#bytes6)
***
### Bytes64
Re-exports [Bytes64](index/namespaces/BrandedBytes64.mdx#bytes64)
***
### Bytes7
Re-exports [Bytes7](index/index.mdx#bytes7)
***
### Bytes8
Re-exports [Bytes8](index/namespaces/BrandedBytes8.mdx#bytes8)
***
### CallTrace
Renames and re-exports [primitives/CallTrace](primitives/CallTrace.mdx)
***
### Chain
Re-exports [Chain](index/namespaces/BrandedChain.mdx#chain-1)
***
### ChainHead
Renames and re-exports [primitives/ChainHead](primitives/ChainHead.mdx)
***
### CompilerVersion
Renames and re-exports [primitives/CompilerVersion](primitives/CompilerVersion.mdx)
***
### ContractCode
Renames and re-exports [primitives/ContractCode](primitives/ContractCode.mdx)
***
### ContractResult
Renames and re-exports [primitives/ContractResult](primitives/ContractResult.mdx)
***
### ContractSignature
Renames and re-exports [primitives/ContractSignature](primitives/ContractSignature.mdx)
***
### CryptoError
Re-exports [CryptoError](index/index.mdx#cryptoerror)
***
### DecodedData
Renames and re-exports [primitives/DecodedData](primitives/DecodedData.mdx)
***
### DecodingError
Re-exports [DecodingError](index/index.mdx#decodingerror)
***
### Domain
Renames and re-exports [primitives/Domain](primitives/Domain.mdx)
***
### DomainSeparator
Renames and re-exports [primitives/DomainSeparator](primitives/DomainSeparator.mdx)
***
### EncodedData
Renames and re-exports [primitives/EncodedData](primitives/EncodedData.mdx)
***
### EncodingError
Re-exports [EncodingError](index/index.mdx#encodingerror)
***
### Ens
Renames and re-exports [primitives/Ens](primitives/Ens.mdx)
***
### Epoch
Renames and re-exports [primitives/Epoch](primitives/Epoch.mdx)
***
### ErrorSignature
Renames and re-exports [primitives/ErrorSignature](primitives/ErrorSignature.mdx)
***
### Ether
Re-exports [Ether](index/index.mdx#ether-1)
***
### EventLog
Renames and re-exports [primitives/EventLog](primitives/EventLog.mdx)
***
### EventSignature
Renames and re-exports [primitives/EventSignature](primitives/EventSignature.mdx)
***
### FeeMarket
Re-exports [FeeMarket](index/namespaces/FeeMarket.mdx)
***
### FilterId
Renames and re-exports [primitives/FilterId](primitives/FilterId.mdx)
***
### ForkId
Renames and re-exports [primitives/ForkId](primitives/ForkId.mdx)
***
### FunctionSignature
Renames and re-exports [primitives/FunctionSignature](primitives/FunctionSignature.mdx)
***
### Gas
Renames and re-exports [primitives/Gas](primitives/Gas.mdx)
***
### GasConstants
Renames and re-exports [primitives/GasConstants](primitives/GasConstants/index.mdx)
***
### GasCosts
Re-exports [GasCosts](GasCosts.mdx)
***
### GasEstimate
Renames and re-exports [primitives/GasEstimate](primitives/GasEstimate.mdx)
***
### GasRefund
Renames and re-exports [primitives/GasRefund](primitives/GasRefund.mdx)
***
### GasUsed
Renames and re-exports [primitives/GasUsed](primitives/GasUsed.mdx)
***
### Gwei
Re-exports [Gwei](index/index.mdx#gwei-1)
***
### Hardfork
Renames and re-exports [primitives/Hardfork](primitives/Hardfork.mdx)
***
### Hash
Re-exports [Hash](index/index.mdx#hash)
***
### HashType
Re-exports [HashType](index/namespaces/HashType.mdx)
***
### Hex
Re-exports [Hex](index/index.mdx#hex)
***
### InitCode
Renames and re-exports [primitives/InitCode](primitives/InitCode.mdx)
***
### Int128
Re-exports [Int128](index/index.mdx#int128)
***
### Int16
Re-exports [Int16](index/index.mdx#int16)
***
### Int256
Re-exports [Int256](index/index.mdx#int256)
***
### Int32
Re-exports [Int32](index/index.mdx#int32)
***
### Int64
Re-exports [Int64](index/index.mdx#int64)
***
### Int8
Re-exports [Int8](index/index.mdx#int8)
***
### IntegerOverflowError
Re-exports [IntegerOverflowError](index/index.mdx#integeroverflowerror)
***
### IntegerUnderflowError
Re-exports [IntegerUnderflowError](index/index.mdx#integerunderflowerror)
***
### InvalidChecksumError
Re-exports [InvalidChecksumError](index/index.mdx#invalidchecksumerror)
***
### InvalidFormatError
Re-exports [InvalidFormatError](index/index.mdx#invalidformaterror)
***
### InvalidLengthError
Re-exports [InvalidLengthError](index/index.mdx#invalidlengtherror)
***
### InvalidPrivateKeyError
Re-exports [InvalidPrivateKeyError](index/index.mdx#invalidprivatekeyerror)
***
### InvalidPublicKeyError
Re-exports [InvalidPublicKeyError](index/index.mdx#invalidpublickeyerror)
***
### InvalidRangeError
Re-exports [InvalidRangeError](index/index.mdx#invalidrangeerror)
***
### InvalidSignatureError
Re-exports [InvalidSignatureError](index/index.mdx#invalidsignatureerror)
***
### InvalidSignerError
Re-exports [InvalidSignerError](index/index.mdx#invalidsignererror)
***
### InvalidSizeError
Re-exports [InvalidSizeError](index/index.mdx#invalidsizeerror)
***
### InvalidTransactionTypeError
Re-exports [InvalidTransactionTypeError](index/index.mdx#invalidtransactiontypeerror)
***
### License
Renames and re-exports [primitives/License](primitives/License.mdx)
***
### LogFilter
Renames and re-exports [primitives/LogFilter](primitives/LogFilter.mdx)
***
### LogIndex
Renames and re-exports [primitives/LogIndex](primitives/LogIndex.mdx)
***
### MemoryDump
Renames and re-exports [primitives/MemoryDump](primitives/MemoryDump.mdx)
***
### Metadata
Renames and re-exports [primitives/Metadata](primitives/Metadata.mdx)
***
### NetworkId
Renames and re-exports [primitives/NetworkId](primitives/NetworkId.mdx)
***
### NodeInfo
Renames and re-exports [primitives/NodeInfo](primitives/NodeInfo.mdx)
***
### Opcode
Re-exports [Opcode](index/index.mdx#opcode)
***
### OpStep
Renames and re-exports [primitives/OpStep](primitives/OpStep.mdx)
***
### PeerId
Renames and re-exports [primitives/PeerId](primitives/PeerId.mdx)
***
### PeerInfo
Renames and re-exports [primitives/PeerInfo](primitives/PeerInfo.mdx)
***
### PendingTransactionFilter
Renames and re-exports [primitives/PendingTransactionFilter](primitives/PendingTransactionFilter.mdx)
***
### Permit
Renames and re-exports [primitives/Permit](primitives/Permit/index.mdx)
***
### PrimitiveError
Re-exports [PrimitiveError](index/index.mdx#primitiveerror)
***
### ProtocolVersion
Renames and re-exports [primitives/ProtocolVersion](primitives/ProtocolVersion.mdx)
***
### Proxy
Re-exports [Proxy](Proxy.mdx)
***
### Receipt
Renames and re-exports [primitives/Receipt](primitives/Receipt.mdx)
***
### ReturnData
Renames and re-exports [primitives/ReturnData](primitives/ReturnData.mdx)
***
### RevertReason
Renames and re-exports [primitives/RevertReason](primitives/RevertReason.mdx)
***
### Rlp
Re-exports [Rlp](primitives/Rlp.mdx#rlp)
***
### RuntimeCode
Renames and re-exports [primitives/RuntimeCode](primitives/RuntimeCode.mdx)
***
### Selector
Renames and re-exports [primitives/Selector](primitives/Selector.mdx)
***
### SerializationError
Re-exports [SerializationError](index/index.mdx#serializationerror)
***
### SignedData
Renames and re-exports [primitives/SignedData](primitives/SignedData.mdx)
***
### Siwe
Re-exports [Siwe](primitives/Siwe.mdx#siwe)
***
### Slot
Renames and re-exports [primitives/Slot](primitives/Slot.mdx)
***
### SourceMap
Renames and re-exports [primitives/SourceMap](primitives/SourceMap.mdx)
***
### Ssz
Re-exports [Ssz](Ssz.mdx)
***
### State
Renames and re-exports [primitives/State](primitives/State.mdx)
***
### StateDiff
Renames and re-exports [primitives/StateDiff](primitives/StateDiff.mdx)
***
### StealthAddress
Renames and re-exports [primitives/StealthAddress](primitives/StealthAddress.mdx)
***
### Storage
Re-exports [Storage](Storage.mdx)
***
### StorageDiff
Renames and re-exports [primitives/StorageDiff](primitives/StorageDiff.mdx)
***
### StorageKey
Re-exports [StorageKey](primitives/State.mdx#storagekey)
***
### StructLog
Renames and re-exports [primitives/StructLog](primitives/StructLog.mdx)
***
### SyncStatus
Renames and re-exports [primitives/SyncStatus](primitives/SyncStatus.mdx)
***
### TopicFilter
Renames and re-exports [primitives/TopicFilter](primitives/TopicFilter.mdx)
***
### TraceConfig
Renames and re-exports [primitives/TraceConfig](primitives/TraceConfig.mdx)
***
### TraceResult
Renames and re-exports [primitives/TraceResult](primitives/TraceResult.mdx)
***
### Transaction
Renames and re-exports [primitives/Transaction](primitives/Transaction/index.mdx)
***
### TransactionError
Re-exports [TransactionError](index/index.mdx#transactionerror)
***
### TransactionHash
Renames and re-exports [primitives/TransactionHash](primitives/TransactionHash.mdx)
***
### TransactionIndex
Renames and re-exports [primitives/TransactionIndex](primitives/TransactionIndex.mdx)
***
### TransactionStatus
Renames and re-exports [primitives/TransactionStatus](primitives/TransactionStatus.mdx)
***
### TransactionUrl
Re-exports [TransactionUrl](TransactionUrl.mdx)
***
### TypedData
Renames and re-exports [primitives/TypedData](primitives/TypedData.mdx)
***
### Uint
Re-exports [Uint](index/index.mdx#uint)
***
### Uint128
Re-exports [Uint128](index/index.mdx#uint128)
***
### Uint16
Re-exports [Uint16](index/index.mdx#uint16)
***
### Uint256
Renames and re-exports [primitives/Uint](primitives/Uint.mdx)
***
### Uint32
Re-exports [Uint32](index/index.mdx#uint32)
***
### Uint64
Re-exports [Uint64](index/index.mdx#uint64)
***
### Uint8
Re-exports [Uint8](index/index.mdx#uint8)
***
### Uncle
Renames and re-exports [primitives/Uncle](primitives/Uncle.mdx)
***
### ValidationError
Re-exports [ValidationError](index/index.mdx#validationerror)
***
### ValidatorIndex
Renames and re-exports [primitives/ValidatorIndex](primitives/ValidatorIndex.mdx)
***
### Wei
Re-exports [Wei](index/index.mdx#wei-1)
***
### Withdrawal
Renames and re-exports [primitives/Withdrawal](primitives/Withdrawal.mdx)
***
### WithdrawalIndex
Renames and re-exports [primitives/WithdrawalIndex](primitives/WithdrawalIndex.mdx)
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / primitives/Abi
# primitives/Abi
## Namespaces
* [Constructor](namespaces/Constructor.mdx)
* [Error](namespaces/Error.mdx)
* [Event](namespaces/Event.mdx)
* [Function](namespaces/Function.mdx)
* [Item](namespaces/Item.mdx)
## Classes
### Abi
Defined in: [src/primitives/Abi/Abi.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L36)
Factory function for creating Abi instances
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Param
ABI items
#### Throws
#### Example
```javascript theme={null}
import { Abi } from './primitives/Abi/index.js';
const abi = Abi([
{ type: 'function', name: 'transfer', inputs: [...], outputs: [...] }
]);
```
#### Constructors
##### Constructor
> **new Abi**(`items`): [`Abi`](#abi)
Defined in: [src/primitives/Abi/Abi.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L36)
Factory function for creating Abi instances
###### Parameters
###### items
readonly `Item`\[]
ABI items
###### Returns
[`Abi`](#abi)
Abi instance
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import { Abi } from './primitives/Abi/index.js';
const abi = Abi([
{ type: 'function', name: 'transfer', inputs: [...], outputs: [...] }
]);
```
#### Properties
##### Constructor
> `static` **Constructor**: [`Constructor`](namespaces/Constructor.mdx)
Defined in: [src/primitives/Abi/Abi.js:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L71)
##### decode()
> `static` **decode**: (`this`, `functionName`, `data`) => readonly `unknown`\[]
Defined in: [src/primitives/Abi/Abi.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L55)
Decode function return values (branded ABI method)
###### Parameters
###### this
readonly `Item`\[]
###### functionName
`string`
Function name
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded return data
###### Returns
readonly `unknown`\[]
Decoded return values
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If function not found in ABI
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'balanceOf', outputs: [...] }];
const decoded = Abi.decode(abi, "balanceOf", encodedData);
```
##### decodeData()
> `static` **decodeData**: (`this`, `data`) => `object`
Defined in: [src/primitives/Abi/Abi.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L56)
Decode function call data and identify function (branded ABI method)
###### Parameters
###### this
readonly `Item`\[]
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded function call data
###### Returns
`object`
Decoded function name and arguments
###### args
> **args**: readonly `unknown`\[]
###### functionName
> **functionName**: `string`
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If data is too short to contain selector
###### Throws
If function with selector not found in ABI
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'transfer', inputs: [...] }];
const decoded = Abi.decodeData(abi, calldata);
// { functionName: "transfer", args: [address, amount] }
```
##### decodeParameters()
> `static` **decodeParameters**: \<`TParams`>(`params`, `data`) => `ParametersToPrimitiveTypes`\<`TParams`>
Defined in: [src/primitives/Abi/Abi.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L61)
###### Type Parameters
###### TParams
`TParams` *extends* readonly `Parameter`\[]
###### Parameters
###### params
`TParams`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`ParametersToPrimitiveTypes`\<`TParams`>
##### DecodeParameters()
> `static` **DecodeParameters**: \<`TParams`>(`params`, `data`) => `ParametersToPrimitiveTypes`\<`TParams`>
Defined in: [src/primitives/Abi/Abi.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L65)
###### Type Parameters
###### TParams
`TParams` *extends* readonly `Parameter`\[]
###### Parameters
###### params
`TParams`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`ParametersToPrimitiveTypes`\<`TParams`>
##### encode()
> `static` **encode**: (`this`, `functionName`, `args`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/Abi.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L54)
Encode function call data (branded ABI method)
###### Parameters
###### this
readonly `Item`\[]
###### functionName
`string`
Function name to encode
###### args
readonly `unknown`\[]
Function arguments
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded function call data
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If function not found in ABI
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'transfer', inputs: [...] }];
const encoded = Abi.encode(abi, "transfer", [address, amount]);
```
##### encodeParameters()
> `static` **encodeParameters**: \<`TParams`>(`params`, `values`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/Abi.js:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L60)
###### Type Parameters
###### TParams
`TParams` *extends* readonly `Parameter`\[]
###### Parameters
###### params
`TParams`
###### values
`ParametersToPrimitiveTypes`\<`TParams`>
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### Error
> `static` **Error**: `object`
Defined in: [src/primitives/Abi/Abi.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L70)
###### decodeParams()
> **decodeParams**: \<`TName`, `TInputs`>(`error`, `data`) => `ParametersToPrimitiveTypes`\<`TInputs`>
Decode error parameters from encoded data
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](namespaces/Error.mdx#errortype)\<`TName`, `TInputs`>
ABI error definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with selector prefix
###### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
Decoded parameter values
###### Throws
If data is too short for selector
###### Throws
If selector doesn't match expected
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const decoded = decodeParams(error, encodedData); // [100n]
```
###### encodeParams()
> **encodeParams**: \<`TName`, `TInputs`>(`error`, `args`) => `Uint8Array`\<`ArrayBufferLike`>
Encode error parameters with selector prefix
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](namespaces/Error.mdx#errortype)\<`TName`, `TInputs`>
ABI error definition
###### args
`ParametersToPrimitiveTypes`\<`TInputs`>
Parameter values to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with 4-byte selector prefix
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const encoded = encodeParams(error, [100n]); // Uint8Array with selector + encoded params
```
###### getSelector()
> **getSelector**: (`error`) => `Uint8Array`
###### Parameters
###### error
`any`
###### Returns
`Uint8Array`
###### GetSelector()
> **GetSelector**: (`deps`) => (`error`) => `Uint8Array`
Factory: Get the 4-byte selector for an error
###### Parameters
###### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that computes error selector
> (`error`): `Uint8Array`
###### Parameters
###### error
`any`
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/error/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const error = { type: "error", name: "Unauthorized", inputs: [] };
const selector = getSelector(error);
```
###### getSignature()
> **getSignature**: \<`TName`, `TInputs`>(`error`) => `string`
Get the signature string for an error (e.g., "MyError(uint256,address)")
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](namespaces/Error.mdx#errortype)\<`TName`, `TInputs`>
ABI error definition
###### Returns
`string`
Error signature string
###### Example
```typescript theme={null}
const error = { type: "error", name: "Unauthorized", inputs: [{ type: "address", name: "sender" }] };
const sig = getSignature(error); // "Unauthorized(address)"
```
##### Event
> `static` **Event**: `object`
Defined in: [src/primitives/Abi/Abi.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L69)
###### decodeLog()
> **decodeLog**: (`event`, `data`, `topics`) => [`DecodeLogResult`](namespaces/Event.mdx#decodelogresult)\<`any`>
Decode event log data and topics into event arguments
###### Parameters
###### event
[`EventType`](namespaces/Event.mdx#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
###### topics
readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
###### Returns
[`DecodeLogResult`](namespaces/Event.mdx#decodelogresult)\<`any`>
Decoded event arguments
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If topics are missing or invalid
###### Throws
If event selector doesn't match topic0
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
###### DecodeLog()
> **DecodeLog**: (`event`, `data`, `topics`) => [`DecodeLogResult`](namespaces/Event.mdx#decodelogresult)\<`any`> = `decodeLog`
Decode event log data and topics into event arguments
###### Parameters
###### event
[`EventType`](namespaces/Event.mdx#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
###### topics
readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
###### Returns
[`DecodeLogResult`](namespaces/Event.mdx#decodelogresult)\<`any`>
Decoded event arguments
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If topics are missing or invalid
###### Throws
If event selector doesn't match topic0
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
###### encodeTopics()
> **encodeTopics**: (`event`, `args`) => ([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### EncodeTopics()
> **EncodeTopics**: (`deps`) => (`event`, `args`) => ([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
Factory: Encode event arguments into topics array
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that encodes event topics
> (`event`, `args`): ([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Example
```typescript theme={null}
import { EncodeTopics } from './primitives/Abi/event/index.js';
import { hash as keccak256, keccak256String } from './primitives/Hash/index.js';
const encodeTopics = EncodeTopics({ keccak256, keccak256String });
const event = { type: "event", name: "Transfer", inputs: [...], anonymous: false };
const topics = encodeTopics(event, { from: "0x...", to: "0x..." });
// [selector, encodedFrom, encodedTo]
```
###### getSelector()
> **getSelector**: (`event`) => [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Factory function for creating Event instances
Note: Event is a plain object, not a class instance
This namespace provides convenient methods for working with events
###### Parameters
###### event
`any`
###### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = {
type: 'event',
name: 'Transfer',
inputs: [
{ type: 'address', name: 'from', indexed: true },
{ type: 'address', name: 'to', indexed: true },
{ type: 'uint256', name: 'value' }
]
};
const selector = Abi.Event.getSelector(event);
```
###### GetSelector()
> **GetSelector**: (`deps`) => (`event`) => [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Factory: Get event selector (keccak256 hash of signature)
###### Parameters
###### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that computes event selector
> (`event`): [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### event
`any`
###### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/event/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const event = { type: "event", name: "Transfer", inputs: [{ type: "address", indexed: true }] };
const selector = getSelector(event);
```
###### getSignature()
> **getSignature**: (`event`) => `string`
Get event signature string (e.g., "Transfer(address,address,uint256)")
###### Parameters
###### event
[`EventType`](namespaces/Event.mdx#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### Returns
`string`
Event signature
###### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
###### Signature()
> **Signature**: (`event`) => `string` = `getSignature`
Get event signature string (e.g., "Transfer(address,address,uint256)")
###### Parameters
###### event
[`EventType`](namespaces/Event.mdx#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### Returns
`string`
Event signature
###### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
###### Topics()
> **Topics**: (`event`, `args`) => ([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[] = `encodeTopics`
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
##### format()
> `static` **format**: (`item`) => `string`
Defined in: [src/primitives/Abi/Abi.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L52)
Format an ABI item as a human-readable string
###### Parameters
###### item
`Item`
ABI item to format
###### Returns
`string`
Formatted string representation
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const formatted = Abi.Item.format({
type: 'function',
name: 'transfer',
inputs: [{ type: 'address', name: 'to' }, { type: 'uint256', name: 'amount' }],
outputs: [{ type: 'bool' }]
});
// => "function transfer(address to, uint256 amount) returns (bool)"
```
##### formatWithArgs()
> `static` **formatWithArgs**: (`item`, `args`) => `string`
Defined in: [src/primitives/Abi/Abi.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L53)
Format an ABI item with arguments as a human-readable string
###### Parameters
###### item
`Item`
ABI item to format
###### args
readonly `unknown`\[]
Arguments to display
###### Returns
`string`
Formatted string with arguments
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const formatted = Abi.Item.formatWithArgs(
{ type: 'function', name: 'transfer', inputs: [{ type: 'address' }, { type: 'uint256' }] },
['0x123...', 100n]
);
// => "transfer(0x123..., 100)"
```
##### Function
> `static` **Function**: *typeof* [`Function`](namespaces/Function.mdx#function)
Defined in: [src/primitives/Abi/Abi.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L68)
##### getItem()
> `static` **getItem**: \<`TAbi`, `TName`, `TType`>(`abi`, `name`, `type?`) => `Extract`\<`TAbi`\[`number`], \{ `name`: `TName`; }> | `undefined`
Defined in: [src/primitives/Abi/Abi.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L51)
Get a specific ABI item by name and optional type
###### Type Parameters
###### TAbi
`TAbi` *extends* readonly `Item`\[]
###### TName
`TName` *extends* `string`
###### TType
`TType` *extends* `"function"` | `"event"` | `"constructor"` | `"error"` | `"fallback"` | `"receive"` | `undefined`
###### Parameters
###### abi
`TAbi`
ABI array to search
###### name
`TName`
Name of the item to find
###### type?
`TType`
Optional type filter (function, event, error, constructor)
###### Returns
`Extract`\<`TAbi`\[`number`], \{ `name`: `TName`; }> | `undefined`
The found item or undefined
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const transferFn = Abi.Item.getItem(abi, 'transfer', 'function');
const transferEvent = Abi.Item.getItem(abi, 'Transfer', 'event');
```
##### Item
> `static` **Item**: [`Item`](namespaces/Item.mdx)
Defined in: [src/primitives/Abi/Abi.js:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L72)
##### Parameters()
> `static` **Parameters**: \<`TParams`>(`params`, `values`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/Abi.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L64)
###### Type Parameters
###### TParams
`TParams` *extends* readonly `Parameter`\[]
###### Parameters
###### params
`TParams`
###### values
`ParametersToPrimitiveTypes`\<`TParams`>
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### parseLogs()
> `static` **parseLogs**: (`this`, `logs`) => readonly `object`\[]
Defined in: [src/primitives/Abi/Abi.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L57)
Parse event logs (branded ABI method)
###### Parameters
###### this
readonly `Item`\[]
###### logs
readonly `object`\[]
Array of log objects
###### Returns
readonly `object`\[]
Parsed event logs
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'event', name: 'Transfer', inputs: [...] }];
const parsed = Abi.parseLogs(abi, logs);
// [{ eventName: "Transfer", args: { from, to, value } }]
```
#### Methods
##### decode()
> **decode**(`functionName`, `data`): readonly `unknown`\[]
Defined in: [src/primitives/Abi/Abi.js:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L107)
###### Parameters
###### functionName
`string`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
readonly `unknown`\[]
##### decodeData()
> **decodeData**(`data`): `object`
Defined in: [src/primitives/Abi/Abi.js:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L112)
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`object`
###### args
> **args**: readonly `unknown`\[]
###### functionName
> **functionName**: `string`
##### encode()
> **encode**(`functionName`, `args`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/Abi.js:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L102)
###### Parameters
###### functionName
`string`
###### args
`unknown`\[]
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### format()
> **format**(): `any`
Defined in: [src/primitives/Abi/Abi.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L83)
###### Returns
`any`
##### formatWithArgs()
> **formatWithArgs**(`args`): `any`
Defined in: [src/primitives/Abi/Abi.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L90)
###### Parameters
###### args
`Record`\<`string`, `unknown`\[]>
###### Returns
`any`
##### getConstructor()
> **getConstructor**(): `any`
Defined in: [src/primitives/Abi/Abi.js:137](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L137)
###### Returns
`any`
##### getError()
> **getError**(`name`): `any`
Defined in: [src/primitives/Abi/Abi.js:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L133)
###### Parameters
###### name
`string`
###### Returns
`any`
##### getEvent()
> **getEvent**(`name`): `any`
Defined in: [src/primitives/Abi/Abi.js:128](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L128)
###### Parameters
###### name
`string`
###### Returns
`any`
##### getFallback()
> **getFallback**(): `any`
Defined in: [src/primitives/Abi/Abi.js:143](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L143)
###### Returns
`any`
##### getFunction()
> **getFunction**(`name`): `any`
Defined in: [src/primitives/Abi/Abi.js:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L123)
###### Parameters
###### name
`string`
###### Returns
`any`
##### getItem()
> **getItem**(`name`, `type?`): `any`
Defined in: [src/primitives/Abi/Abi.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L79)
###### Parameters
###### name
`string`
###### type?
`"function"` | `"event"` | `"constructor"` | `"error"` | `"fallback"` | `"receive"`
###### Returns
`any`
##### getReceive()
> **getReceive**(): `any`
Defined in: [src/primitives/Abi/Abi.js:149](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L149)
###### Returns
`any`
##### parseLogs()
> **parseLogs**(`logs`): readonly `object`\[]
Defined in: [src/primitives/Abi/Abi.js:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L117)
###### Parameters
###### logs
readonly `object`\[]
###### Returns
readonly `object`\[]
##### toString()
> **toString**(): `string`
Defined in: [src/primitives/Abi/Abi.js:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L162)
###### Returns
`string`
##### from()
> `static` **from**(`items`): `any`
Defined in: [src/primitives/Abi/Abi.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Abi.js#L44)
###### Parameters
###### items
readonly [`ItemType`](namespaces/Item.mdx#itemtype)\[]
###### Returns
`any`
## Type Aliases
### WrappedErrorType
> **WrappedErrorType** = `object`
Defined in: [src/primitives/Abi/error/wrapped/WrappedErrorType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/WrappedErrorType.ts#L14)
ERC-7751 Wrapped Error type
Represents a wrapped execution error with additional context about the failing contract,
function, and original revert reason.
#### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
#### Since
0.0.0
#### Properties
##### details
> **details**: [`BytesType`](../Bytes.mdx#bytestype)
Defined in: [src/primitives/Abi/error/wrapped/WrappedErrorType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/WrappedErrorType.ts#L22)
Additional error details/context
##### reason
> **reason**: [`BytesType`](../Bytes.mdx#bytestype)
Defined in: [src/primitives/Abi/error/wrapped/WrappedErrorType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/WrappedErrorType.ts#L20)
Original revert reason data
##### selector
> **selector**: [`SelectorType`](../Selector.mdx#selectortype)
Defined in: [src/primitives/Abi/error/wrapped/WrappedErrorType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/WrappedErrorType.ts#L18)
Function selector that was called
##### target
> **target**: [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Abi/error/wrapped/WrappedErrorType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/WrappedErrorType.ts#L16)
Address of contract that reverted
## Variables
### ERC1155InsufficientBalance
> `const` **ERC1155InsufficientBalance**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L14)
Insufficient balance for transfer
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }, \{ `name`: `"balance"`; `type`: `"uint256"`; }, \{ `name`: `"needed"`; `type`: `"uint256"`; }, \{ `name`: `"tokenId"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC1155InsufficientBalance"` = `"ERC1155InsufficientBalance"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155InvalidApprover
> `const` **ERC1155InvalidApprover**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L62)
Invalid approver address
error ERC1155InvalidApprover(address approver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"approver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC1155InvalidApprover"` = `"ERC1155InvalidApprover"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155InvalidArrayLength
> `const` **ERC1155InvalidArrayLength**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L82)
Array length mismatch
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"idsLength"`; `type`: `"uint256"`; }, \{ `name`: `"valuesLength"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC1155InvalidArrayLength"` = `"ERC1155InvalidArrayLength"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155InvalidOperator
> `const` **ERC1155InvalidOperator**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L72)
Invalid operator address
error ERC1155InvalidOperator(address operator)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"operator"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC1155InvalidOperator"` = `"ERC1155InvalidOperator"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155InvalidReceiver
> `const` **ERC1155InvalidReceiver**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L39)
Invalid receiver address
error ERC1155InvalidReceiver(address receiver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"receiver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC1155InvalidReceiver"` = `"ERC1155InvalidReceiver"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155InvalidSender
> `const` **ERC1155InvalidSender**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L29)
Invalid sender address
error ERC1155InvalidSender(address sender)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC1155InvalidSender"` = `"ERC1155InvalidSender"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC1155MissingApprovalForAll
> `const` **ERC1155MissingApprovalForAll**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC1155Errors.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC1155Errors.ts#L49)
Missing approval for all tokens
error ERC1155MissingApprovalForAll(address operator, address owner)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"operator"`; `type`: `"address"`; }, \{ `name`: `"owner"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC1155MissingApprovalForAll"` = `"ERC1155MissingApprovalForAll"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InsufficientAllowance
> `const` **ERC20InsufficientAllowance**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L48)
Insufficient allowance for transfer
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"spender"`; `type`: `"address"`; }, \{ `name`: `"allowance"`; `type`: `"uint256"`; }, \{ `name`: `"needed"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC20InsufficientAllowance"` = `"ERC20InsufficientAllowance"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InsufficientBalance
> `const` **ERC20InsufficientBalance**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L14)
Insufficient balance for transfer
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }, \{ `name`: `"balance"`; `type`: `"uint256"`; }, \{ `name`: `"needed"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC20InsufficientBalance"` = `"ERC20InsufficientBalance"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InvalidApprover
> `const` **ERC20InvalidApprover**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L62)
Invalid approver address
error ERC20InvalidApprover(address approver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"approver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC20InvalidApprover"` = `"ERC20InvalidApprover"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InvalidReceiver
> `const` **ERC20InvalidReceiver**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L38)
Invalid receiver address
error ERC20InvalidReceiver(address receiver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"receiver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC20InvalidReceiver"` = `"ERC20InvalidReceiver"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InvalidSender
> `const` **ERC20InvalidSender**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L28)
Invalid sender address
error ERC20InvalidSender(address sender)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC20InvalidSender"` = `"ERC20InvalidSender"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC20InvalidSpender
> `const` **ERC20InvalidSpender**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC20Errors.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC20Errors.ts#L72)
Invalid spender address
error ERC20InvalidSpender(address spender)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"spender"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC20InvalidSpender"` = `"ERC20InvalidSpender"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721IncorrectOwner
> `const` **ERC721IncorrectOwner**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L34)
Sender is not the owner
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }, \{ `name`: `"tokenId"`; `type`: `"uint256"`; }, \{ `name`: `"owner"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721IncorrectOwner"` = `"ERC721IncorrectOwner"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InsufficientApproval
> `const` **ERC721InsufficientApproval**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L68)
Insufficient approval for operation
error ERC721InsufficientApproval(address operator, uint256 tokenId)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"operator"`; `type`: `"address"`; }, \{ `name`: `"tokenId"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC721InsufficientApproval"` = `"ERC721InsufficientApproval"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InvalidApprover
> `const` **ERC721InvalidApprover**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L81)
Invalid approver address
error ERC721InvalidApprover(address approver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"approver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721InvalidApprover"` = `"ERC721InvalidApprover"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InvalidOperator
> `const` **ERC721InvalidOperator**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L91)
Invalid operator address
error ERC721InvalidOperator(address operator)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"operator"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721InvalidOperator"` = `"ERC721InvalidOperator"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InvalidOwner
> `const` **ERC721InvalidOwner**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L14)
Invalid owner address
error ERC721InvalidOwner(address owner)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"owner"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721InvalidOwner"` = `"ERC721InvalidOwner"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InvalidReceiver
> `const` **ERC721InvalidReceiver**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L58)
Invalid receiver address
error ERC721InvalidReceiver(address receiver)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"receiver"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721InvalidReceiver"` = `"ERC721InvalidReceiver"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721InvalidSender
> `const` **ERC721InvalidSender**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L48)
Invalid sender address
error ERC721InvalidSender(address sender)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"sender"`; `type`: `"address"`; }]
##### name
> `readonly` **name**: `"ERC721InvalidSender"` = `"ERC721InvalidSender"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### ERC721NonexistentToken
> `const` **ERC721NonexistentToken**: `object`
Defined in: [src/primitives/Abi/error/standards/ERC721Errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/standards/ERC721Errors.ts#L24)
Token does not exist
error ERC721NonexistentToken(uint256 tokenId)
#### Type Declaration
##### inputs
> `readonly` **inputs**: readonly \[\{ `name`: `"tokenId"`; `type`: `"uint256"`; }]
##### name
> `readonly` **name**: `"ERC721NonexistentToken"` = `"ERC721NonexistentToken"`
##### type
> `readonly` **type**: `"error"` = `"error"`
***
### Interface
> `const` **Interface**: `object`
Defined in: [src/primitives/Abi/interface/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/interface/index.ts#L19)
#### Type Declaration
##### ERC1155\_INTERFACE\_ID
> **ERC1155\_INTERFACE\_ID**: [`SelectorType`](../Selector.mdx#selectortype)
ERC-1155 Multi Token Standard interface ID
###### See
[https://eips.ethereum.org/EIPS/eip-1155](https://eips.ethereum.org/EIPS/eip-1155)
##### ERC165\_INTERFACE\_ID
> **ERC165\_INTERFACE\_ID**: [`SelectorType`](../Selector.mdx#selectortype)
ERC-165 supportsInterface(bytes4) interface ID
###### See
[https://eips.ethereum.org/EIPS/eip-165](https://eips.ethereum.org/EIPS/eip-165)
##### ERC20\_INTERFACE\_ID
> **ERC20\_INTERFACE\_ID**: [`SelectorType`](../Selector.mdx#selectortype)
ERC-20 Token Standard interface ID
###### See
[https://eips.ethereum.org/EIPS/eip-20](https://eips.ethereum.org/EIPS/eip-20)
##### ERC721\_INTERFACE\_ID
> **ERC721\_INTERFACE\_ID**: [`SelectorType`](../Selector.mdx#selectortype)
ERC-721 Non-Fungible Token Standard interface ID
###### See
[https://eips.ethereum.org/EIPS/eip-721](https://eips.ethereum.org/EIPS/eip-721)
##### getInterfaceId()
> **getInterfaceId**: (`selectors`) => [`SelectorType`](../Selector.mdx#selectortype)
Calculate ERC-165 interface ID from function selectors
Interface ID is computed by XORing all function selectors in the interface.
Per ERC-165 specification.
###### Parameters
###### selectors
[`SelectorLike`](../Selector.mdx#selectorlike)\[]
Array of function selectors
###### Returns
[`SelectorType`](../Selector.mdx#selectortype)
Interface ID (4-byte XOR result)
###### Throws
If no selectors provided
###### See
[https://eips.ethereum.org/EIPS/eip-165](https://eips.ethereum.org/EIPS/eip-165)
###### Example
```javascript theme={null}
import * as Interface from './primitives/Abi/interface/index.js';
// ERC-20 interface
const erc20 = Interface.getInterfaceId([
'0x70a08231', // balanceOf(address)
'0x095ea7b3', // approve(address,uint256)
'0xa9059cbb', // transfer(address,uint256)
'0xdd62ed3e', // allowance(address,address)
'0x23b872dd', // transferFrom(address,address,uint256)
'0x18160ddd', // totalSupply()
]);
// Returns ERC20_INTERFACE_ID: 0x36372b07
```
***
### WRAPPED\_ERROR\_SELECTOR
> `const` **WRAPPED\_ERROR\_SELECTOR**: [`SelectorType`](../Selector.mdx#selectortype)
Defined in: [src/primitives/Abi/error/wrapped/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/constants.js#L11)
ERC-7751 WrappedError selector
Selector for: error WrappedError(address target, bytes4 selector, bytes reason, bytes details)
#### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
***
### WrappedError
> `const` **WrappedError**: `object`
Defined in: [src/primitives/Abi/error/wrapped/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/index.ts#L21)
#### Type Declaration
##### decodeWrappedError()
> **decodeWrappedError**: (`data`) => [`WrappedErrorType`](#wrappederrortype)
Decode ERC-7751 wrapped error data
Decodes a WrappedError from encoded bytes following the ERC-7751 specification.
Expects data to start with the WrappedError selector (0x90bfb865).
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data (selector + ABI-encoded params)
###### Returns
[`WrappedErrorType`](#wrappederrortype)
Decoded wrapped error
###### Throws
If selector doesn't match or data is invalid
###### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
###### Example
```javascript theme={null}
import * as WrappedError from './primitives/Abi/error/wrapped/index.js';
const decoded = WrappedError.decodeWrappedError(errorData);
console.log(decoded.target); // Address of failing contract
console.log(decoded.selector); // Function selector
console.log(decoded.reason); // Original revert reason
```
##### encodeWrappedError()
> **encodeWrappedError**: (`wrappedError`) => `Uint8Array`\<`ArrayBufferLike`>
Encode ERC-7751 wrapped error data
Encodes a WrappedError following the ERC-7751 specification:
error WrappedError(address target, bytes4 selector, bytes reason, bytes details)
###### Parameters
###### wrappedError
[`WrappedErrorType`](#wrappederrortype)
Wrapped error data
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data (selector + ABI-encoded params)
###### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
###### Example
```javascript theme={null}
import * as WrappedError from './primitives/Abi/error/wrapped/index.js';
import * as Address from './primitives/Address/index.js';
import * as Selector from './primitives/Selector/index.js';
const encoded = WrappedError.encodeWrappedError({
target: Address.from('0x1234...'),
selector: Selector.fromHex('0xabcd1234'),
reason: new Uint8Array([...]),
details: new Uint8Array([...])
});
```
##### WRAPPED\_ERROR\_SELECTOR
> **WRAPPED\_ERROR\_SELECTOR**: [`SelectorType`](../Selector.mdx#selectortype)
ERC-7751 WrappedError selector
Selector for: error WrappedError(address target, bytes4 selector, bytes reason, bytes details)
###### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
## Functions
### decode()
> **decode**(`this`, `functionName`, `data`): readonly `unknown`\[]
Defined in: [src/primitives/Abi/decode.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/decode.js#L23)
Decode function return values (branded ABI method)
#### Parameters
##### this
readonly `Item`\[]
##### functionName
`string`
Function name
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded return data
#### Returns
readonly `unknown`\[]
Decoded return values
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If function not found in ABI
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'balanceOf', outputs: [...] }];
const decoded = Abi.decode(abi, "balanceOf", encodedData);
```
***
### decodeData()
> **decodeData**(`this`, `data`): `object`
Defined in: [src/primitives/Abi/decodeData.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/decodeData.js#L25)
Decode function call data and identify function (branded ABI method)
#### Parameters
##### this
readonly `Item`\[]
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded function call data
#### Returns
`object`
Decoded function name and arguments
##### args
> **args**: readonly `unknown`\[]
##### functionName
> **functionName**: `string`
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If data is too short to contain selector
#### Throws
If function with selector not found in ABI
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'transfer', inputs: [...] }];
const decoded = Abi.decodeData(abi, calldata);
// { functionName: "transfer", args: [address, amount] }
```
***
### decodeParameters()
> **decodeParameters**\<`TParams`>(`params`, `data`): `ParametersToPrimitiveTypes`\<`TParams`>
Defined in: [src/primitives/Abi/decodeParameters.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/decodeParameters.js#L14)
#### Type Parameters
##### TParams
`TParams` *extends* readonly `Parameter`\[]
#### Parameters
##### params
`TParams`
##### data
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`ParametersToPrimitiveTypes`\<`TParams`>
***
### DecodeParameters()
> **DecodeParameters**\<`TParams`>(`params`, `data`): `ParametersToPrimitiveTypes`\<`TParams`>
Defined in: [src/primitives/Abi/decodeParameters.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/decodeParameters.js#L14)
#### Type Parameters
##### TParams
`TParams` *extends* readonly `Parameter`\[]
#### Parameters
##### params
`TParams`
##### data
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
`ParametersToPrimitiveTypes`\<`TParams`>
***
### decodeWrappedError()
> **decodeWrappedError**(`data`): [`WrappedErrorType`](#wrappederrortype)
Defined in: [src/primitives/Abi/error/wrapped/decodeWrappedError.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/decodeWrappedError.js#L26)
Decode ERC-7751 wrapped error data
Decodes a WrappedError from encoded bytes following the ERC-7751 specification.
Expects data to start with the WrappedError selector (0x90bfb865).
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data (selector + ABI-encoded params)
#### Returns
[`WrappedErrorType`](#wrappederrortype)
Decoded wrapped error
#### Throws
If selector doesn't match or data is invalid
#### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
#### Example
```javascript theme={null}
import * as WrappedError from './primitives/Abi/error/wrapped/index.js';
const decoded = WrappedError.decodeWrappedError(errorData);
console.log(decoded.target); // Address of failing contract
console.log(decoded.selector); // Function selector
console.log(decoded.reason); // Original revert reason
```
***
### encode()
> **encode**(`this`, `functionName`, `args`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/encode.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/encode.js#L22)
Encode function call data (branded ABI method)
#### Parameters
##### this
readonly `Item`\[]
##### functionName
`string`
Function name to encode
##### args
readonly `unknown`\[]
Function arguments
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded function call data
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If function not found in ABI
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'function', name: 'transfer', inputs: [...] }];
const encoded = Abi.encode(abi, "transfer", [address, amount]);
```
***
### encodeParameters()
> **encodeParameters**\<`TParams`>(`params`, `values`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/encodeParameters.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/encodeParameters.js#L15)
#### Type Parameters
##### TParams
`TParams` *extends* readonly `Parameter`\[]
#### Parameters
##### params
`TParams`
##### values
`ParametersToPrimitiveTypes`\<`TParams`>
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
***
### encodeWrappedError()
> **encodeWrappedError**(`wrappedError`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/error/wrapped/encodeWrappedError.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/wrapped/encodeWrappedError.js#L27)
Encode ERC-7751 wrapped error data
Encodes a WrappedError following the ERC-7751 specification:
error WrappedError(address target, bytes4 selector, bytes reason, bytes details)
#### Parameters
##### wrappedError
[`WrappedErrorType`](#wrappederrortype)
Wrapped error data
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data (selector + ABI-encoded params)
#### See
[https://eips.ethereum.org/EIPS/eip-7751](https://eips.ethereum.org/EIPS/eip-7751)
#### Example
```javascript theme={null}
import * as WrappedError from './primitives/Abi/error/wrapped/index.js';
import * as Address from './primitives/Address/index.js';
import * as Selector from './primitives/Selector/index.js';
const encoded = WrappedError.encodeWrappedError({
target: Address.from('0x1234...'),
selector: Selector.fromHex('0xabcd1234'),
reason: new Uint8Array([...]),
details: new Uint8Array([...])
});
```
***
### Parameters()
> **Parameters**\<`TParams`>(`params`, `values`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/encodeParameters.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/encodeParameters.js#L15)
#### Type Parameters
##### TParams
`TParams` *extends* readonly `Parameter`\[]
#### Parameters
##### params
`TParams`
##### values
`ParametersToPrimitiveTypes`\<`TParams`>
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
***
### parseLogs()
> **parseLogs**(`this`, `logs`): readonly `object`\[]
Defined in: [src/primitives/Abi/parseLogs.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/parseLogs.js#L21)
Parse event logs (branded ABI method)
#### Parameters
##### this
readonly `Item`\[]
##### logs
readonly `object`\[]
Array of log objects
#### Returns
readonly `object`\[]
Parsed event logs
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const abi = [{ type: 'event', name: 'Transfer', inputs: [...] }];
const parsed = Abi.parseLogs(abi, logs);
// [{ eventName: "Transfer", args: { from, to, value } }]
```
# Constructor
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/namespaces/Constructor
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Abi](../index.mdx) / Constructor
# Constructor
## Classes
### Constructor
Defined in: [src/primitives/Abi/constructor/Constructor.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L14)
Factory function for creating Constructor instances
#### Template
#### Template
#### Param
#### Param
#### Param
#### Param
#### Type Parameters
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](Function.mdx#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\[]
#### Constructors
##### Constructor
> **new Constructor**\<`TStateMutability`, `TInputs`>(`options`): [`Constructor`](#constructor)\<`TStateMutability`, `TInputs`>
Defined in: [src/primitives/Abi/constructor/Constructor.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L14)
Factory function for creating Constructor instances
###### Parameters
###### options
###### inputs
`TInputs`
###### stateMutability
`TStateMutability`
###### type?
`"constructor"` = `"constructor"`
###### Returns
[`Constructor`](#constructor)\<`TStateMutability`, `TInputs`>
#### Properties
##### decodeParams()
> `static` **decodeParams**: (`constructor`, `data`) => `any`\[]
Defined in: [src/primitives/Abi/constructor/Constructor.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L22)
Decode constructor parameters
###### Parameters
###### constructor
[`ConstructorType`](#constructortype)\<[`StateMutability`](Function.mdx#statemutability-1), readonly `Parameter`\[]>
Constructor definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded data to decode
###### Returns
`any`\[]
Decoded parameters
###### Example
```typescript theme={null}
const constructor = {
type: "constructor",
stateMutability: "nonpayable",
inputs: [{ type: "uint256" }]
};
const decoded = Constructor.decodeParams(constructor, encodedData);
```
##### encodeParams()
> `static` **encodeParams**: (`constructor`, `args`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/constructor/Constructor.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L21)
Encode constructor parameters
###### Parameters
###### constructor
[`ConstructorType`](#constructortype)\<[`StateMutability`](Function.mdx#statemutability-1), readonly `Parameter`\[]>
Constructor definition
###### args
`unknown`\[]
Arguments to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded parameters
###### Example
```typescript theme={null}
const constructor = {
type: "constructor",
stateMutability: "nonpayable",
inputs: [{ type: "uint256" }]
};
const encoded = Constructor.encodeParams(constructor, [123n]);
```
#### Methods
##### decodeParams()
> **decodeParams**(`data`): `any`\[]
Defined in: [src/primitives/Abi/constructor/Constructor.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L34)
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### Returns
`any`\[]
##### encodeParams()
> **encodeParams**(`args`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/constructor/Constructor.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L29)
###### Parameters
###### args
`unknown`\[]
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### toString()
> **toString**(): `string`
Defined in: [src/primitives/Abi/constructor/Constructor.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/Constructor.js#L49)
###### Returns
`string`
## Interfaces
### ConstructorInstance
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L19)
Constructor instance with methods (returned by Constructor factory)
#### Extends
* [`ConstructorType`](#constructortype)\<`TStateMutability`, `TInputs`>
#### Type Parameters
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](Function.mdx#statemutability-1) = [`StateMutability`](Function.mdx#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
#### Properties
##### inputs
> **inputs**: `TInputs`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L13)
###### Inherited from
`ConstructorType.inputs`
##### stateMutability
> **stateMutability**: `TStateMutability`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L12)
###### Inherited from
`ConstructorType.stateMutability`
##### type
> **type**: `"constructor"`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L11)
###### Inherited from
`ConstructorType.type`
#### Methods
##### decodeParams()
> **decodeParams**(`data`): `ParametersToPrimitiveTypes`\<`TInputs`>
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L24)
###### Parameters
###### data
`Uint8Array`
###### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
##### encodeParams()
> **encodeParams**(`args`): `Uint8Array`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L23)
###### Parameters
###### args
`ParametersToPrimitiveTypes`\<`TInputs`>
###### Returns
`Uint8Array`
## Type Aliases
### ConstructorType
> **ConstructorType**\<`TStateMutability`, `TInputs`> = `object`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L7)
Type definition for Constructor (data only)
#### Extended by
* [`ConstructorInstance`](#constructorinstance)
#### Type Parameters
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](Function.mdx#statemutability-1) = [`StateMutability`](Function.mdx#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
#### Properties
##### inputs
> **inputs**: `TInputs`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L13)
##### stateMutability
> **stateMutability**: `TStateMutability`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L12)
##### type
> **type**: `"constructor"`
Defined in: [src/primitives/Abi/constructor/ConstructorType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/ConstructorType.ts#L11)
## Functions
### decodeParams()
> **decodeParams**(`constructor`, `data`): `any`\[]
Defined in: [src/primitives/Abi/constructor/decodeParams.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/decodeParams.js#L21)
Decode constructor parameters
#### Parameters
##### constructor
[`ConstructorType`](#constructortype)\<[`StateMutability`](Function.mdx#statemutability-1), readonly `Parameter`\[]>
Constructor definition
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded data to decode
#### Returns
`any`\[]
Decoded parameters
#### Example
```typescript theme={null}
const constructor = {
type: "constructor",
stateMutability: "nonpayable",
inputs: [{ type: "uint256" }]
};
const decoded = Constructor.decodeParams(constructor, encodedData);
```
***
### encodeParams()
> **encodeParams**(`constructor`, `args`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/constructor/encodeParams.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/constructor/encodeParams.js#L21)
Encode constructor parameters
#### Parameters
##### constructor
[`ConstructorType`](#constructortype)\<[`StateMutability`](Function.mdx#statemutability-1), readonly `Parameter`\[]>
Constructor definition
##### args
`unknown`\[]
Arguments to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded parameters
#### Example
```typescript theme={null}
const constructor = {
type: "constructor",
stateMutability: "nonpayable",
inputs: [{ type: "uint256" }]
};
const encoded = Constructor.encodeParams(constructor, [123n]);
```
## References
### BrandedConstructor
Renames and re-exports [ConstructorType](#constructortype)
# Error
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/namespaces/Error
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Abi](../index.mdx) / Error
# Error
## Interfaces
### AbiErrorConstructor()
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L27)
> **AbiErrorConstructor**\<`TName`, `TInputs`>(`error`): `AbiErrorPrototype`\<`TName`, `TInputs`>
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L28)
#### Type Parameters
##### TName
`TName` *extends* `string` = `string`
##### TInputs
`TInputs` *extends* readonly `ParameterType`\[] = readonly `ParameterType`\[]
#### Parameters
##### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
#### Returns
`AbiErrorPrototype`\<`TName`, `TInputs`>
#### Properties
##### decodeParams()
> **decodeParams**: \<`TName`, `TInputs`>(`error`, `data`) => `ParametersToPrimitiveTypes`\<`TInputs`>
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L38)
Decode error parameters from encoded data
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with selector prefix
###### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
Decoded parameter values
###### Throws
If data is too short for selector
###### Throws
If selector doesn't match expected
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const decoded = decodeParams(error, encodedData); // [100n]
```
##### encodeParams()
> **encodeParams**: \<`TName`, `TInputs`>(`error`, `args`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L37)
Encode error parameters with selector prefix
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### args
`ParametersToPrimitiveTypes`\<`TInputs`>
Parameter values to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with 4-byte selector prefix
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const encoded = encodeParams(error, [100n]); // Uint8Array with selector + encoded params
```
##### getSelector()
> **getSelector**: (`error`) => `Uint8Array`
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L35)
###### Parameters
###### error
`any`
###### Returns
`Uint8Array`
##### getSignature()
> **getSignature**: \<`TName`, `TInputs`>(`error`) => `string`
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L36)
Get the signature string for an error (e.g., "MyError(uint256,address)")
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### Returns
`string`
Error signature string
###### Example
```typescript theme={null}
const error = { type: "error", name: "Unauthorized", inputs: [{ type: "address", name: "sender" }] };
const sig = getSignature(error); // "Unauthorized(address)"
```
##### prototype
> **prototype**: `AbiErrorPrototype`
Defined in: [src/primitives/Abi/error/AbiErrorConstructor.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/AbiErrorConstructor.ts#L34)
## Type Aliases
### ErrorType
> **ErrorType**\<`TName`, `TInputs`> = `object`
Defined in: [src/primitives/Abi/error/ErrorType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/ErrorType.ts#L3)
#### Type Parameters
##### TName
`TName` *extends* `string` = `string`
##### TInputs
`TInputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
#### Properties
##### inputs
> **inputs**: `TInputs`
Defined in: [src/primitives/Abi/error/ErrorType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/ErrorType.ts#L9)
##### name
> **name**: `TName`
Defined in: [src/primitives/Abi/error/ErrorType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/ErrorType.ts#L8)
##### type
> **type**: `"error"`
Defined in: [src/primitives/Abi/error/ErrorType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/ErrorType.ts#L7)
## Variables
### AbiError
> `const` **AbiError**: [`AbiErrorConstructor`](#abierrorconstructor)
Defined in: [src/primitives/Abi/error/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/index.ts#L18)
***
### Error
> `const` **Error**: `object`
Defined in: [src/primitives/Abi/error/Error.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/Error.js#L30)
Factory function for creating Error instances
Note: Error is a plain object, not a class instance
This namespace provides convenient methods for working with errors
#### Type Declaration
##### decodeParams()
> **decodeParams**: \<`TName`, `TInputs`>(`error`, `data`) => `ParametersToPrimitiveTypes`\<`TInputs`>
Decode error parameters from encoded data
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with selector prefix
###### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
Decoded parameter values
###### Throws
If data is too short for selector
###### Throws
If selector doesn't match expected
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const decoded = decodeParams(error, encodedData); // [100n]
```
##### encodeParams()
> **encodeParams**: \<`TName`, `TInputs`>(`error`, `args`) => `Uint8Array`\<`ArrayBufferLike`>
Encode error parameters with selector prefix
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### args
`ParametersToPrimitiveTypes`\<`TInputs`>
Parameter values to encode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with 4-byte selector prefix
###### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const encoded = encodeParams(error, [100n]); // Uint8Array with selector + encoded params
```
##### getSelector()
> **getSelector**: (`error`) => `Uint8Array`
###### Parameters
###### error
`any`
###### Returns
`Uint8Array`
##### GetSelector()
> **GetSelector**: (`deps`) => (`error`) => `Uint8Array`
Factory: Get the 4-byte selector for an error
###### Parameters
###### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that computes error selector
> (`error`): `Uint8Array`
###### Parameters
###### error
`any`
###### Returns
`Uint8Array`
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/error/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const error = { type: "error", name: "Unauthorized", inputs: [] };
const selector = getSelector(error);
```
##### getSignature()
> **getSignature**: \<`TName`, `TInputs`>(`error`) => `string`
Get the signature string for an error (e.g., "MyError(uint256,address)")
###### Type Parameters
###### TName
`TName` *extends* `string`
###### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
###### Parameters
###### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
###### Returns
`string`
Error signature string
###### Example
```typescript theme={null}
const error = { type: "error", name: "Unauthorized", inputs: [{ type: "address", name: "sender" }] };
const sig = getSignature(error); // "Unauthorized(address)"
```
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const error = {
type: 'error',
name: 'Unauthorized',
inputs: [{ type: 'address', name: 'caller' }]
};
const selector = Abi.Error.getSelector(error);
```
***
### getSelector()
> `const` **getSelector**: (`error`) => `Uint8Array`
Defined in: [src/primitives/Abi/error/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/index.ts#L24)
#### Parameters
##### error
`any`
#### Returns
`Uint8Array`
## Functions
### decodeParams()
> **decodeParams**\<`TName`, `TInputs`>(`error`, `data`): `ParametersToPrimitiveTypes`\<`TInputs`>
Defined in: [src/primitives/Abi/error/decodeParams.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/decodeParams.js#L22)
Decode error parameters from encoded data
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with selector prefix
#### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
Decoded parameter values
#### Throws
If data is too short for selector
#### Throws
If selector doesn't match expected
#### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const decoded = decodeParams(error, encodedData); // [100n]
```
***
### encodeParams()
> **encodeParams**\<`TName`, `TInputs`>(`error`, `args`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Abi/error/encodeParams.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/encodeParams.js#L19)
Encode error parameters with selector prefix
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
##### args
`ParametersToPrimitiveTypes`\<`TInputs`>
Parameter values to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded error data with 4-byte selector prefix
#### Example
```typescript theme={null}
const error = { type: "error", name: "InsufficientBalance", inputs: [{ type: "uint256", name: "balance" }] };
const encoded = encodeParams(error, [100n]); // Uint8Array with selector + encoded params
```
***
### GetSelector()
> **GetSelector**(`deps`): (`error`) => `Uint8Array`
Defined in: [src/primitives/Abi/error/getSelector.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/getSelector.js#L21)
Factory: Get the 4-byte selector for an error
#### Parameters
##### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
#### Returns
Function that computes error selector
> (`error`): `Uint8Array`
##### Parameters
###### error
`any`
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/error/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const error = { type: "error", name: "Unauthorized", inputs: [] };
const selector = getSelector(error);
```
***
### getSignature()
> **getSignature**\<`TName`, `TInputs`>(`error`): `string`
Defined in: [src/primitives/Abi/error/getSignature.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/error/getSignature.js#L15)
Get the signature string for an error (e.g., "MyError(uint256,address)")
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### error
[`ErrorType`](#errortype)\<`TName`, `TInputs`>
ABI error definition
#### Returns
`string`
Error signature string
#### Example
```typescript theme={null}
const error = { type: "error", name: "Unauthorized", inputs: [{ type: "address", name: "sender" }] };
const sig = getSignature(error); // "Unauthorized(address)"
```
# Event
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/namespaces/Event
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Abi](../index.mdx) / Event
# Event
## Type Aliases
### DecodeLogResult
> **DecodeLogResult**\<`TInputs`> = `ParametersToObject`\<`TInputs`>
Defined in: [src/primitives/Abi/event/EventType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L17)
#### Type Parameters
##### TInputs
`TInputs` *extends* readonly `Parameter`\[]
***
### EncodeTopicsArgs
> **EncodeTopicsArgs**\<`TInputs`> = `Partial`\<`ParametersToObject`\<`TInputs`>>
Defined in: [src/primitives/Abi/event/EventType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L13)
#### Type Parameters
##### TInputs
`TInputs` *extends* readonly `Parameter`\[]
***
### EventType
> **EventType**\<`TName`, `TInputs`> = `object`
Defined in: [src/primitives/Abi/event/EventType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L3)
#### Type Parameters
##### TName
`TName` *extends* `string` = `string`
##### TInputs
`TInputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
#### Properties
##### anonymous?
> `optional` **anonymous**: `boolean`
Defined in: [src/primitives/Abi/event/EventType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L10)
##### inputs
> **inputs**: `TInputs`
Defined in: [src/primitives/Abi/event/EventType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L9)
##### name
> **name**: `TName`
Defined in: [src/primitives/Abi/event/EventType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L8)
##### type
> **type**: `"event"`
Defined in: [src/primitives/Abi/event/EventType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/EventType.ts#L7)
## Variables
### encodeTopics()
> `const` **encodeTopics**: (`event`, `args`) => ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
Defined in: [src/primitives/Abi/event/index.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/index.js#L24)
#### Parameters
##### event
`any`
##### args
`any`
#### Returns
([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
***
### Event
> `const` **Event**: `object`
Defined in: [src/primitives/Abi/event/Event.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/Event.js#L42)
#### Type Declaration
##### decodeLog()
> **decodeLog**: (`event`, `data`, `topics`) => [`DecodeLogResult`](#decodelogresult)\<`any`>
Decode event log data and topics into event arguments
###### Parameters
###### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
###### topics
readonly [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
###### Returns
[`DecodeLogResult`](#decodelogresult)\<`any`>
Decoded event arguments
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If topics are missing or invalid
###### Throws
If event selector doesn't match topic0
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
##### DecodeLog()
> **DecodeLog**: (`event`, `data`, `topics`) => [`DecodeLogResult`](#decodelogresult)\<`any`> = `decodeLog`
Decode event log data and topics into event arguments
###### Parameters
###### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
###### topics
readonly [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
###### Returns
[`DecodeLogResult`](#decodelogresult)\<`any`>
Decoded event arguments
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
If topics are missing or invalid
###### Throws
If event selector doesn't match topic0
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
##### encodeTopics()
> **encodeTopics**: (`event`, `args`) => ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
##### EncodeTopics()
> **EncodeTopics**: (`deps`) => (`event`, `args`) => ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
Factory: Encode event arguments into topics array
###### Parameters
###### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that encodes event topics
> (`event`, `args`): ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
###### Example
```typescript theme={null}
import { EncodeTopics } from './primitives/Abi/event/index.js';
import { hash as keccak256, keccak256String } from './primitives/Hash/index.js';
const encodeTopics = EncodeTopics({ keccak256, keccak256String });
const event = { type: "event", name: "Transfer", inputs: [...], anonymous: false };
const topics = encodeTopics(event, { from: "0x...", to: "0x..." });
// [selector, encodedFrom, encodedTo]
```
##### getSelector()
> **getSelector**: (`event`) => [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Factory function for creating Event instances
Note: Event is a plain object, not a class instance
This namespace provides convenient methods for working with events
###### Parameters
###### event
`any`
###### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = {
type: 'event',
name: 'Transfer',
inputs: [
{ type: 'address', name: 'from', indexed: true },
{ type: 'address', name: 'to', indexed: true },
{ type: 'uint256', name: 'value' }
]
};
const selector = Abi.Event.getSelector(event);
```
##### GetSelector()
> **GetSelector**: (`deps`) => (`event`) => [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Factory: Get event selector (keccak256 hash of signature)
###### Parameters
###### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
###### Returns
Function that computes event selector
> (`event`): [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
###### Parameters
###### event
`any`
###### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
###### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
###### Since
0.0.0
###### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/event/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const event = { type: "event", name: "Transfer", inputs: [{ type: "address", indexed: true }] };
const selector = getSelector(event);
```
##### getSignature()
> **getSignature**: (`event`) => `string`
Get event signature string (e.g., "Transfer(address,address,uint256)")
###### Parameters
###### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### Returns
`string`
Event signature
###### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
##### Signature()
> **Signature**: (`event`) => `string` = `getSignature`
Get event signature string (e.g., "Transfer(address,address,uint256)")
###### Parameters
###### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
###### Returns
`string`
Event signature
###### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
##### Topics()
> **Topics**: (`event`, `args`) => ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[] = `encodeTopics`
###### Parameters
###### event
`any`
###### args
`any`
###### Returns
([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
***
### getSelector()
> `const` **getSelector**: (`event`) => [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Abi/event/index.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/index.js#L21)
#### Parameters
##### event
`any`
#### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
## Functions
### decodeLog()
> **decodeLog**(`event`, `data`, `topics`): [`DecodeLogResult`](#decodelogresult)\<`any`>
Defined in: [src/primitives/Abi/event/decodeLog.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/decodeLog.js#L29)
Decode event log data and topics into event arguments
#### Parameters
##### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
##### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
##### topics
readonly [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
#### Returns
[`DecodeLogResult`](#decodelogresult)\<`any`>
Decoded event arguments
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If topics are missing or invalid
#### Throws
If event selector doesn't match topic0
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
***
### DecodeLog()
> **DecodeLog**(`event`, `data`, `topics`): [`DecodeLogResult`](#decodelogresult)\<`any`>
Defined in: [src/primitives/Abi/event/decodeLog.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/decodeLog.js#L29)
Decode event log data and topics into event arguments
#### Parameters
##### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
##### data
`Uint8Array`\<`ArrayBufferLike`>
Log data bytes
##### topics
readonly [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)\[]
Log topics
#### Returns
[`DecodeLogResult`](#decodelogresult)\<`any`>
Decoded event arguments
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If topics are missing or invalid
#### Throws
If event selector doesn't match topic0
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const event = { type: "event", name: "Transfer", inputs: [
{ type: "address", name: "from", indexed: true },
{ type: "address", name: "to", indexed: true },
{ type: "uint256", name: "value" }
]};
const decoded = Abi.Event.decodeLog(event, logData, logTopics);
// { from: "0x...", to: "0x...", value: 1000n }
```
***
### EncodeTopics()
> **EncodeTopics**(`deps`): (`event`, `args`) => ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
Defined in: [src/primitives/Abi/event/encodeTopics.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/encodeTopics.js#L22)
Factory: Encode event arguments into topics array
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
#### Returns
Function that encodes event topics
> (`event`, `args`): ([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
##### Parameters
###### event
`any`
###### args
`any`
##### Returns
([`HashType`](../../../index/namespaces/HashType.mdx#hashtype) | `null`)\[]
#### Example
```typescript theme={null}
import { EncodeTopics } from './primitives/Abi/event/index.js';
import { hash as keccak256, keccak256String } from './primitives/Hash/index.js';
const encodeTopics = EncodeTopics({ keccak256, keccak256String });
const event = { type: "event", name: "Transfer", inputs: [...], anonymous: false };
const topics = encodeTopics(event, { from: "0x...", to: "0x..." });
// [selector, encodedFrom, encodedTo]
```
***
### GetSelector()
> **GetSelector**(`deps`): (`event`) => [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Abi/event/getSelector.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/getSelector.js#L21)
Factory: Get event selector (keccak256 hash of signature)
#### Parameters
##### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
#### Returns
Function that computes event selector
> (`event`): [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### event
`any`
##### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/event/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const event = { type: "event", name: "Transfer", inputs: [{ type: "address", indexed: true }] };
const selector = getSelector(event);
```
***
### getSignature()
> **getSignature**(`event`): `string`
Defined in: [src/primitives/Abi/event/getSignature.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/getSignature.js#L13)
Get event signature string (e.g., "Transfer(address,address,uint256)")
#### Parameters
##### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
#### Returns
`string`
Event signature
#### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
***
### Signature()
> **Signature**(`event`): `string`
Defined in: [src/primitives/Abi/event/getSignature.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/event/getSignature.js#L13)
Get event signature string (e.g., "Transfer(address,address,uint256)")
#### Parameters
##### event
[`EventType`](#eventtype)\<`string`, readonly `Parameter`\[]>
Event definition
#### Returns
`string`
Event signature
#### Example
```typescript theme={null}
const event = { type: "event", name: "Transfer", inputs: [...] };
const sig = Event.getSignature(event); // "Transfer(address,address,uint256)"
```
# Function
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/namespaces/Function
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Abi](../index.mdx) / Function
# Function
## Classes
### FunctionDecodingError
Defined in: [src/primitives/Abi/function/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L33)
Error thrown when decoding function data fails
#### Extends
* `AbiDecodingError`
#### Constructors
##### Constructor
> **new FunctionDecodingError**(`message`, `options?`): [`FunctionDecodingError`](#functiondecodingerror)
Defined in: [src/primitives/Abi/function/errors.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L42)
###### Parameters
###### message
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Original error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### Returns
[`FunctionDecodingError`](#functiondecodingerror)
###### Overrides
`AbiDecodingError.constructor`
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
`AbiDecodingError.cause`
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
`AbiDecodingError.code`
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
`AbiDecodingError.context`
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
`AbiDecodingError.docsPath`
##### name
> **name**: `string`
Defined in: [src/primitives/Abi/function/errors.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L49)
###### Inherited from
`AbiDecodingError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
`AbiDecodingError.getErrorChain`
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
`AbiDecodingError.toJSON`
***
### FunctionEncodingError
Defined in: [src/primitives/Abi/function/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L10)
Error thrown when encoding function data fails
#### Extends
* `AbiEncodingError`
#### Constructors
##### Constructor
> **new FunctionEncodingError**(`message`, `options?`): [`FunctionEncodingError`](#functionencodingerror)
Defined in: [src/primitives/Abi/function/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L19)
###### Parameters
###### message
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Original error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### Returns
[`FunctionEncodingError`](#functionencodingerror)
###### Overrides
`AbiEncodingError.constructor`
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
`AbiEncodingError.cause`
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
`AbiEncodingError.code`
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
`AbiEncodingError.context`
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
`AbiEncodingError.docsPath`
##### name
> **name**: `string`
Defined in: [src/primitives/Abi/function/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L26)
###### Inherited from
`AbiEncodingError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
`AbiEncodingError.getErrorChain`
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
`AbiEncodingError.toJSON`
***
### FunctionInvalidSelectorError
Defined in: [src/primitives/Abi/function/errors.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L56)
Error thrown when function selector doesn't match
#### Extends
* `AbiInvalidSelectorError`
#### Constructors
##### Constructor
> **new FunctionInvalidSelectorError**(`message`, `options`): [`FunctionInvalidSelectorError`](#functioninvalidselectorerror)
Defined in: [src/primitives/Abi/function/errors.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L67)
###### Parameters
###### message
`string`
Error message
###### options
Error options
###### cause?
`Error`
Original error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected
`string`
Expected selector value
###### value
`unknown`
Actual selector value
###### Returns
[`FunctionInvalidSelectorError`](#functioninvalidselectorerror)
###### Overrides
`AbiInvalidSelectorError.constructor`
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
`AbiInvalidSelectorError.cause`
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
`AbiInvalidSelectorError.code`
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
`AbiInvalidSelectorError.context`
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
`AbiInvalidSelectorError.docsPath`
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
`AbiInvalidSelectorError.expected`
##### name
> **name**: `string`
Defined in: [src/primitives/Abi/function/errors.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/errors.js#L76)
###### Inherited from
`AbiInvalidSelectorError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
`AbiInvalidSelectorError.value`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
`AbiInvalidSelectorError.getErrorChain`
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
`AbiInvalidSelectorError.toJSON`
## Type Aliases
### ExtractNames
> **ExtractNames**\<`TAbi`> = `Extract`\<`TAbi`\[`number`], \{ `type`: `"function"`; }>\[`"name"`]
Defined in: [src/primitives/Abi/function/FunctionType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L29)
Extract function names from an ABI
#### Type Parameters
##### TAbi
`TAbi` *extends* readonly [`ItemType`](Item.mdx#itemtype)\[]
***
### FunctionType
> **FunctionType**\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`> = `object`
Defined in: [src/primitives/Abi/function/FunctionType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L13)
Function ABI item type
#### Type Parameters
##### TName
`TName` *extends* `string` = `string`
Function name
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1) = [`StateMutability`](#statemutability-1)
State mutability (pure | view | nonpayable | payable)
##### TInputs
`TInputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
Input parameters
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\[] = readonly `Parameter`\[]
Output parameters
#### Properties
##### inputs
> **inputs**: `TInputs`
Defined in: [src/primitives/Abi/function/FunctionType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L22)
##### name
> **name**: `TName`
Defined in: [src/primitives/Abi/function/FunctionType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L20)
##### outputs
> **outputs**: `TOutputs`
Defined in: [src/primitives/Abi/function/FunctionType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L23)
##### stateMutability
> **stateMutability**: `TStateMutability`
Defined in: [src/primitives/Abi/function/FunctionType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L21)
##### type
> **type**: `"function"`
Defined in: [src/primitives/Abi/function/FunctionType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L19)
***
### Get
> **Get**\<`TAbi`, `TName`> = `Extract`\<`TAbi`\[`number`], \{ `name`: `TName`; `type`: `"function"`; }>
Defined in: [src/primitives/Abi/function/FunctionType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/FunctionType.ts#L37)
Get a specific function from an ABI by name
#### Type Parameters
##### TAbi
`TAbi` *extends* readonly [`ItemType`](Item.mdx#itemtype)\[]
##### TName
`TName` *extends* `string`
***
### StateMutability
> **StateMutability** = `"pure"` | `"view"` | `"nonpayable"` | `"payable"`
Defined in: [src/primitives/Abi/function/statemutability.ts:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/statemutability.ts#L1)
## Variables
### decodeParams()
> `const` **decodeParams**: \<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`, `data`) => `ParametersToPrimitiveTypes`\<`TInputs`> = `_decodeParams`
Defined in: [src/primitives/Abi/function/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L30)
Decode function call data (verify selector and decode parameters)
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded calldata
#### Returns
`ParametersToPrimitiveTypes`\<`TInputs`>
Decoded arguments
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
If data is too short
#### Throws
If selector doesn't match
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const func = {
type: "function",
name: "transfer",
stateMutability: "nonpayable",
inputs: [
{ type: "address", name: "to" },
{ type: "uint256", name: "amount" }
],
outputs: []
};
const decoded = Abi.Function.decodeParams(func, encoded);
// ["0x742d35cc6634c0532925a3b844bc9e7595f251e3", 100n]
```
***
### decodeResult()
> `const` **decodeResult**: \<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`, `data`) => `ParametersToPrimitiveTypes`\<`TOutputs`> = `_decodeResult`
Defined in: [src/primitives/Abi/function/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L32)
Decode function return values
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
##### data
`Uint8Array`\<`ArrayBufferLike`>
Encoded return data
#### Returns
`ParametersToPrimitiveTypes`\<`TOutputs`>
Decoded return values
#### Example
```typescript theme={null}
const func = {
type: "function",
name: "balanceOf",
stateMutability: "view",
inputs: [{ type: "address", name: "account" }],
outputs: [{ type: "uint256", name: "" }]
};
const decoded = decodeResult(func, encoded);
// [1000n]
```
***
### encodeParams()
> `const` **encodeParams**: \<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`, `args`) => `Uint8Array`\<`ArrayBufferLike`> = `_encodeParams`
Defined in: [src/primitives/Abi/function/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L29)
Encode function call data (selector + ABI-encoded parameters)
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
##### args
`ParametersToPrimitiveTypes`\<`TInputs`>
Function arguments
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded calldata (selector + params)
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const func = {
type: "function",
name: "transfer",
stateMutability: "nonpayable",
inputs: [
{ type: "address", name: "to" },
{ type: "uint256", name: "amount" }
],
outputs: []
};
const encoded = Abi.Function.encodeParams(func, [
"0x742d35cc6634c0532925a3b844bc9e7595f251e3",
100n
]);
```
***
### encodeResult()
> `const` **encodeResult**: \<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`, `values`) => `Uint8Array`\<`ArrayBufferLike`> = `_encodeResult`
Defined in: [src/primitives/Abi/function/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L31)
Encode function return values
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
##### values
`ParametersToPrimitiveTypes`\<`TOutputs`>
Return values
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded return data
#### Example
```typescript theme={null}
const func = {
type: "function",
name: "balanceOf",
stateMutability: "view",
inputs: [{ type: "address", name: "account" }],
outputs: [{ type: "uint256", name: "" }]
};
const encoded = encodeResult(func, [1000n]);
```
***
### getSelector()
> `const` **getSelector**: (`fn`) => `Uint8Array`
Defined in: [src/primitives/Abi/function/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L23)
#### Parameters
##### fn
`any`
#### Returns
`Uint8Array`
***
### getSignature()
> `const` **getSignature**: \<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`) => `string` = `_getSignature`
Defined in: [src/primitives/Abi/function/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/index.ts#L28)
Get function signature string (name(type1,type2,...))
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `Parameter`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
#### Returns
`string`
Function signature string
#### Example
```typescript theme={null}
const func = {
type: "function",
name: "transfer",
stateMutability: "nonpayable",
inputs: [
{ type: "address", name: "to" },
{ type: "uint256", name: "amount" }
],
outputs: []
};
const sig = getSignature(func);
// "transfer(address,uint256)"
```
## Functions
### Function()
> **Function**\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>(`fn`): [`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Defined in: [src/primitives/Abi/function/Function.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/Function.js#L38)
Factory function for creating/validating Function ABI items
Since Function items are plain objects, this mainly serves as a namespace
#### Type Parameters
##### TName
`TName` *extends* `string`
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](#statemutability-1)
##### TInputs
`TInputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
##### TOutputs
`TOutputs` *extends* readonly `ParameterType`\<`AbiType`, `string`, `string`>\[]
#### Parameters
##### fn
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Function ABI item
#### Returns
[`FunctionType`](#functiontype)\<`TName`, `TStateMutability`, `TInputs`, `TOutputs`>
Validated function item
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Abi from './primitives/Abi/index.js';
const func = Abi.Function({
type: 'function',
name: 'transfer',
stateMutability: 'nonpayable',
inputs: [{ type: 'address' }, { type: 'uint256' }],
outputs: [{ type: 'bool' }]
});
```
***
### GetSelector()
> **GetSelector**(`deps`): (`fn`) => `Uint8Array`
Defined in: [src/primitives/Abi/function/getSelector.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/function/getSelector.js#L31)
Factory: Get function selector (first 4 bytes of keccak256 hash of signature)
#### Parameters
##### deps
Crypto dependencies
###### keccak256String
(`str`) => `Uint8Array`
Keccak256 hash function for strings
#### Returns
Function that computes function selector
> (`fn`): `Uint8Array`
##### Parameters
###### fn
`any`
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/abi](https://voltaire.tevm.sh/primitives/abi)
#### Since
0.0.0
#### Example
```javascript theme={null}
import { GetSelector } from './primitives/Abi/function/index.js';
import { keccak256String } from './primitives/Hash/index.js';
const getSelector = GetSelector({ keccak256String });
const func = {
type: "function",
name: "transfer",
stateMutability: "nonpayable",
inputs: [
{ type: "address", name: "to" },
{ type: "uint256", name: "amount" }
],
outputs: []
};
const selector = getSelector(func);
// Uint8Array([0xa9, 0x05, 0x9c, 0xbb]) - transfer(address,uint256)
```
## References
### DecodeParams
Renames and re-exports [decodeParams](#decodeparams)
***
### DecodeResult
Renames and re-exports [decodeResult](#decoderesult)
***
### Params
Renames and re-exports [encodeParams](#encodeparams)
***
### Result
Renames and re-exports [encodeResult](#encoderesult)
***
### Signature
Renames and re-exports [getSignature](#getsignature)
# Item
Source: https://voltaire.tevm.sh/generated-api/primitives/Abi/namespaces/Item
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Abi](../index.mdx) / Item
# Item
## Interfaces
### ItemConstructor
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L10)
Item constructor interface - provides type guards and utilities for ABI items
#### Methods
##### format()
> **format**(`item`): `string`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L44)
Format an ABI item to a human-readable string
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`string`
##### formatWithArgs()
> **formatWithArgs**(`item`, `args`): `string`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L49)
Format an ABI item with concrete argument values
###### Parameters
###### item
[`ItemType`](#itemtype)
###### args
readonly `unknown`\[]
###### Returns
`string`
##### getItem()
> **getItem**\<`TAbi`, `TName`, `TType`>(`abi`, `name`, `type?`): `Extract`\<`TAbi`\[`number`], \{ `name`: `TName`; }> | `undefined`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L54)
Get an item from an ABI by name and optionally by type
###### Type Parameters
###### TAbi
`TAbi` *extends* readonly [`ItemType`](#itemtype)\[]
###### TName
`TName` *extends* `string`
###### TType
`TType` *extends* `"function"` | `"event"` | `"constructor"` | `"error"` | `"fallback"` | `"receive"` | `undefined` = `undefined`
###### Parameters
###### abi
`TAbi`
###### name
`TName`
###### type?
`TType`
###### Returns
`Extract`\<`TAbi`\[`number`], \{ `name`: `TName`; }> | `undefined`
##### isConstructor()
> **isConstructor**(`item`): `item is ConstructorType`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L29)
Type guard to check if an item is a Constructor
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is ConstructorType`
##### isError()
> **isError**(`item`): `item is ErrorType`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L24)
Type guard to check if an item is an Error
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is ErrorType`
##### isEvent()
> **isEvent**(`item`): `item is EventType`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L19)
Type guard to check if an item is an Event
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is EventType`
##### isFallback()
> **isFallback**(`item`): `item is Fallback`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L34)
Type guard to check if an item is a Fallback
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is Fallback`
##### isFunction()
> **isFunction**(`item`): `item is FunctionType`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L14)
Type guard to check if an item is a Function
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is FunctionType`
##### isReceive()
> **isReceive**(`item`): `item is Receive`
Defined in: [src/primitives/Abi/Item/ItemConstructor.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemConstructor.ts#L39)
Type guard to check if an item is a Receive
###### Parameters
###### item
[`ItemType`](#itemtype)
###### Returns
`item is Receive`
## Type Aliases
### Fallback
> **Fallback**\<`TStateMutability`> = `object`
Defined in: [src/primitives/Abi/Item/ItemType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L7)
#### Type Parameters
##### TStateMutability
`TStateMutability` *extends* [`StateMutability`](Function.mdx#statemutability-1) = [`StateMutability`](Function.mdx#statemutability-1)
#### Properties
##### stateMutability
> **stateMutability**: `TStateMutability`
Defined in: [src/primitives/Abi/Item/ItemType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L11)
##### type
> **type**: `"fallback"`
Defined in: [src/primitives/Abi/Item/ItemType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L10)
***
### ItemType
> **ItemType** = [`FunctionType`](Function.mdx#functiontype) | [`EventType`](Event.mdx#eventtype) | [`ErrorType`](Error.mdx#errortype) | [`ConstructorType`](Constructor.mdx#constructortype) | [`Fallback`](#fallback) | [`Receive`](#receive)
Defined in: [src/primitives/Abi/Item/ItemType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L22)
ItemType - discriminated union of all ABI item types
***
### Receive
> **Receive** = `object`
Defined in: [src/primitives/Abi/Item/ItemType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L14)
#### Properties
##### stateMutability
> **stateMutability**: `"payable"`
Defined in: [src/primitives/Abi/Item/ItemType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L16)
##### type
> **type**: `"receive"`
Defined in: [src/primitives/Abi/Item/ItemType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/ItemType.ts#L15)
## Variables
### Item
> `const` **Item**: [`ItemConstructor`](#itemconstructor)
Defined in: [src/primitives/Abi/Item/Item.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/Item.js#L28)
Item "class" - a namespace object for ABI item operations
## Functions
### \_format()
> **\_format**(`item`): `string`
Defined in: [src/primitives/Abi/Item/format.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/format.js#L6)
Format an ABI item to a human-readable string
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to format
#### Returns
`string`
***
### \_formatWithArgs()
> **\_formatWithArgs**(`item`, `args`): `string`
Defined in: [src/primitives/Abi/Item/formatWithArgs.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/formatWithArgs.js#L9)
Format an ABI item with concrete argument values
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to format
##### args
readonly `unknown`\[]
The argument values
#### Returns
`string`
***
### \_getItem()
> **\_getItem**\<`TAbi`, `TName`, `TType`>(`abi`, `name`, `type?`): `any`
Defined in: [src/primitives/Abi/Item/getItem.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/getItem.js#L11)
Get an item from an ABI by name and optionally by type
#### Type Parameters
##### TAbi
`TAbi` *extends* readonly [`ItemType`](#itemtype)\[]
##### TName
`TName` *extends* `string`
##### TType
`TType` *extends* `"function"` | `"event"` | `"constructor"` | `"error"` | `"fallback"` | `"receive"` | `undefined`
#### Parameters
##### abi
`TAbi`
The ABI array
##### name
`TName`
The item name
##### type?
`TType`
Optional type filter
#### Returns
`any`
***
### \_isConstructor()
> **\_isConstructor**(`item`): `item is ConstructorType`
Defined in: [src/primitives/Abi/Item/isConstructor.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isConstructor.js#L6)
Type guard to check if an item is a Constructor
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is ConstructorType`
***
### \_isError()
> **\_isError**(`item`): `item is ErrorType`
Defined in: [src/primitives/Abi/Item/isError.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isError.js#L6)
Type guard to check if an item is an Error
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is ErrorType`
***
### \_isEvent()
> **\_isEvent**(`item`): `item is EventType`
Defined in: [src/primitives/Abi/Item/isEvent.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isEvent.js#L6)
Type guard to check if an item is an Event
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is EventType`
***
### \_isFallback()
> **\_isFallback**(`item`): `item is Fallback`
Defined in: [src/primitives/Abi/Item/isFallback.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isFallback.js#L6)
Type guard to check if an item is a Fallback
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is Fallback`
***
### \_isFunction()
> **\_isFunction**(`item`): `item is FunctionType`
Defined in: [src/primitives/Abi/Item/isFunction.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isFunction.js#L6)
Type guard to check if an item is a Function
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is FunctionType`
***
### \_isReceive()
> **\_isReceive**(`item`): `item is Receive`
Defined in: [src/primitives/Abi/Item/isReceive.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Abi/Item/isReceive.js#L6)
Type guard to check if an item is a Receive
#### Parameters
##### item
[`ItemType`](#itemtype)
The item to check
#### Returns
`item is Receive`
## References
### BrandedItem
Renames and re-exports [ItemType](#itemtype)
***
### format
Renames and re-exports [\_format](#_format)
***
### formatWithArgs
Renames and re-exports [\_formatWithArgs](#_formatwithargs)
***
### getItem
Renames and re-exports [\_getItem](#_getitem)
***
### isConstructor
Renames and re-exports [\_isConstructor](#_isconstructor)
***
### isError
Renames and re-exports [\_isError](#_iserror)
***
### isEvent
Renames and re-exports [\_isEvent](#_isevent)
***
### isFallback
Renames and re-exports [\_isFallback](#_isfallback)
***
### isFunction
Renames and re-exports [\_isFunction](#_isfunction)
***
### isReceive
Renames and re-exports [\_isReceive](#_isreceive)
# primitives/AccessList
Source: https://voltaire.tevm.sh/generated-api/primitives/AccessList
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/AccessList
# primitives/AccessList
## Type Aliases
### BrandedAccessList
> **BrandedAccessList** = readonly [`Item`](#item)\[] & `object`
Defined in: [src/primitives/AccessList/AccessListType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessListType.ts#L27)
Branded AccessList type
Array of access list items (EIP-2930)
#### Type Declaration
##### \_\_brand?
> `readonly` `optional` **\_\_brand**: *typeof* `accessListSymbol`
***
### Item
> **Item**\<`TAddress`, `TStorageKeys`> = `object`
Defined in: [src/primitives/AccessList/AccessListType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessListType.ts#L13)
Single access list entry
Contains address and its accessed storage keys
#### Type Parameters
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TStorageKeys
`TStorageKeys` *extends* readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] = readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
#### Properties
##### address
> **address**: `TAddress`
Defined in: [src/primitives/AccessList/AccessListType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessListType.ts#L18)
Contract address
##### storageKeys
> **storageKeys**: `TStorageKeys`
Defined in: [src/primitives/AccessList/AccessListType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/AccessListType.ts#L20)
Storage keys accessed at this address
## Variables
### AccessList
> `const` **AccessList**: `object`
Defined in: [src/primitives/AccessList/index.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L115)
Namespace for AccessList operations
#### Type Declaration
##### ADDRESS\_COST
> **ADDRESS\_COST**: `bigint`
Gas cost per address in access list (EIP-2930)
##### addressCount()
> **addressCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`number`
##### assertValid()
> **assertValid**: (`list`) => `void`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`void`
##### COLD\_ACCOUNT\_ACCESS\_COST
> **COLD\_ACCOUNT\_ACCESS\_COST**: `bigint`
Cold account access cost (pre-EIP-2930)
##### COLD\_STORAGE\_ACCESS\_COST
> **COLD\_STORAGE\_ACCESS\_COST**: `bigint`
Cold storage access cost (pre-EIP-2930)
##### create()
> **create**: () => [`BrandedAccessList`](#brandedaccesslist)
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### deduplicate()
> **deduplicate**: (`list`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### from()
> **from**: (`value`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### value
`Uint8Array`\<`ArrayBufferLike`> | readonly [`Item`](#item)\[]
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### gasCost()
> **gasCost**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`bigint`
##### gasSavings()
> **gasSavings**: (`list`) => `bigint`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`bigint`
##### hasSavings()
> **hasSavings**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`boolean`
##### includesAddress()
> **includesAddress**: (`list`, `address`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### address
[`AddressType`](Address.mdx#addresstype)
###### Returns
`boolean`
##### includesStorageKey()
> **includesStorageKey**: (`list`, `address`, `storageKey`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### address
[`AddressType`](Address.mdx#addresstype)
###### storageKey
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Returns
`boolean`
##### is()
> **is**: (`value`) => `value is BrandedAccessList`
###### Parameters
###### value
`unknown`
###### Returns
`value is BrandedAccessList`
##### isEmpty()
> **isEmpty**: (`list`) => `boolean`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`boolean`
##### isItem()
> **isItem**: (`value`) => `value is Item`
###### Parameters
###### value
`unknown`
###### Returns
`value is Item`
##### keysFor()
> **keysFor**: (`list`, `address`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `undefined`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### address
[`AddressType`](Address.mdx#addresstype)
###### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `undefined`
##### merge()
> **merge**: (...`accessLists`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### accessLists
...[`BrandedAccessList`](#brandedaccesslist)\[]
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### STORAGE\_KEY\_COST
> **STORAGE\_KEY\_COST**: `bigint`
Gas cost per storage key in access list (EIP-2930)
##### storageKeyCount()
> **storageKeyCount**: (`list`) => `number`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`number`
##### toBytes()
> **toBytes**: (`list`) => `Uint8Array`
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### Returns
`Uint8Array`
##### WARM\_STORAGE\_ACCESS\_COST
> **WARM\_STORAGE\_ACCESS\_COST**: `bigint`
Warm storage access cost (post-EIP-2929)
##### withAddress()
> **withAddress**: (`list`, `address`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### address
[`AddressType`](Address.mdx#addresstype)
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
##### withStorageKey()
> **withStorageKey**: (`list`, `address`, `storageKey`) => [`BrandedAccessList`](#brandedaccesslist)
###### Parameters
###### list
[`BrandedAccessList`](#brandedaccesslist)
###### address
[`AddressType`](Address.mdx#addresstype)
###### storageKey
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### ADDRESS\_COST
> `const` **ADDRESS\_COST**: `2400n` = `2400n`
Defined in: [src/primitives/AccessList/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/constants.js#L6)
Gas cost per address in access list (EIP-2930)
***
### addressCount()
> `const` **addressCount**: (`list`) => `number` = `_addressCount`
Defined in: [src/primitives/AccessList/index.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L84)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`number`
***
### assertValid()
> `const` **assertValid**: (`list`) => `void` = `_assertValid`
Defined in: [src/primitives/AccessList/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L82)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`void`
***
### COLD\_ACCOUNT\_ACCESS\_COST
> `const` **COLD\_ACCOUNT\_ACCESS\_COST**: `2600n` = `2600n`
Defined in: [src/primitives/AccessList/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/constants.js#L12)
Cold account access cost (pre-EIP-2930)
***
### COLD\_STORAGE\_ACCESS\_COST
> `const` **COLD\_STORAGE\_ACCESS\_COST**: `2100n` = `2100n`
Defined in: [src/primitives/AccessList/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/constants.js#L15)
Cold storage access cost (pre-EIP-2930)
***
### create()
> `const` **create**: () => [`BrandedAccessList`](#brandedaccesslist) = `_create`
Defined in: [src/primitives/AccessList/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L52)
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### deduplicate()
> `const` **deduplicate**: (`list`) => [`BrandedAccessList`](#brandedaccesslist) = `_deduplicate`
Defined in: [src/primitives/AccessList/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L71)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### from()
> `const` **from**: (`value`) => [`BrandedAccessList`](#brandedaccesslist) = `_from`
Defined in: [src/primitives/AccessList/index.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L48)
#### Parameters
##### value
readonly [`Item`](#item)\[] | `Uint8Array`
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### fromBytes()
> `const` **fromBytes**: (`bytes`) => [`BrandedAccessList`](#brandedaccesslist) = `_fromBytes`
Defined in: [src/primitives/AccessList/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L49)
#### Parameters
##### bytes
`Uint8Array`
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### gasCost()
> `const` **gasCost**: (`list`) => `bigint` = `_gasCost`
Defined in: [src/primitives/AccessList/index.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L55)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`bigint`
***
### gasSavings()
> `const` **gasSavings**: (`list`) => `bigint` = `_gasSavings`
Defined in: [src/primitives/AccessList/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L56)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`bigint`
***
### hasSavings()
> `const` **hasSavings**: (`list`) => `boolean` = `_hasSavings`
Defined in: [src/primitives/AccessList/index.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L57)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`boolean`
***
### includesAddress()
> `const` **includesAddress**: (`list`, `address`) => `boolean` = `_includesAddress`
Defined in: [src/primitives/AccessList/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L58)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
##### address
[`AddressType`](Address.mdx#addresstype)
#### Returns
`boolean`
***
### includesStorageKey()
> `const` **includesStorageKey**: (`list`, `address`, `storageKey`) => `boolean` = `_includesStorageKey`
Defined in: [src/primitives/AccessList/index.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L62)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
##### address
[`AddressType`](Address.mdx#addresstype)
##### storageKey
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
`boolean`
***
### is()
> `const` **is**: (`value`) => `value is BrandedAccessList` = `_is`
Defined in: [src/primitives/AccessList/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L50)
#### Parameters
##### value
`unknown`
#### Returns
`value is BrandedAccessList`
***
### isEmpty()
> `const` **isEmpty**: (`list`) => `boolean` = `_isEmpty`
Defined in: [src/primitives/AccessList/index.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L86)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`boolean`
***
### isItem()
> `const` **isItem**: (`value`) => `value is Item` = `_isItem`
Defined in: [src/primitives/AccessList/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L51)
#### Parameters
##### value
`unknown`
#### Returns
`value is Item`
***
### keysFor()
> `const` **keysFor**: (`list`, `address`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `undefined` = `_keysFor`
Defined in: [src/primitives/AccessList/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L67)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
##### address
[`AddressType`](Address.mdx#addresstype)
#### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `undefined`
***
### merge()
> `const` **merge**: (...`accessLists`) => [`BrandedAccessList`](#brandedaccesslist) = `_merge`
Defined in: [src/primitives/AccessList/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L53)
#### Parameters
##### accessLists
...[`BrandedAccessList`](#brandedaccesslist)\[]
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### STORAGE\_KEY\_COST
> `const` **STORAGE\_KEY\_COST**: `1900n` = `1900n`
Defined in: [src/primitives/AccessList/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/constants.js#L9)
Gas cost per storage key in access list (EIP-2930)
***
### storageKeyCount()
> `const` **storageKeyCount**: (`list`) => `number` = `_storageKeyCount`
Defined in: [src/primitives/AccessList/index.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L85)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`number`
***
### toBytes()
> `const` **toBytes**: (`list`) => `Uint8Array` = `_toBytes`
Defined in: [src/primitives/AccessList/index.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L83)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
#### Returns
`Uint8Array`
***
### WARM\_STORAGE\_ACCESS\_COST
> `const` **WARM\_STORAGE\_ACCESS\_COST**: `100n` = `100n`
Defined in: [src/primitives/AccessList/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/constants.js#L18)
Warm storage access cost (post-EIP-2929)
***
### withAddress()
> `const` **withAddress**: (`list`, `address`) => [`BrandedAccessList`](#brandedaccesslist) = `_withAddress`
Defined in: [src/primitives/AccessList/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L73)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
##### address
[`AddressType`](Address.mdx#addresstype)
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
***
### withStorageKey()
> `const` **withStorageKey**: (`list`, `address`, `storageKey`) => [`BrandedAccessList`](#brandedaccesslist) = `_withStorageKey`
Defined in: [src/primitives/AccessList/index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccessList/index.ts#L77)
#### Parameters
##### list
[`BrandedAccessList`](#brandedaccesslist)
##### address
[`AddressType`](Address.mdx#addresstype)
##### storageKey
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
[`BrandedAccessList`](#brandedaccesslist)
## References
### AccessListNamespace
Renames and re-exports [AccessList](#accesslist)
# primitives/AccountState
Source: https://voltaire.tevm.sh/generated-api/primitives/AccountState
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/AccountState
# primitives/AccountState
## Type Aliases
### AccountStateLike
> **AccountStateLike** = [`AccountStateType`](#accountstatetype) | \{ `balance`: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype); `codeHash`: [`HashType`](../index/namespaces/HashType.mdx#hashtype); `nonce`: [`NonceType`](Nonce.mdx#noncetype); `storageRoot`: [`StateRootType`](StateRoot.mdx#stateroottype); }
Defined in: [src/primitives/AccountState/AccountStateType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L51)
Inputs that can be converted to AccountState
***
### AccountStateType
> **AccountStateType** = `object`
Defined in: [src/primitives/AccountState/AccountStateType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L20)
AccountState represents the state of an Ethereum account as defined in the Yellow Paper.
Each account in Ethereum has four fields:
* nonce: Number of transactions sent from this address (for EOAs) or contracts created (for contracts)
* balance: Amount of Wei owned by this account
* storageRoot: Root hash of the account's storage trie (for contracts) or empty hash (for EOAs)
* codeHash: Hash of the account's EVM bytecode (for contracts) or hash of empty string (for EOAs)
The global state is a mapping from addresses to account states, represented as a
Merkle Patricia Trie. The root of this trie is the state root included in each block header.
#### See
Yellow Paper section 4.1 - World State
#### Properties
##### balance
> `readonly` **balance**: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype)
Defined in: [src/primitives/AccountState/AccountStateType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L31)
Account balance in Wei (10^-18 ETH).
Can be zero or any positive value up to the total ETH supply.
##### codeHash
> `readonly` **codeHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/AccountState/AccountStateType.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L45)
Keccak256 hash of the account's EVM bytecode.
For EOAs, this is keccak256("") = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470.
For contracts, this is the hash of their deployed bytecode.
##### nonce
> `readonly` **nonce**: [`NonceType`](Nonce.mdx#noncetype)
Defined in: [src/primitives/AccountState/AccountStateType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L25)
Transaction count (EOA) or number of contract creations (contract account).
Starts at 0 and increments with each transaction/creation.
##### storageRoot
> `readonly` **storageRoot**: [`StateRootType`](StateRoot.mdx#stateroottype)
Defined in: [src/primitives/AccountState/AccountStateType.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L38)
Root hash of the account's storage trie.
For EOAs (externally owned accounts), this is the empty trie hash.
For contracts, this is the root of the Merkle Patricia Trie containing storage slots.
## Variables
### EMPTY\_CODE\_HASH
> `const` **EMPTY\_CODE\_HASH**: `"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"` = `"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"`
Defined in: [src/primitives/AccountState/AccountStateType.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L64)
Standard hash of empty string - used for EOA code hash
keccak256("") = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
***
### EMPTY\_TRIE\_HASH
> `const` **EMPTY\_TRIE\_HASH**: `"0x56e81f171bcc55a6ff8345e692c0f86e5b47e5b60e2d8c5ab6c7c9fa0e32d3c5"` = `"0x56e81f171bcc55a6ff8345e692c0f86e5b47e5b60e2d8c5ab6c7c9fa0e32d3c5"`
Defined in: [src/primitives/AccountState/AccountStateType.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/AccountStateType.ts#L71)
Standard hash of empty trie - used for EOA storage root
keccak256(rlp(\[])) = 0x56e81f171bcc55a6ff8345e692c0f86e5b47e5b60e2d8c5ab6c7c9fa0e32d3c5
## Functions
### createEmpty()
> **createEmpty**(): [`AccountStateType`](#accountstatetype)
Defined in: [src/primitives/AccountState/createEmpty.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/createEmpty.js#L28)
Creates an empty AccountState representing an EOA (Externally Owned Account)
with zero balance and nonce.
Empty accounts have:
* nonce: 0
* balance: 0 Wei
* storageRoot: empty trie hash
* codeHash: empty code hash
#### Returns
[`AccountStateType`](#accountstatetype)
* An empty AccountState
#### Example
```typescript theme={null}
const emptyAccount = AccountState.createEmpty();
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/AccountState/equals.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/equals.js#L22)
Compares two AccountStates for equality.
All four fields must match for accounts to be considered equal.
#### Parameters
##### a
[`AccountStateType`](#accountstatetype)
First AccountState
##### b
[`AccountStateType`](#accountstatetype)
Second AccountState
#### Returns
`boolean`
* True if all fields are equal
#### Example
```typescript theme={null}
const isEqual = AccountState.equals(state1, state2);
```
***
### from()
> **from**(`state`): [`AccountStateType`](#accountstatetype)
Defined in: [src/primitives/AccountState/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/from.js#L22)
Creates an AccountState from an object with the required fields.
#### Parameters
##### state
[`AccountStateLike`](#accountstatelike)
Object containing nonce, balance, storageRoot, and codeHash
#### Returns
[`AccountStateType`](#accountstatetype)
* A validated AccountState
#### Example
```typescript theme={null}
const state = AccountState.from({
nonce: Nonce.from(5n),
balance: Wei.from(1000000000000000000n), // 1 ETH
storageRoot: StateRoot.from("0x56e8..."),
codeHash: Hash.from("0xc5d2..."),
});
```
***
### isContract()
> **isContract**(`state`): `boolean`
Defined in: [src/primitives/AccountState/isContract.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/isContract.js#L22)
Checks if an AccountState represents a contract account.
A contract account is identified by having a non-empty code hash, meaning
it has associated bytecode that can be executed.
#### Parameters
##### state
[`AccountStateType`](#accountstatetype)
The AccountState to check
#### Returns
`boolean`
* True if the account is a contract
#### Example
```typescript theme={null}
const isContract = AccountState.isContract(account);
```
***
### isEOA()
> **isEOA**(`state`): `boolean`
Defined in: [src/primitives/AccountState/isEOA.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/AccountState/isEOA.js#L22)
Checks if an AccountState represents an EOA (Externally Owned Account).
An EOA is identified by having the empty code hash, meaning it has no
associated bytecode. EOAs can only send transactions and cannot execute code.
#### Parameters
##### state
[`AccountStateType`](#accountstatetype)
The AccountState to check
#### Returns
`boolean`
* True if the account is an EOA
#### Example
```typescript theme={null}
const isEOA = AccountState.isEOA(account);
```
# primitives/Address
Source: https://voltaire.tevm.sh/generated-api/primitives/Address
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Address
# primitives/Address
## Classes
### InvalidAddressError
Defined in: [src/primitives/Address/errors.js:159](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L159)
Error thrown when address is invalid
#### Throws
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidAddressError**(`message?`, `options?`): [`InvalidAddressError`](#invalidaddresserror)
Defined in: [src/primitives/Address/errors.js:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L170)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected format
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidAddressError`](#invalidaddresserror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:180](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L180)
###### Inherited from
`ValidationError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### InvalidAddressLengthError
Defined in: [src/primitives/Address/errors.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L74)
Error thrown when address has invalid length
#### Throws
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidAddressLengthError**(`message?`, `options?`): [`InvalidAddressLengthError`](#invalidaddresslengtherror)
Defined in: [src/primitives/Address/errors.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L85)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected length
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidAddressLengthError`](#invalidaddresslengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L95)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidChecksumError
Defined in: [src/primitives/Address/errors.js:189](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L189)
Error thrown when address checksum is invalid
#### Throws
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidChecksumError**(`message?`, `options?`): [`InvalidChecksumError`](#invalidchecksumerror)
Defined in: [src/primitives/Address/errors.js:200](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L200)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected checksum
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidChecksumError`](#invalidchecksumerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:210](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L210)
###### Inherited from
`ValidationError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### InvalidHexFormatError
Defined in: [src/primitives/Address/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L13)
Error thrown when address hex format is invalid
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidHexFormatError**(`message?`, `options?`): [`InvalidHexFormatError`](#invalidhexformaterror)
Defined in: [src/primitives/Address/errors.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L24)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected format
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidHexFormatError`](#invalidhexformaterror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L34)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidHexStringError
Defined in: [src/primitives/Address/errors.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L43)
Error thrown when hex string contains invalid characters
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidHexStringError**(`message?`, `options?`): [`InvalidHexStringError`](#invalidhexstringerror)
Defined in: [src/primitives/Address/errors.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L54)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected format
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidHexStringError`](#invalidhexstringerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L65)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidValueError
Defined in: [src/primitives/Address/errors.js:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L104)
Error thrown when value is invalid
#### Throws
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidValueError**(`message`, `options?`): [`InvalidValueError`](#invalidvalueerror)
Defined in: [src/primitives/Address/errors.js:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L115)
###### Parameters
###### message
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected value
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidValueError`](#invalidvalueerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L125)
###### Inherited from
`ValidationError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### NotImplementedError
Defined in: [src/primitives/Address/errors.js:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L134)
Error thrown when feature is not implemented
#### Throws
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new NotImplementedError**(`message?`, `options?`): [`NotImplementedError`](#notimplementederror)
Defined in: [src/primitives/Address/errors.js:143](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L143)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### Returns
[`NotImplementedError`](#notimplementederror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
##### name
> **name**: `string`
Defined in: [src/primitives/Address/errors.js:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/errors.js#L150)
###### Inherited from
`PrimitiveError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Interfaces
### AddressCrypto
Defined in: [src/primitives/Address/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L23)
Crypto dependencies for Address operations
#### Properties
##### keccak256()?
> `optional` **keccak256**: (`data`) => `Uint8Array`
Defined in: [src/primitives/Address/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L24)
###### Parameters
###### data
`Uint8Array`
###### Returns
`Uint8Array`
##### rlpEncode()?
> `optional` **rlpEncode**: (`items`) => `Uint8Array`
Defined in: [src/primitives/Address/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L25)
###### Parameters
###### items
`unknown`\[]
###### Returns
`Uint8Array`
***
### AddressWithFullCrypto
Defined in: [src/primitives/Address/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L61)
Address with full crypto support (enables all contract address methods)
#### Extends
* [`AddressWithKeccak`](#addresswithkeccak)
#### Indexable
\[`index`: `number`]: `number`
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Address"`
Defined in: [src/primitives/Address/AddressType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/AddressType.ts#L4)
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`[brand]`](#brand-1)
#### Methods
##### calculateCreate2Address()
> **calculateCreate2Address**(`salt`, `initCode`): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L52)
###### Parameters
###### salt
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### initCode
`BrandedBytecode`
###### Returns
[`AddressType`](#addresstype)
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`calculateCreate2Address`](#calculatecreate2address-2)
##### calculateCreateAddress()
> **calculateCreateAddress**(`nonce`): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L62)
###### Parameters
###### nonce
`bigint`
###### Returns
[`AddressType`](#addresstype)
##### clone()
> **clone**(): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L41)
###### Returns
[`AddressType`](#addresstype)
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`clone`](#clone-2)
##### compare()
> **compare**(`other`): `number`
Defined in: [src/primitives/Address/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L42)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`number`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`compare`](#compare-2)
##### equals()
> **equals**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L39)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`equals`](#equals-2)
##### greaterThan()
> **greaterThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L44)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`greaterThan`](#greaterthan-2)
##### isZero()
> **isZero**(): `boolean`
Defined in: [src/primitives/Address/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L38)
###### Returns
`boolean`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`isZero`](#iszero-2)
##### lessThan()
> **lessThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L43)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`lessThan`](#lessthan-2)
##### toAbiEncoded()
> **toAbiEncoded**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L36)
###### Returns
`Uint8Array`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toAbiEncoded`](#toabiencoded-2)
##### toBytes()
> **toBytes**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L40)
###### Returns
`Uint8Array`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toBytes`](#tobytes-2)
##### toChecksummed()
> **toChecksummed**(): `string`
Defined in: [src/primitives/Address/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L51)
###### Returns
`string`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toChecksummed`](#tochecksummed-2)
##### toHex()
> **toHex**(): `string`
Defined in: [src/primitives/Address/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L32)
Convert the Uint8Array to a hex encoded string
###### Returns
`string`
The hex encoded string representation of the Uint8Array
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toHex`](#tohex-2)
##### toLowercase()
> **toLowercase**(): `string`
Defined in: [src/primitives/Address/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L33)
###### Returns
`string`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toLowercase`](#tolowercase-2)
##### toShortHex()
> **toShortHex**(`startLength?`, `endLength?`): `string`
Defined in: [src/primitives/Address/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L37)
###### Parameters
###### startLength?
`number`
###### endLength?
`number`
###### Returns
`string`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toShortHex`](#toshorthex-2)
##### toU256()
> **toU256**(): `bigint`
Defined in: [src/primitives/Address/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L35)
###### Returns
`bigint`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toU256`](#tou256-2)
##### toUppercase()
> **toUppercase**(): `string`
Defined in: [src/primitives/Address/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L34)
###### Returns
`string`
###### Inherited from
[`AddressWithKeccak`](#addresswithkeccak).[`toUppercase`](#touppercase-2)
***
### AddressWithKeccak
Defined in: [src/primitives/Address/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L50)
Address with keccak256 support (enables checksum methods)
#### Extends
* [`BaseAddress`](#baseaddress)
#### Extended by
* [`AddressWithFullCrypto`](#addresswithfullcrypto)
#### Indexable
\[`index`: `number`]: `number`
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Address"`
Defined in: [src/primitives/Address/AddressType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/AddressType.ts#L4)
###### Inherited from
[`BaseAddress`](#baseaddress).[`[brand]`](#brand-2)
#### Methods
##### calculateCreate2Address()
> **calculateCreate2Address**(`salt`, `initCode`): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L52)
###### Parameters
###### salt
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### initCode
`BrandedBytecode`
###### Returns
[`AddressType`](#addresstype)
##### clone()
> **clone**(): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L41)
###### Returns
[`AddressType`](#addresstype)
###### Inherited from
[`BaseAddress`](#baseaddress).[`clone`](#clone-4)
##### compare()
> **compare**(`other`): `number`
Defined in: [src/primitives/Address/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L42)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`number`
###### Inherited from
[`BaseAddress`](#baseaddress).[`compare`](#compare-4)
##### equals()
> **equals**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L39)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`BaseAddress`](#baseaddress).[`equals`](#equals-4)
##### greaterThan()
> **greaterThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L44)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`BaseAddress`](#baseaddress).[`greaterThan`](#greaterthan-4)
##### isZero()
> **isZero**(): `boolean`
Defined in: [src/primitives/Address/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L38)
###### Returns
`boolean`
###### Inherited from
[`BaseAddress`](#baseaddress).[`isZero`](#iszero-4)
##### lessThan()
> **lessThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L43)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
###### Inherited from
[`BaseAddress`](#baseaddress).[`lessThan`](#lessthan-4)
##### toAbiEncoded()
> **toAbiEncoded**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L36)
###### Returns
`Uint8Array`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toAbiEncoded`](#toabiencoded-4)
##### toBytes()
> **toBytes**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L40)
###### Returns
`Uint8Array`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toBytes`](#tobytes-4)
##### toChecksummed()
> **toChecksummed**(): `string`
Defined in: [src/primitives/Address/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L51)
###### Returns
`string`
##### toHex()
> **toHex**(): `string`
Defined in: [src/primitives/Address/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L32)
Convert the Uint8Array to a hex encoded string
###### Returns
`string`
The hex encoded string representation of the Uint8Array
###### Inherited from
[`BaseAddress`](#baseaddress).[`toHex`](#tohex-4)
##### toLowercase()
> **toLowercase**(): `string`
Defined in: [src/primitives/Address/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L33)
###### Returns
`string`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toLowercase`](#tolowercase-4)
##### toShortHex()
> **toShortHex**(`startLength?`, `endLength?`): `string`
Defined in: [src/primitives/Address/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L37)
###### Parameters
###### startLength?
`number`
###### endLength?
`number`
###### Returns
`string`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toShortHex`](#toshorthex-4)
##### toU256()
> **toU256**(): `bigint`
Defined in: [src/primitives/Address/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L35)
###### Returns
`bigint`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toU256`](#tou256-4)
##### toUppercase()
> **toUppercase**(): `string`
Defined in: [src/primitives/Address/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L34)
###### Returns
`string`
###### Inherited from
[`BaseAddress`](#baseaddress).[`toUppercase`](#touppercase-4)
***
### BaseAddress
Defined in: [src/primitives/Address/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L31)
Base Address type without crypto-dependent methods
#### Extends
* [`AddressType`](#addresstype)
#### Extended by
* [`AddressWithKeccak`](#addresswithkeccak)
#### Indexable
\[`index`: `number`]: `number`
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Address"`
Defined in: [src/primitives/Address/AddressType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/AddressType.ts#L4)
###### Inherited from
`AddressType.[brand]`
#### Methods
##### clone()
> **clone**(): [`AddressType`](#addresstype)
Defined in: [src/primitives/Address/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L41)
###### Returns
[`AddressType`](#addresstype)
##### compare()
> **compare**(`other`): `number`
Defined in: [src/primitives/Address/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L42)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`number`
##### equals()
> **equals**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L39)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
##### greaterThan()
> **greaterThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L44)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
##### isZero()
> **isZero**(): `boolean`
Defined in: [src/primitives/Address/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L38)
###### Returns
`boolean`
##### lessThan()
> **lessThan**(`other`): `boolean`
Defined in: [src/primitives/Address/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L43)
###### Parameters
###### other
[`AddressType`](#addresstype)
###### Returns
`boolean`
##### toAbiEncoded()
> **toAbiEncoded**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L36)
###### Returns
`Uint8Array`
##### toBytes()
> **toBytes**(): `Uint8Array`
Defined in: [src/primitives/Address/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L40)
###### Returns
`Uint8Array`
##### toHex()
> **toHex**(): `string`
Defined in: [src/primitives/Address/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L32)
Convert the Uint8Array to a hex encoded string
###### Returns
`string`
The hex encoded string representation of the Uint8Array
###### Overrides
`AddressType.toHex`
##### toLowercase()
> **toLowercase**(): `string`
Defined in: [src/primitives/Address/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L33)
###### Returns
`string`
##### toShortHex()
> **toShortHex**(`startLength?`, `endLength?`): `string`
Defined in: [src/primitives/Address/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L37)
###### Parameters
###### startLength?
`number`
###### endLength?
`number`
###### Returns
`string`
##### toU256()
> **toU256**(): `bigint`
Defined in: [src/primitives/Address/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L35)
###### Returns
`bigint`
##### toUppercase()
> **toUppercase**(): `string`
Defined in: [src/primitives/Address/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L34)
###### Returns
`string`
## Type Aliases
### AddressType
> **AddressType** = `Uint8Array` & `object`
Defined in: [src/primitives/Address/AddressType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/AddressType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Address"`
## Variables
### equals()
> `const` **equals**: (`address`, `other`) => `boolean` = `Address.equals`
Defined in: [src/primitives/Address/index.ts:262](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L262)
Check if two addresses are equal
#### Parameters
##### address
[`AddressType`](#addresstype)
First address
##### other
[`AddressType`](#addresstype)
Address to compare with
#### Returns
`boolean`
True if addresses are identical
#### Example
```typescript theme={null}
if (Address.equals(addr1, addr2)) {
console.log("Addresses match");
}
```
***
### fromHex()
> `const` **fromHex**: (`value`, `crypto?`) => [`AddressType`](#addresstype) = `Address.fromHex`
Defined in: [src/primitives/Address/index.ts:261](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L261)
#### Parameters
##### value
`string`
##### crypto?
[`AddressCrypto`](#addresscrypto)
#### Returns
[`AddressType`](#addresstype)
***
### fromPublicKey()
> `const` **fromPublicKey**: \{(`x`, `y`): [`AddressType`](#addresstype); (`publicKey`): [`AddressType`](#addresstype); } = `Address.fromPublicKey`
Defined in: [src/primitives/Address/index.ts:186](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L186)
#### Call Signature
> (`x`, `y`): [`AddressType`](#addresstype)
##### Parameters
###### x
`bigint`
###### y
`bigint`
##### Returns
[`AddressType`](#addresstype)
#### Call Signature
> (`publicKey`): [`AddressType`](#addresstype)
##### Parameters
###### publicKey
`Uint8Array`
##### Returns
[`AddressType`](#addresstype)
***
### HEX\_SIZE
> `const` **HEX\_SIZE**: `42` = `42`
Defined in: [src/primitives/Address/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/constants.js#L11)
Address hex string size (including 0x prefix)
***
### NATIVE\_ASSET\_ADDRESS
> `const` **NATIVE\_ASSET\_ADDRESS**: `string` = `"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"`
Defined in: [src/primitives/Address/constants.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/constants.js#L19)
Native ETH address constant as defined in ERC-7528
Used to represent native ETH in token-related operations
#### See
[https://eips.ethereum.org/EIPS/eip-7528](https://eips.ethereum.org/EIPS/eip-7528)
***
### SIZE
> `const` **SIZE**: `20` = `20`
Defined in: [src/primitives/Address/constants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/constants.js#L5)
Address size in bytes
***
### toHex()
> `const` **toHex**: (`address`) => [`HexType`](Hex.mdx#hextype) = `BrandedAddress.toHex`
Defined in: [src/primitives/Address/index.ts:260](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L260)
Convert Address to hex string
#### Parameters
##### address
[`AddressType`](#addresstype)
Address to convert
#### Returns
[`HexType`](Hex.mdx#hextype)
Lowercase hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = Address.toHex(addr);
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
## Functions
### Address()
#### Call Signature
> **Address**(`value`): [`BaseAddress`](#baseaddress)
Defined in: [src/primitives/Address/index.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L80)
Creates Address instances with prototype chain
##### Parameters
###### value
Value to convert (hex string, bytes, or number)
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
##### Returns
[`BaseAddress`](#baseaddress)
Address instance with prototype methods
##### See
[https://voltaire.tevm.sh/primitives/address](https://voltaire.tevm.sh/primitives/address) for Address documentation
##### Since
0.0.0
##### Throws
If value format is invalid
##### Example
```typescript theme={null}
import { Address } from './primitives/Address/index.js';
const addr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
console.log(addr.toHex());
```
#### Call Signature
> **Address**(`value`, `crypto`): [`AddressWithKeccak`](#addresswithkeccak)
Defined in: [src/primitives/Address/index.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L91)
Creates Address with keccak256 support
##### Parameters
###### value
Value to convert
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### crypto
Crypto dependencies with keccak256
###### keccak256
(`data`) => `Uint8Array`
##### Returns
[`AddressWithKeccak`](#addresswithkeccak)
Address with checksum methods
#### Call Signature
> **Address**(`value`, `crypto`): [`AddressWithFullCrypto`](#addresswithfullcrypto)
Defined in: [src/primitives/Address/index.ts:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L103)
Creates Address with full crypto support
##### Parameters
###### value
Value to convert
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### crypto
Crypto dependencies with keccak256 and rlpEncode
###### keccak256
(`data`) => `Uint8Array`
###### rlpEncode
(`items`) => `Uint8Array`
##### Returns
[`AddressWithFullCrypto`](#addresswithfullcrypto)
Address with all contract address methods
***
### deduplicateAddresses()
> **deduplicateAddresses**(`addresses`): [`AddressType`](#addresstype)\[]
Defined in: [src/primitives/Address/index.ts:251](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L251)
#### Parameters
##### addresses
[`AddressType`](#addresstype)\[]
#### Returns
[`AddressType`](#addresstype)\[]
***
### sortAddresses()
> **sortAddresses**(`addresses`): [`AddressType`](#addresstype)\[]
Defined in: [src/primitives/Address/index.ts:244](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Address/index.ts#L244)
#### Parameters
##### addresses
[`AddressType`](#addresstype)\[]
#### Returns
[`AddressType`](#addresstype)\[]
## References
### BrandedAddress
Renames and re-exports [AddressType](#addresstype)
***
### default
Renames and re-exports [Address](#address)
# primitives/Authorization
Source: https://voltaire.tevm.sh/generated-api/primitives/Authorization
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Authorization
# primitives/Authorization
## Classes
### InvalidAddressError
Defined in: [src/primitives/Authorization/errors.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L35)
Authorization address cannot be zero address
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidAddressError**(`address`, `options?`): [`InvalidAddressError`](#invalidaddresserror)
Defined in: [src/primitives/Authorization/errors.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L41)
###### Parameters
###### address
`Uint8Array`\<`ArrayBufferLike`>
###### options?
###### cause?
`Error`
###### Returns
[`InvalidAddressError`](#invalidaddresserror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L49)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidChainIdError
Defined in: [src/primitives/Authorization/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L12)
Authorization chain ID must be non-zero
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidChainIdError**(`chainId`, `options?`): [`InvalidChainIdError`](#invalidchainiderror)
Defined in: [src/primitives/Authorization/errors.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L18)
###### Parameters
###### chainId
`bigint`
###### options?
###### cause?
`Error`
###### Returns
[`InvalidChainIdError`](#invalidchainiderror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L26)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidSignatureComponentError
Defined in: [src/primitives/Authorization/errors.js:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L81)
Authorization signature component cannot be zero
#### Throws
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new InvalidSignatureComponentError**(`component`, `value`, `options?`): [`InvalidSignatureComponentError`](#invalidsignaturecomponenterror)
Defined in: [src/primitives/Authorization/errors.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L88)
###### Parameters
###### component
`string`
'r' or 's'
###### value
`bigint`
###### options?
###### cause?
`Error`
###### Returns
[`InvalidSignatureComponentError`](#invalidsignaturecomponenterror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L95)
###### Inherited from
`InvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
***
### InvalidSignatureRangeError
Defined in: [src/primitives/Authorization/errors.js:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L104)
Authorization signature r must be less than curve order
#### Throws
#### Extends
* [`InvalidRangeError`](../index/index.mdx#invalidrangeerror)
#### Constructors
##### Constructor
> **new InvalidSignatureRangeError**(`value`, `max`, `options?`): [`InvalidSignatureRangeError`](#invalidsignaturerangeerror)
Defined in: [src/primitives/Authorization/errors.js:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L111)
###### Parameters
###### value
`bigint`
###### max
`bigint`
###### options?
###### cause?
`Error`
###### Returns
[`InvalidSignatureRangeError`](#invalidsignaturerangeerror)
###### Overrides
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`constructor`](../index/index.mdx#constructor-11)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`cause`](../index/index.mdx#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`code`](../index/index.mdx#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`context`](../index/index.mdx#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`docsPath`](../index/index.mdx#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`expected`](../index/index.mdx#expected-5)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L119)
###### Inherited from
`InvalidRangeError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`value`](../index/index.mdx#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`getErrorChain`](../index/index.mdx#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`toJSON`](../index/index.mdx#tojson-22)
***
### InvalidYParityError
Defined in: [src/primitives/Authorization/errors.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L58)
Authorization yParity must be 0 or 1
#### Throws
#### Extends
* [`InvalidRangeError`](../index/index.mdx#invalidrangeerror)
#### Constructors
##### Constructor
> **new InvalidYParityError**(`yParity`, `options?`): [`InvalidYParityError`](#invalidyparityerror)
Defined in: [src/primitives/Authorization/errors.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L64)
###### Parameters
###### yParity
`number`
###### options?
###### cause?
`Error`
###### Returns
[`InvalidYParityError`](#invalidyparityerror)
###### Overrides
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`constructor`](../index/index.mdx#constructor-11)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`cause`](../index/index.mdx#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`code`](../index/index.mdx#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`context`](../index/index.mdx#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`docsPath`](../index/index.mdx#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`expected`](../index/index.mdx#expected-5)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L72)
###### Inherited from
`InvalidRangeError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`value`](../index/index.mdx#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`getErrorChain`](../index/index.mdx#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`toJSON`](../index/index.mdx#tojson-22)
***
### MalleableSignatureError
Defined in: [src/primitives/Authorization/errors.js:128](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L128)
Authorization signature s too high (malleable signature)
#### Throws
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new MalleableSignatureError**(`s`, `max`, `options?`): [`MalleableSignatureError`](#malleablesignatureerror)
Defined in: [src/primitives/Authorization/errors.js:135](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L135)
###### Parameters
###### s
`bigint`
###### max
`bigint`
###### options?
###### cause?
`Error`
###### Returns
[`MalleableSignatureError`](#malleablesignatureerror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/primitives/Authorization/errors.js:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/errors.js#L142)
###### Inherited from
`InvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
## Interfaces
### DelegationDesignation
Defined in: [src/primitives/Authorization/types.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L20)
#### Properties
##### authority
> **authority**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Authorization/types.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L21)
Authority (signer) address
##### delegatedAddress
> **delegatedAddress**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Authorization/types.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L22)
Delegated code address
***
### Unsigned
Defined in: [src/primitives/Authorization/types.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L11)
#### Properties
##### address
> **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Authorization/types.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L13)
Address to delegate code execution to
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Authorization/types.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L12)
Chain ID where authorization is valid
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Authorization/types.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/types.js#L14)
Nonce of the authorizing account
## Type Aliases
### AuthorizationType
> **AuthorizationType** = `object`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L7)
EIP-7702 Authorization branded type
Allows EOA to delegate code execution to another address
#### Properties
##### address
> **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Authorization/AuthorizationType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L11)
Address to delegate code execution to
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L9)
Chain ID where authorization is valid
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L13)
Nonce of the authorizing account
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L17)
Signature r value (32 bytes)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L19)
Signature s value (32 bytes)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Authorization/AuthorizationType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L15)
Signature Y parity (0 or 1)
***
### ~~BrandedAuthorization~~
> **BrandedAuthorization** = [`AuthorizationType`](#authorizationtype)
Defined in: [src/primitives/Authorization/AuthorizationType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/AuthorizationType.ts#L25)
#### Deprecated
Use AuthorizationType instead
## Variables
### Authorization
> `const` **Authorization**: `object`
Defined in: [src/primitives/Authorization/index.ts:163](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L163)
#### Type Declaration
##### calculateGasCost()
> **calculateGasCost**: (`authList`, `emptyAccounts`) => `bigint`
###### Parameters
###### authList
[`AuthorizationType`](#authorizationtype)\[]
###### emptyAccounts
`number`
###### Returns
`bigint`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`AddressType`](Address.mdx#addresstype)
###### b
[`AddressType`](Address.mdx#addresstype)
###### Returns
`boolean`
##### equalsAuth()
> **equalsAuth**: (`auth1`, `auth2`) => `boolean`
###### Parameters
###### auth1
[`AuthorizationType`](#authorizationtype)
###### auth2
[`AuthorizationType`](#authorizationtype)
###### Returns
`boolean`
##### format()
> **format**: (`auth`) => `string`
###### Parameters
###### auth
[`AuthorizationType`](#authorizationtype) | \{ `address`: [`AddressType`](Address.mdx#addresstype); `chainId`: `bigint`; `nonce`: `bigint`; }
###### Returns
`string`
##### getGasCost()
> **getGasCost**: (`auth`, `isEmpty`) => `bigint`
###### Parameters
###### auth
[`AuthorizationType`](#authorizationtype)
###### isEmpty
`boolean`
###### Returns
`bigint`
##### hash
> **hash**: `HashFn`
##### Hash()
> **Hash**: (`deps`) => `HashFn`
###### Parameters
###### deps
###### keccak256
(`data`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
###### Returns
`HashFn`
##### isItem()
> **isItem**: (`value`) => `boolean`
###### Parameters
###### value
`unknown`
###### Returns
`boolean`
##### isUnsigned()
> **isUnsigned**: (`value`) => `boolean`
###### Parameters
###### value
`unknown`
###### Returns
`boolean`
##### MAGIC\_BYTE
> **MAGIC\_BYTE**: `number`
EIP-7702 magic byte for signing hash
##### PER\_AUTH\_BASE\_COST
> **PER\_AUTH\_BASE\_COST**: `bigint`
Base gas cost per authorization
##### PER\_EMPTY\_ACCOUNT\_COST
> **PER\_EMPTY\_ACCOUNT\_COST**: `bigint`
Gas cost per empty account authorization
##### process()
> **process**: (`auth`) => `object`
###### Parameters
###### auth
[`AuthorizationType`](#authorizationtype)
###### Returns
`object`
###### authority
> **authority**: [`AddressType`](Address.mdx#addresstype)
###### delegatedAddress
> **delegatedAddress**: [`AddressType`](Address.mdx#addresstype)
##### processAll()
> **processAll**: (`authList`) => `object`\[]
###### Parameters
###### authList
[`AuthorizationType`](#authorizationtype)\[]
###### Returns
`object`\[]
##### SECP256K1\_HALF\_N
> **SECP256K1\_HALF\_N**: `bigint`
secp256k1 curve order N / 2 (for malleability check)
##### SECP256K1\_N
> **SECP256K1\_N**: `bigint`
secp256k1 curve order N
##### sign
> **sign**: `SignFn`
##### Sign()
> **Sign**: (`deps`) => `SignFn`
###### Parameters
###### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
###### sign
(`messageHash`, `privateKey`) => `object`
###### Returns
`SignFn`
##### validate()
> **validate**: (`auth`) => `void`
###### Parameters
###### auth
[`AuthorizationType`](#authorizationtype)
###### Returns
`void`
##### verify
> **verify**: `VerifyFn`
##### Verify()
> **Verify**: (`deps`) => `VerifyFn`
###### Parameters
###### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
###### Returns
`VerifyFn`
***
### calculateGasCost()
> `const` **calculateGasCost**: (`authList`, `emptyAccounts`) => `bigint` = `calculateGasCostImpl`
Defined in: [src/primitives/Authorization/index.ts:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L97)
#### Parameters
##### authList
[`AuthorizationType`](#authorizationtype)\[]
##### emptyAccounts
`number`
#### Returns
`bigint`
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `equalsImpl`
Defined in: [src/primitives/Authorization/index.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L102)
#### Parameters
##### a
[`AddressType`](Address.mdx#addresstype)
##### b
[`AddressType`](Address.mdx#addresstype)
#### Returns
`boolean`
***
### equalsAuth()
> `const` **equalsAuth**: (`auth1`, `auth2`) => `boolean` = `equalsAuthImpl`
Defined in: [src/primitives/Authorization/index.ts:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L104)
#### Parameters
##### auth1
[`AuthorizationType`](#authorizationtype)
##### auth2
[`AuthorizationType`](#authorizationtype)
#### Returns
`boolean`
***
### format()
> `const` **format**: (`auth`) => `string` = `formatImpl`
Defined in: [src/primitives/Authorization/index.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L109)
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype) | \{ `address`: [`AddressType`](Address.mdx#addresstype); `chainId`: `bigint`; `nonce`: `bigint`; }
#### Returns
`string`
***
### getGasCost()
> `const` **getGasCost**: (`auth`, `isEmpty`) => `bigint` = `getGasCostImpl`
Defined in: [src/primitives/Authorization/index.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L115)
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype)
##### isEmpty
`boolean`
#### Returns
`bigint`
***
### hash
> `const` **hash**: `HashFn`
Defined in: [src/primitives/Authorization/index.ts:135](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L135)
***
### Hash()
> `const` **Hash**: (`deps`) => `HashFn`
Defined in: [src/primitives/Authorization/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L43)
#### Parameters
##### deps
###### keccak256
(`data`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
#### Returns
`HashFn`
***
### isItem()
> `const` **isItem**: (`value`) => `boolean` = `isItemImpl`
Defined in: [src/primitives/Authorization/index.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L118)
#### Parameters
##### value
`unknown`
#### Returns
`boolean`
***
### isUnsigned()
> `const` **isUnsigned**: (`value`) => `boolean` = `isUnsignedImpl`
Defined in: [src/primitives/Authorization/index.ts:120](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L120)
#### Parameters
##### value
`unknown`
#### Returns
`boolean`
***
### MAGIC\_BYTE
> `const` **MAGIC\_BYTE**: `5` = `0x05`
Defined in: [src/primitives/Authorization/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/constants.js#L8)
EIP-7702 magic byte for signing hash
***
### PER\_AUTH\_BASE\_COST
> `const` **PER\_AUTH\_BASE\_COST**: `12500n` = `12500n`
Defined in: [src/primitives/Authorization/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/constants.js#L18)
Base gas cost per authorization
***
### PER\_EMPTY\_ACCOUNT\_COST
> `const` **PER\_EMPTY\_ACCOUNT\_COST**: `25000n` = `25000n`
Defined in: [src/primitives/Authorization/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/constants.js#L13)
Gas cost per empty account authorization
***
### process()
> `const` **process**: (`auth`) => `object` = `processImpl`
Defined in: [src/primitives/Authorization/index.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L122)
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype)
#### Returns
`object`
##### authority
> **authority**: [`AddressType`](Address.mdx#addresstype)
##### delegatedAddress
> **delegatedAddress**: [`AddressType`](Address.mdx#addresstype)
***
### processAll()
> `const` **processAll**: (`authList`) => `object`\[] = `processAllImpl`
Defined in: [src/primitives/Authorization/index.ts:127](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L127)
#### Parameters
##### authList
[`AuthorizationType`](#authorizationtype)\[]
#### Returns
`object`\[]
***
### SECP256K1\_HALF\_N
> `const` **SECP256K1\_HALF\_N**: `bigint`
Defined in: [src/primitives/Authorization/constants.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/constants.js#L29)
secp256k1 curve order N / 2 (for malleability check)
***
### SECP256K1\_N
> `const` **SECP256K1\_N**: `115792089237316195423570985008687907852837564279074904382605163141518161494337n` = `0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n`
Defined in: [src/primitives/Authorization/constants.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/constants.js#L23)
secp256k1 curve order N
***
### sign
> `const` **sign**: `SignFn`
Defined in: [src/primitives/Authorization/index.ts:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L148)
***
### Sign()
> `const` **Sign**: (`deps`) => `SignFn`
Defined in: [src/primitives/Authorization/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L49)
#### Parameters
##### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
###### sign
(`messageHash`, `privateKey`) => `object`
#### Returns
`SignFn`
***
### validate()
> `const` **validate**: (`auth`) => `void` = `validateImpl`
Defined in: [src/primitives/Authorization/index.ts:132](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L132)
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype)
#### Returns
`void`
***
### verify
> `const` **verify**: `VerifyFn`
Defined in: [src/primitives/Authorization/index.ts:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L140)
***
### Verify()
> `const` **Verify**: (`deps`) => `VerifyFn`
Defined in: [src/primitives/Authorization/index.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/index.ts#L64)
#### Parameters
##### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
###### rlpEncode
(`data`) => `Uint8Array`
#### Returns
`VerifyFn`
## Functions
### authorityWasm()
> **authorityWasm**(`auth`): [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Authorization/Authorization.wasm.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/Authorization.wasm.ts#L56)
Recover authority (signer) from authorization
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype)
Authorization to recover from
#### Returns
[`AddressType`](Address.mdx#addresstype)
Recovered authority address
***
### gasCostWasm()
> **gasCostWasm**(`authCount`, `emptyAccounts`): `bigint`
Defined in: [src/primitives/Authorization/Authorization.wasm.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/Authorization.wasm.ts#L73)
Calculate gas cost for authorization list
#### Parameters
##### authCount
`number`
Number of authorizations
##### emptyAccounts
`number`
Number of empty accounts
#### Returns
`bigint`
Gas cost as bigint
***
### signingHashWasm()
> **signingHashWasm**(`chainId`, `address`, `nonce`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Authorization/Authorization.wasm.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/Authorization.wasm.ts#L43)
Calculate signing hash for authorization
#### Parameters
##### chainId
`bigint`
Chain ID
##### address
[`AddressType`](Address.mdx#addresstype)
Target address
##### nonce
`bigint`
Nonce
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Signing hash
***
### validateWasm()
> **validateWasm**(`auth`): `void`
Defined in: [src/primitives/Authorization/Authorization.wasm.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Authorization/Authorization.wasm.ts#L25)
Validate authorization structure
#### Parameters
##### auth
[`AuthorizationType`](#authorizationtype)
Authorization to validate
#### Returns
`void`
#### Throws
Error if authorization is invalid
# primitives/Base64
Source: https://voltaire.tevm.sh/generated-api/primitives/Base64
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Base64
# primitives/Base64
## Type Aliases
### Base64Like
> **Base64Like** = [`BrandedBase64`](#brandedbase64) | `string` | `Uint8Array`
Defined in: [src/primitives/Base64/Base64Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/Base64Type.ts#L19)
Inputs that can be converted to BrandedBase64
***
### Base64UrlLike
> **Base64UrlLike** = [`BrandedBase64Url`](#brandedbase64url) | `string` | `Uint8Array`
Defined in: [src/primitives/Base64/Base64Type.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/Base64Type.ts#L37)
Inputs that can be converted to BrandedBase64Url
***
### BrandedBase64
> **BrandedBase64** = `string` & `object`
Defined in: [src/primitives/Base64/Base64Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/Base64Type.ts#L12)
Branded Base64 string type
Standard Base64 encoding (RFC 4648):
* Alphabet: A-Z, a-z, 0-9, +, /
* Padding: = (required, length must be multiple of 4)
Type safety ensures only validated Base64 strings are used.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Base64"`
***
### BrandedBase64Url
> **BrandedBase64Url** = `string` & `object`
Defined in: [src/primitives/Base64/Base64Type.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/Base64Type.ts#L30)
Branded Base64Url string type
URL-safe Base64 encoding (RFC 4648):
* Alphabet: A-Z, a-z, 0-9, -, \_
* Padding: typically omitted
Type safety ensures only validated Base64Url strings are used.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Base64Url"`
## Variables
### Base64
> `const` **Base64**: `object`
Defined in: [src/primitives/Base64/Base64.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/Base64.js#L77)
Base64 encoding/decoding namespace
Standard and URL-safe base64 encoding with proper padding.
Built on Web APIs for maximum performance and compatibility.
#### Type Declaration
##### calcDecodedSize()
> **calcDecodedSize**: (`encodedLength`) => `number`
Calculate decoded size in bytes
###### Parameters
###### encodedLength
`number`
Length of base64 string
###### Returns
`number`
Maximum size of decoded output
##### calcEncodedSize()
> **calcEncodedSize**: (`dataLength`) => `number`
Calculate encoded size in bytes
###### Parameters
###### dataLength
`number`
Length of data to encode
###### Returns
`number`
Size of base64 output
##### decode()
> **decode**: (`encoded`) => `Uint8Array`\<`ArrayBufferLike`>
Decode standard base64 string to bytes
###### Parameters
###### encoded
`string`
Base64 string to decode
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
###### See
[https://voltaire.tevm.sh/primitives/base64](https://voltaire.tevm.sh/primitives/base64) for Base64 documentation
###### Since
0.0.0
###### Throws
If input is invalid base64
###### Example
```javascript theme={null}
import * as Base64 from './primitives/Base64/index.js';
const decoded = Base64.decode('SGVsbG8=');
// Uint8Array([72, 101, 108, 108, 111])
```
##### decodeToString()
> **decodeToString**: (`encoded`) => `string`
Decode base64 string to UTF-8 string
###### Parameters
###### encoded
`string`
Base64 string
###### Returns
`string`
Decoded string
###### Example
```typescript theme={null}
const str = Base64.decodeToString('SGVsbG8=');
// "Hello"
```
##### decodeUrlSafe()
> **decodeUrlSafe**: (`encoded`) => `Uint8Array`\<`ArrayBufferLike`>
Decode URL-safe base64 string to bytes
###### Parameters
###### encoded
`string`
URL-safe base64 string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
###### Throws
If input is invalid
##### decodeUrlSafeToString()
> **decodeUrlSafeToString**: (`encoded`) => `string`
Decode URL-safe base64 to UTF-8 string
###### Parameters
###### encoded
`string`
URL-safe base64 string
###### Returns
`string`
Decoded string
##### encode()
> **encode**: (`data`) => [`BrandedBase64`](#brandedbase64)
Encode bytes to standard base64 string
Uses standard base64 alphabet (A-Z, a-z, 0-9, +, /)
with padding (=)
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
###### Returns
[`BrandedBase64`](#brandedbase64)
Base64-encoded string
###### Example
```typescript theme={null}
const data = new Uint8Array([72, 101, 108, 108, 111]);
const encoded = Base64.encode(data);
// "SGVsbG8="
```
##### encodeString()
> **encodeString**: (`str`) => `string`
Encode string to base64
###### Parameters
###### str
`string`
String to encode (UTF-8)
###### Returns
`string`
Base64-encoded string
###### Example
```typescript theme={null}
const encoded = Base64.encodeString('Hello, world!');
```
##### encodeStringUrlSafe()
> **encodeStringUrlSafe**: (`str`) => [`BrandedBase64Url`](#brandedbase64url)
Encode string to URL-safe base64
###### Parameters
###### str
`string`
String to encode (UTF-8)
###### Returns
[`BrandedBase64Url`](#brandedbase64url)
URL-safe base64 string
##### encodeUrlSafe()
> **encodeUrlSafe**: (`data`) => [`BrandedBase64Url`](#brandedbase64url)
Encode bytes to URL-safe base64 string
Uses URL-safe alphabet (A-Z, a-z, 0-9, -, \_)
without padding
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
###### Returns
[`BrandedBase64Url`](#brandedbase64url)
URL-safe base64 string
###### Example
```typescript theme={null}
const data = new Uint8Array([255, 254, 253]);
const encoded = Base64.encodeUrlSafe(data);
// No padding, uses - and _ instead of + and /
```
##### from()
> **from**: (`value`) => [`BrandedBase64`](#brandedbase64)
Convert input to BrandedBase64
###### Parameters
###### value
[`Base64Like`](#base64like)
Input to convert
###### Returns
[`BrandedBase64`](#brandedbase64)
Branded Base64 string
###### Throws
If input cannot be converted to valid Base64
###### Example
```typescript theme={null}
// From string
const b64 = Base64.from("SGVsbG8=");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64 = Base64.from(data);
```
##### fromUrlSafe()
> **fromUrlSafe**: (`value`) => [`BrandedBase64Url`](#brandedbase64url)
Convert input to BrandedBase64Url
###### Parameters
###### value
[`Base64UrlLike`](#base64urllike)
Input to convert
###### Returns
[`BrandedBase64Url`](#brandedbase64url)
Branded Base64Url string
###### Throws
If input cannot be converted to valid Base64Url
###### Example
```typescript theme={null}
// From string
const b64url = Base64.fromUrlSafe("SGVsbG8");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64url = Base64.fromUrlSafe(data);
```
##### isValid()
> **isValid**: (`str`) => `boolean`
Check if string is valid base64
###### Parameters
###### str
`string`
String to validate
###### Returns
`boolean`
True if valid base64
##### isValidUrlSafe()
> **isValidUrlSafe**: (`str`) => `boolean`
Check if string is valid URL-safe base64
###### Parameters
###### str
`string`
String to validate
###### Returns
`boolean`
True if valid URL-safe base64
##### toBase64()
> **toBase64**: (`value`) => [`BrandedBase64`](#brandedbase64)
Convert BrandedBase64Url to BrandedBase64
###### Parameters
###### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
###### Returns
[`BrandedBase64`](#brandedbase64)
Base64 string
###### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const b64 = Base64.toBase64(b64url);
// "SGVsbG8=" (with padding)
```
##### toBase64Url()
> **toBase64Url**: (`value`) => [`BrandedBase64Url`](#brandedbase64url)
Convert BrandedBase64 to BrandedBase64Url
###### Parameters
###### value
[`BrandedBase64`](#brandedbase64)
Base64 string
###### Returns
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
###### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const b64url = Base64.toBase64Url(b64);
// "SGVsbG8" (no padding, URL-safe)
```
##### toBytes()
> **toBytes**: (`value`) => `Uint8Array`\<`ArrayBufferLike`>
Convert BrandedBase64 to bytes
###### Parameters
###### value
[`BrandedBase64`](#brandedbase64)
Base64 string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
###### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const bytes = Base64.toBytes(b64);
// Uint8Array([72, 101, 108, 108, 111])
```
##### toBytesUrlSafe()
> **toBytesUrlSafe**: (`value`) => `Uint8Array`\<`ArrayBufferLike`>
Convert BrandedBase64Url to bytes
###### Parameters
###### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
###### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const bytes = Base64.toBytesUrlSafe(b64url);
// Uint8Array([72, 101, 108, 108, 111])
```
##### toString()
> **toString**: (`value`) => `string`
Convert BrandedBase64 to plain string (strip branding)
###### Parameters
###### value
[`BrandedBase64`](#brandedbase64)
Base64 string
###### Returns
`string`
Plain string
###### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const str = Base64.toString(b64);
// "SGVsbG8=" (plain string)
```
##### toStringUrlSafe()
> **toStringUrlSafe**: (`value`) => `string`
Convert BrandedBase64Url to plain string (strip branding)
###### Parameters
###### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
###### Returns
`string`
Plain string
###### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const str = Base64.toStringUrlSafe(b64url);
// "SGVsbG8" (plain string)
```
#### Example
```typescript theme={null}
// Encode bytes to base64
const data = new Uint8Array([1, 2, 3]);
const encoded = Base64.encode(data);
// Decode base64 to bytes
const decoded = Base64.decode(encoded);
// URL-safe encoding
const urlSafe = Base64.encodeUrlSafe(data);
// Branded types
const b64 = Base64.from("SGVsbG8=");
const bytes = Base64.toBytes(b64);
```
## Functions
### calcDecodedSize()
> **calcDecodedSize**(`encodedLength`): `number`
Defined in: [src/primitives/Base64/calcDecodedSize.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/calcDecodedSize.js#L7)
Calculate decoded size in bytes
#### Parameters
##### encodedLength
`number`
Length of base64 string
#### Returns
`number`
Maximum size of decoded output
***
### calcEncodedSize()
> **calcEncodedSize**(`dataLength`): `number`
Defined in: [src/primitives/Base64/calcEncodedSize.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/calcEncodedSize.js#L7)
Calculate encoded size in bytes
#### Parameters
##### dataLength
`number`
Length of data to encode
#### Returns
`number`
Size of base64 output
***
### decode()
> **decode**(`encoded`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/decode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decode.js#L19)
Decode standard base64 string to bytes
#### Parameters
##### encoded
`string`
Base64 string to decode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### See
[https://voltaire.tevm.sh/primitives/base64](https://voltaire.tevm.sh/primitives/base64) for Base64 documentation
#### Since
0.0.0
#### Throws
If input is invalid base64
#### Example
```javascript theme={null}
import * as Base64 from './primitives/Base64/index.js';
const decoded = Base64.decode('SGVsbG8=');
// Uint8Array([72, 101, 108, 108, 111])
```
***
### decodeToString()
> **decodeToString**(`encoded`): `string`
Defined in: [src/primitives/Base64/decodeToString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeToString.js#L15)
Decode base64 string to UTF-8 string
#### Parameters
##### encoded
`string`
Base64 string
#### Returns
`string`
Decoded string
#### Example
```typescript theme={null}
const str = Base64.decodeToString('SGVsbG8=');
// "Hello"
```
***
### decodeUrlSafe()
> **decodeUrlSafe**(`encoded`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/decodeUrlSafe.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeUrlSafe.js#L10)
Decode URL-safe base64 string to bytes
#### Parameters
##### encoded
`string`
URL-safe base64 string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Throws
If input is invalid
***
### decodeUrlSafeToString()
> **decodeUrlSafeToString**(`encoded`): `string`
Defined in: [src/primitives/Base64/decodeUrlSafeToString.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/decodeUrlSafeToString.js#L9)
Decode URL-safe base64 to UTF-8 string
#### Parameters
##### encoded
`string`
URL-safe base64 string
#### Returns
`string`
Decoded string
***
### encode()
> **encode**(`data`): [`BrandedBase64`](#brandedbase64)
Defined in: [src/primitives/Base64/encode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encode.js#L19)
Encode bytes to standard base64 string
Uses standard base64 alphabet (A-Z, a-z, 0-9, +, /)
with padding (=)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
#### Returns
[`BrandedBase64`](#brandedbase64)
Base64-encoded string
#### Example
```typescript theme={null}
const data = new Uint8Array([72, 101, 108, 108, 111]);
const encoded = Base64.encode(data);
// "SGVsbG8="
```
***
### encodeString()
> **encodeString**(`str`): `string`
Defined in: [src/primitives/Base64/encodeString.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeString.js#L14)
Encode string to base64
#### Parameters
##### str
`string`
String to encode (UTF-8)
#### Returns
`string`
Base64-encoded string
#### Example
```typescript theme={null}
const encoded = Base64.encodeString('Hello, world!');
```
***
### encodeStringUrlSafe()
> **encodeStringUrlSafe**(`str`): [`BrandedBase64Url`](#brandedbase64url)
Defined in: [src/primitives/Base64/encodeStringUrlSafe.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeStringUrlSafe.js#L9)
Encode string to URL-safe base64
#### Parameters
##### str
`string`
String to encode (UTF-8)
#### Returns
[`BrandedBase64Url`](#brandedbase64url)
URL-safe base64 string
***
### encodeUrlSafe()
> **encodeUrlSafe**(`data`): [`BrandedBase64Url`](#brandedbase64url)
Defined in: [src/primitives/Base64/encodeUrlSafe.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/encodeUrlSafe.js#L19)
Encode bytes to URL-safe base64 string
Uses URL-safe alphabet (A-Z, a-z, 0-9, -, \_)
without padding
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Bytes to encode
#### Returns
[`BrandedBase64Url`](#brandedbase64url)
URL-safe base64 string
#### Example
```typescript theme={null}
const data = new Uint8Array([255, 254, 253]);
const encoded = Base64.encodeUrlSafe(data);
// No padding, uses - and _ instead of + and /
```
***
### from()
> **from**(`value`): [`BrandedBase64`](#brandedbase64)
Defined in: [src/primitives/Base64/from.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/from.js#L21)
Convert input to BrandedBase64
#### Parameters
##### value
[`Base64Like`](#base64like)
Input to convert
#### Returns
[`BrandedBase64`](#brandedbase64)
Branded Base64 string
#### Throws
If input cannot be converted to valid Base64
#### Example
```typescript theme={null}
// From string
const b64 = Base64.from("SGVsbG8=");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64 = Base64.from(data);
```
***
### fromUrlSafe()
> **fromUrlSafe**(`value`): [`BrandedBase64Url`](#brandedbase64url)
Defined in: [src/primitives/Base64/fromUrlSafe.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/fromUrlSafe.js#L21)
Convert input to BrandedBase64Url
#### Parameters
##### value
[`Base64UrlLike`](#base64urllike)
Input to convert
#### Returns
[`BrandedBase64Url`](#brandedbase64url)
Branded Base64Url string
#### Throws
If input cannot be converted to valid Base64Url
#### Example
```typescript theme={null}
// From string
const b64url = Base64.fromUrlSafe("SGVsbG8");
// From bytes
const data = new Uint8Array([1, 2, 3]);
const b64url = Base64.fromUrlSafe(data);
```
***
### isValid()
> **isValid**(`str`): `boolean`
Defined in: [src/primitives/Base64/isValid.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/isValid.js#L7)
Check if string is valid base64
#### Parameters
##### str
`string`
String to validate
#### Returns
`boolean`
True if valid base64
***
### isValidUrlSafe()
> **isValidUrlSafe**(`str`): `boolean`
Defined in: [src/primitives/Base64/isValidUrlSafe.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/isValidUrlSafe.js#L7)
Check if string is valid URL-safe base64
#### Parameters
##### str
`string`
String to validate
#### Returns
`boolean`
True if valid URL-safe base64
***
### toBase64()
> **toBase64**(`value`): [`BrandedBase64`](#brandedbase64)
Defined in: [src/primitives/Base64/toBase64.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBase64.js#L17)
Convert BrandedBase64Url to BrandedBase64
#### Parameters
##### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
#### Returns
[`BrandedBase64`](#brandedbase64)
Base64 string
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const b64 = Base64.toBase64(b64url);
// "SGVsbG8=" (with padding)
```
***
### toBase64Url()
> **toBase64Url**(`value`): [`BrandedBase64Url`](#brandedbase64url)
Defined in: [src/primitives/Base64/toBase64Url.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBase64Url.js#L17)
Convert BrandedBase64 to BrandedBase64Url
#### Parameters
##### value
[`BrandedBase64`](#brandedbase64)
Base64 string
#### Returns
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const b64url = Base64.toBase64Url(b64);
// "SGVsbG8" (no padding, URL-safe)
```
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/toBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBytes.js#L16)
Convert BrandedBase64 to bytes
#### Parameters
##### value
[`BrandedBase64`](#brandedbase64)
Base64 string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const bytes = Base64.toBytes(b64);
// Uint8Array([72, 101, 108, 108, 111])
```
***
### toBytesUrlSafe()
> **toBytesUrlSafe**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Base64/toBytesUrlSafe.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toBytesUrlSafe.js#L16)
Convert BrandedBase64Url to bytes
#### Parameters
##### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Decoded bytes
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const bytes = Base64.toBytesUrlSafe(b64url);
// Uint8Array([72, 101, 108, 108, 111])
```
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Base64/toString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toString.js#L15)
Convert BrandedBase64 to plain string (strip branding)
#### Parameters
##### value
[`BrandedBase64`](#brandedbase64)
Base64 string
#### Returns
`string`
Plain string
#### Example
```typescript theme={null}
const b64 = Base64.from("SGVsbG8=");
const str = Base64.toString(b64);
// "SGVsbG8=" (plain string)
```
***
### toStringUrlSafe()
> **toStringUrlSafe**(`value`): `string`
Defined in: [src/primitives/Base64/toStringUrlSafe.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Base64/toStringUrlSafe.js#L14)
Convert BrandedBase64Url to plain string (strip branding)
#### Parameters
##### value
[`BrandedBase64Url`](#brandedbase64url)
Base64Url string
#### Returns
`string`
Plain string
#### Example
```typescript theme={null}
const b64url = Base64.fromUrlSafe("SGVsbG8");
const str = Base64.toStringUrlSafe(b64url);
// "SGVsbG8" (plain string)
```
# primitives/BaseFeePerGas
Source: https://voltaire.tevm.sh/generated-api/primitives/BaseFeePerGas
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BaseFeePerGas
# primitives/BaseFeePerGas
## Type Aliases
### BaseFeePerGasType
> **BaseFeePerGasType** = `bigint` & `object`
Defined in: [src/primitives/BaseFeePerGas/BaseFeePerGasType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/BaseFeePerGasType.ts#L10)
Branded BaseFeePerGas type - EIP-1559 base fee per gas
Represents the minimum gas price required for transaction inclusion
Base fee is burned and adjusts dynamically based on block fullness
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BaseFeePerGas"`
#### See
[https://eips.ethereum.org/EIPS/eip-1559](https://eips.ethereum.org/EIPS/eip-1559)
## Variables
### BaseFeePerGas
> `const` **BaseFeePerGas**: `object`
Defined in: [src/primitives/BaseFeePerGas/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L53)
#### Type Declaration
##### compare()
> **compare**: (`baseFee1`, `baseFee2`) => `number`
###### Parameters
###### baseFee1
`string` | `number` | `bigint`
###### baseFee2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`baseFee1`, `baseFee2`) => `boolean`
###### Parameters
###### baseFee1
`string` | `number` | `bigint`
###### baseFee2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`BaseFeePerGasType`](#basefeepergastype)
Create BaseFeePerGas from bigint, number, or hex string
###### Parameters
###### value
Base fee in Wei
`string` | `number` | `bigint`
###### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Branded base fee
###### Throws
If value is negative or invalid format
###### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n); // 25 Gwei
const baseFee2 = BaseFeePerGas.from("0x5d21dba00");
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`BaseFeePerGasType`](#basefeepergastype)
Create BaseFeePerGas from Gwei value
###### Parameters
###### gwei
Value in Gwei
`number` | `bigint`
###### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Base fee in Wei
###### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.fromGwei(25n); // 25 Gwei = 25000000000 Wei
```
##### fromWei()
> **fromWei**: (`wei`) => [`BaseFeePerGasType`](#basefeepergastype)
Create BaseFeePerGas from Wei value (alias for from)
###### Parameters
###### wei
Value in Wei
`string` | `number` | `bigint`
###### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Base fee
###### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.fromWei(25000000000n);
```
##### toBigInt()
> **toBigInt**: (`baseFee`) => `bigint`
###### Parameters
###### baseFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGwei()
> **toGwei**: (`baseFee`) => `bigint`
###### Parameters
###### baseFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`baseFee`) => `number`
###### Parameters
###### baseFee
`string` | `number` | `bigint`
###### Returns
`number`
##### toWei()
> **toWei**: (`baseFee`) => `bigint`
###### Parameters
###### baseFee
`string` | `number` | `bigint`
###### Returns
`bigint`
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/BaseFeePerGas/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/compare.js#L15)
Compare two BaseFeePerGas values
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
##### other
[`BaseFeePerGasType`](#basefeepergastype)
Value to compare
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const fee1 = BaseFeePerGas.from(25000000000n);
const fee2 = BaseFeePerGas.from(30000000000n);
BaseFeePerGas.compare(fee1, fee2); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/BaseFeePerGas/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/equals.js#L15)
Check if two BaseFeePerGas values are equal
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
##### other
[`BaseFeePerGasType`](#basefeepergastype)
Value to compare
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const fee1 = BaseFeePerGas.from(25000000000n);
const fee2 = BaseFeePerGas.from(25000000000n);
BaseFeePerGas.equals(fee1, fee2); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/toBigInt.js#L13)
Convert BaseFeePerGas to bigint (identity function)
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
#### Returns
`bigint`
Value as bigint
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n);
BaseFeePerGas.toBigInt(baseFee); // 25000000000n
```
***
### \_toGwei()
> **\_toGwei**(`this`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/toGwei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/toGwei.js#L13)
Convert BaseFeePerGas to Gwei
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
#### Returns
`bigint`
Value in Gwei
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n);
BaseFeePerGas.toGwei(baseFee); // 25n Gwei
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/BaseFeePerGas/toNumber.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/toNumber.js#L14)
Convert BaseFeePerGas to number
WARNING: May lose precision for large values
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
#### Returns
`number`
Value as number
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n);
BaseFeePerGas.toNumber(baseFee); // 25000000000
```
***
### \_toWei()
> **\_toWei**(`this`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/toWei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/toWei.js#L13)
Convert BaseFeePerGas to Wei (identity function)
#### Parameters
##### this
[`BaseFeePerGasType`](#basefeepergastype)
#### Returns
`bigint`
Value in Wei
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n);
BaseFeePerGas.toWei(baseFee); // 25000000000n Wei
```
***
### compare()
> **compare**(`baseFee1`, `baseFee2`): `number`
Defined in: [src/primitives/BaseFeePerGas/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L42)
#### Parameters
##### baseFee1
`string` | `number` | `bigint`
##### baseFee2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`baseFee1`, `baseFee2`): `boolean`
Defined in: [src/primitives/BaseFeePerGas/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L35)
#### Parameters
##### baseFee1
`string` | `number` | `bigint`
##### baseFee2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`BaseFeePerGasType`](#basefeepergastype)
Defined in: [src/primitives/BaseFeePerGas/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/from.js#L16)
Create BaseFeePerGas from bigint, number, or hex string
#### Parameters
##### value
Base fee in Wei
`string` | `number` | `bigint`
#### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Branded base fee
#### Throws
If value is negative or invalid format
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.from(25000000000n); // 25 Gwei
const baseFee2 = BaseFeePerGas.from("0x5d21dba00");
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`BaseFeePerGasType`](#basefeepergastype)
Defined in: [src/primitives/BaseFeePerGas/fromGwei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/fromGwei.js#L12)
Create BaseFeePerGas from Gwei value
#### Parameters
##### gwei
Value in Gwei
`number` | `bigint`
#### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Base fee in Wei
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.fromGwei(25n); // 25 Gwei = 25000000000 Wei
```
***
### fromWei()
> **fromWei**(`wei`): [`BaseFeePerGasType`](#basefeepergastype)
Defined in: [src/primitives/BaseFeePerGas/fromWei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/fromWei.js#L12)
Create BaseFeePerGas from Wei value (alias for from)
#### Parameters
##### wei
Value in Wei
`string` | `number` | `bigint`
#### Returns
[`BaseFeePerGasType`](#basefeepergastype)
Base fee
#### Example
```typescript theme={null}
const baseFee = BaseFeePerGas.fromWei(25000000000n);
```
***
### toBigInt()
> **toBigInt**(`baseFee`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L31)
#### Parameters
##### baseFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toGwei()
> **toGwei**(`baseFee`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L19)
#### Parameters
##### baseFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toNumber()
> **toNumber**(`baseFee`): `number`
Defined in: [src/primitives/BaseFeePerGas/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L27)
#### Parameters
##### baseFee
`string` | `number` | `bigint`
#### Returns
`number`
***
### toWei()
> **toWei**(`baseFee`): `bigint`
Defined in: [src/primitives/BaseFeePerGas/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BaseFeePerGas/index.ts#L23)
#### Parameters
##### baseFee
`string` | `number` | `bigint`
#### Returns
`bigint`
# primitives/BeaconBlockRoot
Source: https://voltaire.tevm.sh/generated-api/primitives/BeaconBlockRoot
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BeaconBlockRoot
# primitives/BeaconBlockRoot
## Type Aliases
### BeaconBlockRootType
> **BeaconBlockRootType** = `Uint8Array` & `object`
Defined in: [src/primitives/BeaconBlockRoot/BeaconBlockRootType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/BeaconBlockRootType.ts#L13)
BeaconBlockRoot type
Represents a 32-byte beacon chain block root hash (EIP-4788).
Available in the EVM via BLOCKHASH opcode for recent slots.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BeaconBlockRoot"`
##### length
> **length**: `32`
#### See
* [https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
* [https://eips.ethereum.org/EIPS/eip-4788](https://eips.ethereum.org/EIPS/eip-4788) for EIP-4788 specification
#### Since
0.0.0
## Variables
### BeaconBlockRoot
> `const` **BeaconBlockRoot**: `object`
Defined in: [src/primitives/BeaconBlockRoot/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/index.ts#L12)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if BeaconBlockRoot values are equal
###### Parameters
###### a
[`BeaconBlockRootType`](#beaconblockroottype)
First root
###### b
[`BeaconBlockRootType`](#beaconblockroottype)
Second root
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const a = BeaconBlockRoot.from('0x1234...');
const b = BeaconBlockRoot.from('0x1234...');
const result = BeaconBlockRoot.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`BeaconBlockRootType`](#beaconblockroottype)
Create BeaconBlockRoot from string or bytes
###### Parameters
###### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
###### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
###### Since
0.0.0
###### Throws
If input is invalid or wrong length
###### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root1 = BeaconBlockRoot.from('0x1234...');
const root2 = BeaconBlockRoot.from(new Uint8Array(32));
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`BeaconBlockRootType`](#beaconblockroottype)
Create BeaconBlockRoot from Uint8Array
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
###### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
###### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
###### Since
0.0.0
###### Throws
If bytes length is not 32
###### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.fromBytes(new Uint8Array(32));
```
##### fromHex()
> **fromHex**: (`hex`) => [`BeaconBlockRootType`](#beaconblockroottype)
Create BeaconBlockRoot from hex string
###### Parameters
###### hex
`string`
Hex string with optional 0x prefix
###### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
###### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
###### Since
0.0.0
###### Throws
If hex string is invalid or wrong length
###### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.fromHex('0x1234...');
```
##### toHex()
> **toHex**: (`root`) => `string`
Convert BeaconBlockRoot to hex string
###### Parameters
###### root
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.from(new Uint8Array(32));
const hex = BeaconBlockRoot.toHex(root); // "0x0000..."
```
***
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/BeaconBlockRoot/BeaconBlockRootType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/BeaconBlockRootType.ts#L18)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/BeaconBlockRoot/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/equals.js#L18)
Check if BeaconBlockRoot values are equal
#### Parameters
##### a
[`BeaconBlockRootType`](#beaconblockroottype)
First root
##### b
[`BeaconBlockRootType`](#beaconblockroottype)
Second root
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const a = BeaconBlockRoot.from('0x1234...');
const b = BeaconBlockRoot.from('0x1234...');
const result = BeaconBlockRoot.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`BeaconBlockRootType`](#beaconblockroottype)
Defined in: [src/primitives/BeaconBlockRoot/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/from.js#L19)
Create BeaconBlockRoot from string or bytes
#### Parameters
##### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
#### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
#### Since
0.0.0
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root1 = BeaconBlockRoot.from('0x1234...');
const root2 = BeaconBlockRoot.from(new Uint8Array(32));
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`BeaconBlockRootType`](#beaconblockroottype)
Defined in: [src/primitives/BeaconBlockRoot/fromBytes.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/fromBytes.js#L17)
Create BeaconBlockRoot from Uint8Array
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
#### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
#### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
#### Since
0.0.0
#### Throws
If bytes length is not 32
#### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.fromBytes(new Uint8Array(32));
```
***
### fromHex()
> **fromHex**(`hex`): [`BeaconBlockRootType`](#beaconblockroottype)
Defined in: [src/primitives/BeaconBlockRoot/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/fromHex.js#L19)
Create BeaconBlockRoot from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix
#### Returns
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
#### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
#### Since
0.0.0
#### Throws
If hex string is invalid or wrong length
#### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.fromHex('0x1234...');
```
***
### toHex()
> **toHex**(`root`): `string`
Defined in: [src/primitives/BeaconBlockRoot/toHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BeaconBlockRoot/toHex.js#L18)
Convert BeaconBlockRoot to hex string
#### Parameters
##### root
[`BeaconBlockRootType`](#beaconblockroottype)
BeaconBlockRoot
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/beacon-block-root](https://voltaire.tevm.sh/primitives/beacon-block-root) for BeaconBlockRoot documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as BeaconBlockRoot from './primitives/BeaconBlockRoot/index.js';
const root = BeaconBlockRoot.from(new Uint8Array(32));
const hex = BeaconBlockRoot.toHex(root); // "0x0000..."
```
# primitives/BinaryTree
Source: https://voltaire.tevm.sh/generated-api/primitives/BinaryTree
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BinaryTree
# primitives/BinaryTree
## Classes
### InvalidAddressLengthError
Defined in: [src/primitives/BinaryTree/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L19)
Error thrown when an invalid address length is provided
#### Example
```typescript theme={null}
throw new InvalidAddressLengthError(
'Address must be 20 bytes',
{
value: addr.length,
expected: '20 bytes',
code: 'BINARY_TREE_INVALID_ADDRESS_LENGTH',
docsPath: '/primitives/binary-tree/address-to-key#error-handling'
}
)
```
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidAddressLengthError**(`message?`, `options?`): [`InvalidAddressLengthError`](#invalidaddresslengtherror)
Defined in: [src/primitives/BinaryTree/errors.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L30)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidAddressLengthError`](#invalidaddresslengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/BinaryTree/errors.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L41)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidKeyLengthError
Defined in: [src/primitives/BinaryTree/errors.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L61)
Error thrown when an invalid key length is provided
#### Example
```typescript theme={null}
throw new InvalidKeyLengthError(
'Key must be 32 bytes',
{
value: key.length,
expected: '32 bytes',
code: 'BINARY_TREE_INVALID_KEY_LENGTH',
docsPath: '/primitives/binary-tree/split-key#error-handling'
}
)
```
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidKeyLengthError**(`message?`, `options?`): [`InvalidKeyLengthError`](#invalidkeylengtherror)
Defined in: [src/primitives/BinaryTree/errors.js:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L72)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidKeyLengthError`](#invalidkeylengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/BinaryTree/errors.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L82)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidTreeStateError
Defined in: [src/primitives/BinaryTree/errors.js:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L102)
Error thrown when tree is in invalid state
#### Example
```typescript theme={null}
throw new InvalidTreeStateError(
'Cannot insert into leaf node',
{
value: node.type,
expected: 'empty, stem, or internal',
code: 'BINARY_TREE_INVALID_STATE',
docsPath: '/primitives/binary-tree/insert#error-handling'
}
)
```
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidTreeStateError**(`message?`, `options?`): [`InvalidTreeStateError`](#invalidtreestateerror)
Defined in: [src/primitives/BinaryTree/errors.js:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L113)
###### Parameters
###### message?
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidTreeStateError`](#invalidtreestateerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### name
> **name**: `string`
Defined in: [src/primitives/BinaryTree/errors.js:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/errors.js#L122)
###### Inherited from
`ValidationError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
## Interfaces
### AccountData
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L37)
Account basic data layout at index 0
* Version (1 byte)
* Code size (3 bytes)
* Nonce (8 bytes)
* Balance (16 bytes)
#### Properties
##### balance
> `readonly` **balance**: `bigint`
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L41)
##### codeSize
> `readonly` **codeSize**: `number`
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L39)
##### nonce
> `readonly` **nonce**: `bigint`
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L40)
##### version
> `readonly` **version**: `number`
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L38)
***
### BinaryTreeType
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L7)
Binary State Tree (EIP-7864) - Unified tree structure for Ethereum state
#### See
[https://eips.ethereum.org/EIPS/eip-7864](https://eips.ethereum.org/EIPS/eip-7864)
#### Properties
##### root
> `readonly` **root**: [`Node`](#node)
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L8)
## Type Aliases
### EmptyNode
> **EmptyNode** = `Extract`\<[`Node`](#node), \{ `type`: `"empty"`; }>
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L28)
***
### InternalNode
> **InternalNode** = `Extract`\<[`Node`](#node), \{ `type`: `"internal"`; }>
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L25)
***
### LeafNode
> **LeafNode** = `Extract`\<[`Node`](#node), \{ `type`: `"leaf"`; }>
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L27)
***
### Node
> **Node** = \{ `type`: `"empty"`; } | \{ `left`: `Uint8Array`; `right`: `Uint8Array`; `type`: `"internal"`; } | \{ `stem`: `Uint8Array`; `type`: `"stem"`; `values`: (`Uint8Array` | `null`)\[]; } | \{ `type`: `"leaf"`; `value`: `Uint8Array`; }
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L11)
***
### StemNode
> **StemNode** = `Extract`\<[`Node`](#node), \{ `type`: `"stem"`; }>
Defined in: [src/primitives/BinaryTree/BinaryTreeType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/BinaryTreeType.ts#L26)
## Variables
### addressToKey()
> `const` **addressToKey**: (`address`) => `Uint8Array` = `_addressToKey`
Defined in: [src/primitives/BinaryTree/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L56)
#### Parameters
##### address
`Uint8Array`
#### Returns
`Uint8Array`
***
### BinaryTree
> `const` **BinaryTree**: `object`
Defined in: [src/primitives/BinaryTree/index.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L76)
#### Type Declaration
##### addressToKey()
> **addressToKey**: (`address`) => `Uint8Array`
###### Parameters
###### address
`Uint8Array`
###### Returns
`Uint8Array`
##### get()
> **get**: (`tree`, `key`) => `Uint8Array`\<`ArrayBufferLike`> | `null`
###### Parameters
###### tree
[`BinaryTreeType`](#binarytreetype)
###### key
`Uint8Array`
###### Returns
`Uint8Array`\<`ArrayBufferLike`> | `null`
##### getStemBit()
> **getStemBit**: (`stem`, `index`) => `0` | `1`
###### Parameters
###### stem
`Uint8Array`
###### index
`number`
###### Returns
`0` | `1`
##### hashInternal()
> **hashInternal**: (`l`, `r`) => `Uint8Array`
###### Parameters
###### l
`Uint8Array`
###### r
`Uint8Array`
###### Returns
`Uint8Array`
##### hashLeaf()
> **hashLeaf**: (`node`) => `Uint8Array`
###### Parameters
###### node
###### type
`"leaf"`
###### value
`Uint8Array`
###### Returns
`Uint8Array`
##### hashNode()
> **hashNode**: (`node`) => `Uint8Array`
###### Parameters
###### node
[`Node`](#node)
###### Returns
`Uint8Array`
##### hashStem()
> **hashStem**: (`node`) => `Uint8Array`
###### Parameters
###### node
###### stem
`Uint8Array`
###### type
`"stem"`
###### values
(`Uint8Array`\<`ArrayBufferLike`> | `null`)\[]
###### Returns
`Uint8Array`
##### init()
> **init**: () => [`BinaryTreeType`](#binarytreetype)
###### Returns
[`BinaryTreeType`](#binarytreetype)
##### insert()
> **insert**: (`tree`, `key`, `value`) => [`BinaryTreeType`](#binarytreetype)
###### Parameters
###### tree
[`BinaryTreeType`](#binarytreetype)
###### key
`Uint8Array`
###### value
`Uint8Array`
###### Returns
[`BinaryTreeType`](#binarytreetype)
##### rootHash()
> **rootHash**: (`tree`) => `Uint8Array`
###### Parameters
###### tree
[`BinaryTreeType`](#binarytreetype)
###### Returns
`Uint8Array`
##### rootHashHex()
> **rootHashHex**: (`tree`) => [`HexType`](Hex.mdx#hextype)
###### Parameters
###### tree
[`BinaryTreeType`](#binarytreetype)
###### Returns
[`HexType`](Hex.mdx#hextype)
##### splitKey()
> **splitKey**: (`key`) => `object`
###### Parameters
###### key
`Uint8Array`
###### Returns
`object`
###### idx
> **idx**: `number`
###### stem
> **stem**: `Uint8Array`
***
### get()
> `const` **get**: (`tree`, `key`) => `Uint8Array` | `null` = `_get`
Defined in: [src/primitives/BinaryTree/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L67)
#### Parameters
##### tree
[`BinaryTreeType`](#binarytreetype)
##### key
`Uint8Array`
#### Returns
`Uint8Array` | `null`
***
### getStemBit()
> `const` **getStemBit**: (`stem`, `index`) => `0` | `1` = `_getStemBit`
Defined in: [src/primitives/BinaryTree/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L59)
#### Parameters
##### stem
`Uint8Array`
##### index
`number`
#### Returns
`0` | `1`
***
### hashInternal()
> `const` **hashInternal**: (`l`, `r`) => `Uint8Array`
Defined in: [src/primitives/BinaryTree/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L49)
#### Parameters
##### l
`Uint8Array`
##### r
`Uint8Array`
#### Returns
`Uint8Array`
***
### HashInternal()
> `const` **HashInternal**: (`deps`) => (`l`, `r`) => `Uint8Array` = `_HashInternal`
Defined in: [src/primitives/BinaryTree/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L38)
#### Parameters
##### deps
`Blake3Deps`
#### Returns
> (`l`, `r`): `Uint8Array`
##### Parameters
###### l
`Uint8Array`
###### r
`Uint8Array`
##### Returns
`Uint8Array`
***
### hashLeaf()
> `const` **hashLeaf**: (`node`) => `Uint8Array`
Defined in: [src/primitives/BinaryTree/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L52)
#### Parameters
##### node
[`LeafNode`](#leafnode)
#### Returns
`Uint8Array`
***
### HashLeaf()
> `const` **HashLeaf**: (`deps`) => (`node`) => `Uint8Array` = `_HashLeaf`
Defined in: [src/primitives/BinaryTree/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L43)
#### Parameters
##### deps
`Blake3Deps`
#### Returns
> (`node`): `Uint8Array`
##### Parameters
###### node
[`LeafNode`](#leafnode)
##### Returns
`Uint8Array`
***
### hashNode()
> `const` **hashNode**: (`node`) => `Uint8Array`
Defined in: [src/primitives/BinaryTree/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L53)
#### Parameters
##### node
[`Node`](#node)
#### Returns
`Uint8Array`
***
### HashNode()
> `const` **HashNode**: (`deps`) => (`node`) => `Uint8Array` = `_HashNode`
Defined in: [src/primitives/BinaryTree/index.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L45)
#### Parameters
##### deps
`Blake3Deps`
#### Returns
> (`node`): `Uint8Array`
##### Parameters
###### node
[`Node`](#node)
##### Returns
`Uint8Array`
***
### hashStem()
> `const` **hashStem**: (`node`) => `Uint8Array`
Defined in: [src/primitives/BinaryTree/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L51)
#### Parameters
##### node
[`StemNode`](#stemnode)
#### Returns
`Uint8Array`
***
### HashStem()
> `const` **HashStem**: (`deps`) => (`node`) => `Uint8Array` = `_HashStem`
Defined in: [src/primitives/BinaryTree/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L41)
#### Parameters
##### deps
`Blake3Deps`
#### Returns
> (`node`): `Uint8Array`
##### Parameters
###### node
[`StemNode`](#stemnode)
##### Returns
`Uint8Array`
***
### init()
> `const` **init**: () => [`BinaryTreeType`](#binarytreetype) = `_init`
Defined in: [src/primitives/BinaryTree/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L61)
#### Returns
[`BinaryTreeType`](#binarytreetype)
***
### insert()
> `const` **insert**: (`tree`, `key`, `value`) => [`BinaryTreeType`](#binarytreetype)
Defined in: [src/primitives/BinaryTree/index.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L62)
#### Parameters
##### tree
[`BinaryTreeType`](#binarytreetype)
##### key
`Uint8Array`
##### value
`Uint8Array`
#### Returns
[`BinaryTreeType`](#binarytreetype)
***
### rootHash()
> `const` **rootHash**: (`tree`) => `Uint8Array` = `_rootHash`
Defined in: [src/primitives/BinaryTree/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L71)
#### Parameters
##### tree
[`BinaryTreeType`](#binarytreetype)
#### Returns
`Uint8Array`
***
### rootHashHex()
> `const` **rootHashHex**: (`tree`) => [`HexType`](Hex.mdx#hextype) = `_rootHashHex`
Defined in: [src/primitives/BinaryTree/index.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L72)
#### Parameters
##### tree
[`BinaryTreeType`](#binarytreetype)
#### Returns
[`HexType`](Hex.mdx#hextype)
***
### splitKey()
> `const` **splitKey**: (`key`) => `object` = `_splitKey`
Defined in: [src/primitives/BinaryTree/index.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BinaryTree/index.ts#L57)
#### Parameters
##### key
`Uint8Array`
#### Returns
`object`
##### idx
> **idx**: `number`
##### stem
> **stem**: `Uint8Array`
# primitives/Blob
Source: https://voltaire.tevm.sh/generated-api/primitives/Blob
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Blob
# primitives/Blob
## Interfaces
### BlobInstance
Defined in: [src/primitives/Blob/index.ts:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L253)
#### Methods
##### toCommitment()
> **toCommitment**(): [`Commitment`](#commitment)
Defined in: [src/primitives/Blob/index.ts:255](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L255)
###### Returns
[`Commitment`](#commitment)
##### toData()
> **toData**(): `Uint8Array`
Defined in: [src/primitives/Blob/index.ts:254](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L254)
###### Returns
`Uint8Array`
##### toProof()
> **toProof**(`commitment`): [`Proof`](#proof)
Defined in: [src/primitives/Blob/index.ts:256](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L256)
###### Parameters
###### commitment
[`Commitment`](#commitment)
###### Returns
[`Proof`](#proof)
##### verify()
> **verify**(`commitment`, `proof`): `boolean`
Defined in: [src/primitives/Blob/index.ts:257](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L257)
###### Parameters
###### commitment
[`Commitment`](#commitment)
###### proof
[`Proof`](#proof)
###### Returns
`boolean`
## Type Aliases
### BrandedBlob
> **BrandedBlob** = `Uint8Array` & `object`
Defined in: [src/primitives/Blob/BlobType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/BlobType.ts#L10)
Blob data (exactly 131072 bytes)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Blob"`
***
### Commitment
> **Commitment** = `Uint8Array` & `object`
Defined in: [src/primitives/Blob/BlobType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/BlobType.ts#L15)
KZG commitment (48 bytes)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Commitment"`
***
### Proof
> **Proof** = `Uint8Array` & `object`
Defined in: [src/primitives/Blob/BlobType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/BlobType.ts#L20)
KZG proof (48 bytes)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Proof"`
***
### VersionedHash
> **VersionedHash** = `Uint8Array` & `object`
Defined in: [src/primitives/Blob/BlobType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/BlobType.ts#L25)
Versioned hash (32 bytes) - commitment hash with version prefix
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"VersionedHash"`
## Variables
### BYTES\_PER\_FIELD\_ELEMENT
> `const` **BYTES\_PER\_FIELD\_ELEMENT**: `32` = `32`
Defined in: [src/primitives/Blob/constants.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L24)
Bytes per field element
#### Since
0.0.0
***
### calculateGas()
> `const` **calculateGas**: (`blobCount`) => `number` = `_calculateGas`
Defined in: [src/primitives/Blob/index.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L45)
#### Parameters
##### blobCount
`number`
#### Returns
`number`
***
### COMMITMENT\_VERSION\_KZG
> `const` **COMMITMENT\_VERSION\_KZG**: `1` = `0x01`
Defined in: [src/primitives/Blob/constants.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L36)
Blob commitment version byte for KZG
#### Since
0.0.0
***
### CommitmentNamespace
> `const` **CommitmentNamespace**: `object`
Defined in: [src/primitives/Blob/index.ts:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L155)
#### Type Declaration
##### isValid()
> **isValid**: (`commitment`) => `boolean`
###### Parameters
###### commitment
`Uint8Array`
###### Returns
`boolean`
##### toVersionedHash()
> **toVersionedHash**: (`commitment`) => [`VersionedHash`](#versionedhash)
###### Parameters
###### commitment
[`Commitment`](#commitment)
###### Returns
[`VersionedHash`](#versionedhash)
***
### estimateBlobCount()
> `const` **estimateBlobCount**: (`dataSize`) => `number` = `_estimateBlobCount`
Defined in: [src/primitives/Blob/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L46)
#### Parameters
##### dataSize
`number`
#### Returns
`number`
***
### FIELD\_ELEMENTS\_PER\_BLOB
> `const` **FIELD\_ELEMENTS\_PER\_BLOB**: `4096` = `4096`
Defined in: [src/primitives/Blob/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L18)
Number of field elements per blob
#### Since
0.0.0
***
### from()
> `const` **from**: (`value`) => [`BrandedBlob`](#brandedblob) = `_from`
Defined in: [src/primitives/Blob/index.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L47)
#### Parameters
##### value
`Uint8Array`
#### Returns
[`BrandedBlob`](#brandedblob)
***
### fromData()
> `const` **fromData**: (`data`) => [`BrandedBlob`](#brandedblob) = `_fromData`
Defined in: [src/primitives/Blob/index.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L48)
#### Parameters
##### data
`Uint8Array`
#### Returns
[`BrandedBlob`](#brandedblob)
***
### GAS\_PER\_BLOB
> `const` **GAS\_PER\_BLOB**: `131072` = `131072`
Defined in: [src/primitives/Blob/constants.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L42)
Blob gas per blob (2^17)
#### Since
0.0.0
***
### isValid()
> `const` **isValid**: (`blob`) => `boolean` = `_isValid`
Defined in: [src/primitives/Blob/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L49)
#### Parameters
##### blob
`Uint8Array`
#### Returns
`boolean`
***
### isValidVersion()
> `const` **isValidVersion**: (`hash`) => `boolean` = `_isValidVersion`
Defined in: [src/primitives/Blob/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L50)
#### Parameters
##### hash
[`VersionedHash`](#versionedhash)
#### Returns
`boolean`
***
### joinData()
> `const` **joinData**: (`blobs`) => `Uint8Array` = `_joinData`
Defined in: [src/primitives/Blob/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L51)
#### Parameters
##### blobs
readonly [`BrandedBlob`](#brandedblob)\[]
#### Returns
`Uint8Array`
***
### MAX\_DATA\_PER\_BLOB
> `const` **MAX\_DATA\_PER\_BLOB**: `number`
Defined in: [src/primitives/Blob/constants.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L54)
Maximum data bytes per blob (field elements \* 31 bytes - 4 byte length prefix)
#### Since
0.0.0
***
### MAX\_PER\_TRANSACTION
> `const` **MAX\_PER\_TRANSACTION**: `6` = `6`
Defined in: [src/primitives/Blob/constants.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L30)
Maximum blobs per transaction
#### Since
0.0.0
***
### ProofNamespace
> `const` **ProofNamespace**: `object`
Defined in: [src/primitives/Blob/index.ts:164](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L164)
#### Type Declaration
##### isValid()
> **isValid**: (`proof`) => `boolean`
###### Parameters
###### proof
`Uint8Array`
###### Returns
`boolean`
***
### SIZE
> `const` **SIZE**: `131072` = `131072`
Defined in: [src/primitives/Blob/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L12)
Blob size in bytes (128 KB = 4096 field elements \* 32 bytes)
#### Since
0.0.0
***
### splitData()
> `const` **splitData**: (`data`) => [`BrandedBlob`](#brandedblob)\[] = `_splitData`
Defined in: [src/primitives/Blob/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L52)
#### Parameters
##### data
`Uint8Array`
#### Returns
[`BrandedBlob`](#brandedblob)\[]
***
### TARGET\_GAS\_PER\_BLOCK
> `const` **TARGET\_GAS\_PER\_BLOCK**: `393216` = `393216`
Defined in: [src/primitives/Blob/constants.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/constants.js#L48)
Target blob gas per block (3 blobs)
#### Since
0.0.0
***
### toCommitment()
> `const` **toCommitment**: (`blob`) => [`Commitment`](#commitment)
Defined in: [src/primitives/Blob/index.ts:101](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L101)
#### Parameters
##### blob
[`BrandedBlob`](#brandedblob)
#### Returns
[`Commitment`](#commitment)
***
### ToCommitment()
> `const` **ToCommitment**: (`deps`) => (`blob`) => [`Commitment`](#commitment) = `_ToCommitment`
Defined in: [src/primitives/Blob/index.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L55)
#### Parameters
##### deps
###### blobToKzgCommitment
(`blob`) => `Uint8Array`
#### Returns
> (`blob`): [`Commitment`](#commitment)
##### Parameters
###### blob
[`BrandedBlob`](#brandedblob)
##### Returns
[`Commitment`](#commitment)
***
### toData()
> `const` **toData**: (`blob`) => `Uint8Array` = `_toData`
Defined in: [src/primitives/Blob/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L53)
#### Parameters
##### blob
[`BrandedBlob`](#brandedblob)
#### Returns
`Uint8Array`
***
### toProof()
> `const` **toProof**: (`blob`, `commitment`) => [`Proof`](#proof)
Defined in: [src/primitives/Blob/index.ts:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L104)
#### Parameters
##### blob
[`BrandedBlob`](#brandedblob)
##### commitment
[`Commitment`](#commitment)
#### Returns
[`Proof`](#proof)
***
### ToProof()
> `const` **ToProof**: (`deps`) => (`blob`, `commitment`) => [`Proof`](#proof)
Defined in: [src/primitives/Blob/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L58)
#### Parameters
##### deps
###### computeBlobKzgProof
(`blob`, `commitment`) => `Uint8Array`
#### Returns
> (`blob`, `commitment`): [`Proof`](#proof)
##### Parameters
###### blob
[`BrandedBlob`](#brandedblob)
###### commitment
[`Commitment`](#commitment)
##### Returns
[`Proof`](#proof)
***
### toVersionedHash()
> `const` **toVersionedHash**: (`commitment`) => [`VersionedHash`](#versionedhash)
Defined in: [src/primitives/Blob/index.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L100)
#### Parameters
##### commitment
[`Commitment`](#commitment)
#### Returns
[`VersionedHash`](#versionedhash)
***
### ToVersionedHash()
> `const` **ToVersionedHash**: (`deps`) => (`commitment`) => [`VersionedHash`](#versionedhash) = `_ToVersionedHash`
Defined in: [src/primitives/Blob/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L61)
#### Parameters
##### deps
###### sha256
(`data`) => `Uint8Array`
#### Returns
> (`commitment`): [`VersionedHash`](#versionedhash)
##### Parameters
###### commitment
[`Commitment`](#commitment)
##### Returns
[`VersionedHash`](#versionedhash)
***
### verify()
> `const` **verify**: (`blob`, `commitment`, `proof`) => `boolean`
Defined in: [src/primitives/Blob/index.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L107)
#### Parameters
##### blob
[`BrandedBlob`](#brandedblob)
##### commitment
[`Commitment`](#commitment)
##### proof
[`Proof`](#proof)
#### Returns
`boolean`
***
### Verify()
> `const` **Verify**: (`deps`) => (`blob`, `commitment`, `proof`) => `boolean` = `_Verify`
Defined in: [src/primitives/Blob/index.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L64)
#### Parameters
##### deps
###### verifyBlobKzgProof
(`blob`, `commitment`, `proof`) => `boolean`
#### Returns
> (`blob`, `commitment`, `proof`): `boolean`
##### Parameters
###### blob
[`BrandedBlob`](#brandedblob)
###### commitment
[`Commitment`](#commitment)
###### proof
[`Proof`](#proof)
##### Returns
`boolean`
***
### verifyBatch()
> `const` **verifyBatch**: (`blobs`, `commitments`, `proofs`) => `boolean`
Defined in: [src/primitives/Blob/index.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L110)
#### Parameters
##### blobs
readonly [`BrandedBlob`](#brandedblob)\[]
##### commitments
readonly [`Commitment`](#commitment)\[]
##### proofs
readonly [`Proof`](#proof)\[]
#### Returns
`boolean`
***
### VerifyBatch()
> `const` **VerifyBatch**: (`deps`) => (`blobs`, `commitments`, `proofs`) => `boolean` = `_VerifyBatch`
Defined in: [src/primitives/Blob/index.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L76)
#### Parameters
##### deps
###### verifyBlobKzgProofBatch
(`blobs`, `commitments`, `proofs`) => `boolean`
#### Returns
> (`blobs`, `commitments`, `proofs`): `boolean`
##### Parameters
###### blobs
readonly [`BrandedBlob`](#brandedblob)\[]
###### commitments
readonly [`Commitment`](#commitment)\[]
###### proofs
readonly [`Proof`](#proof)\[]
##### Returns
`boolean`
***
### VersionedHashNamespace
> `const` **VersionedHashNamespace**: `object`
Defined in: [src/primitives/Blob/index.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L170)
#### Type Declaration
##### getVersion()
> **getVersion**: (`hash`) => `number`
###### Parameters
###### hash
`Uint8Array`
###### Returns
`number`
##### isValid()
> **isValid**: (`hash`) => `boolean`
###### Parameters
###### hash
`Uint8Array`
###### Returns
`boolean`
##### version()
> **version**: (`hash`) => `number`
###### Parameters
###### hash
`Uint8Array`
###### Returns
`number`
## Functions
### Blob()
> **Blob**(`value`): `Uint8Array`\<`ArrayBufferLike`> & `object` & [`BlobInstance`](#blobinstance)
Defined in: [src/primitives/Blob/index.ts:239](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Blob/index.ts#L239)
Creates a Blob instance from various input types.
Canonical Class API constructor. Supports:
* Number (creates empty blob of specified size)
* Raw blob data (131072 bytes)
* Data to encode (auto-encodes with length prefix)
#### Parameters
##### value
Number for size or Uint8Array (either 131072 bytes blob or data to encode)
`number` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`\<`ArrayBufferLike`> & `object` & [`BlobInstance`](#blobinstance)
Blob instance
#### Throws
Error if data exceeds maximum size
#### Example
```typescript theme={null}
import { Blob } from './primitives/Blob/index.js';
// Create empty blob by size
const blob1 = Blob(131072);
// Raw blob
const blob2 = Blob(new Uint8Array(131072));
// Auto-encode data
const blob3 = Blob(new TextEncoder().encode("Hello"));
```
# primitives/Block
Source: https://voltaire.tevm.sh/generated-api/primitives/Block
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Block
# primitives/Block
## Type Aliases
### BlockType
> **BlockType** = `object`
Defined in: [src/primitives/Block/BlockType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L16)
Block type - represents complete Ethereum block
Full block with header, body, and computed metadata.
Used for block validation, storage, and propagation.
#### See
* [https://voltaire.tevm.sh/primitives/block](https://voltaire.tevm.sh/primitives/block) for Block documentation
* [https://ethereum.org/en/developers/docs/blocks/](https://ethereum.org/en/developers/docs/blocks/) for block documentation
#### Since
0.0.0
#### Properties
##### body
> `readonly` **body**: [`BlockBodyType`](BlockBody.mdx#blockbodytype)
Defined in: [src/primitives/Block/BlockType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L20)
Block body (transactions, ommers, withdrawals)
##### hash
> `readonly` **hash**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Defined in: [src/primitives/Block/BlockType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L22)
Block hash (computed from RLP(header))
##### header
> `readonly` **header**: [`BlockHeaderType`](BlockHeader.mdx#blockheadertype)
Defined in: [src/primitives/Block/BlockType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L18)
Block header (metadata + Merkle roots)
##### size
> `readonly` **size**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Block/BlockType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L24)
Block size in bytes (RLP-encoded)
##### totalDifficulty?
> `readonly` `optional` **totalDifficulty**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Block/BlockType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/BlockType.ts#L26)
Total difficulty (cumulative, pre-merge only)
## Variables
### Block
> `const` **Block**: `object`
Defined in: [src/primitives/Block/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/index.ts#L22)
#### Type Declaration
##### from()
> **from**: (`params`) => [`BlockType`](#blocktype)
###### Parameters
###### params
###### body
[`BlockBodyType`](BlockBody.mdx#blockbodytype)
###### hash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### header
[`BlockHeaderType`](BlockHeader.mdx#blockheadertype)
###### size
`string` | `number` | `bigint`
###### totalDifficulty?
`string` | `number` | `bigint`
###### Returns
[`BlockType`](#blocktype)
## Functions
### \_from()
> **\_from**(`params`): [`BlockType`](#blocktype)
Defined in: [src/primitives/Block/from.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/from.js#L26)
Create Block from components
#### Parameters
##### params
Block parameters
###### body
[`BlockBodyType`](BlockBody.mdx#blockbodytype)
Block body
###### hash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
Block hash
###### header
[`BlockHeaderType`](BlockHeader.mdx#blockheadertype)
Block header
###### size
`string` | `number` | `bigint`
Block size in bytes
###### totalDifficulty?
`string` | `number` | `bigint`
Total difficulty (optional, pre-merge)
#### Returns
[`BlockType`](#blocktype)
Block
#### Example
```typescript theme={null}
const block = Block.from({
header: blockHeader,
body: blockBody,
hash: "0x1234...",
size: 1024n,
totalDifficulty: 12345678n // Optional, pre-merge
});
```
***
### from()
> **from**(`params`): [`BlockType`](#blocktype)
Defined in: [src/primitives/Block/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Block/index.ts#L11)
#### Parameters
##### params
###### body
[`BlockBodyType`](BlockBody.mdx#blockbodytype)
###### hash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### header
[`BlockHeaderType`](BlockHeader.mdx#blockheadertype)
###### size
`string` | `number` | `bigint`
###### totalDifficulty?
`string` | `number` | `bigint`
#### Returns
[`BlockType`](#blocktype)
# primitives/BlockBody
Source: https://voltaire.tevm.sh/generated-api/primitives/BlockBody
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BlockBody
# primitives/BlockBody
## Type Aliases
### BlockBodyType
> **BlockBodyType** = `object`
Defined in: [src/primitives/BlockBody/BlockBodyType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/BlockBodyType.ts#L15)
BlockBody type - represents Ethereum block body
Contains the transactions, uncles/ommers, and withdrawals for a block.
The body combined with the header forms a complete block.
#### See
* [https://voltaire.tevm.sh/primitives/block-body](https://voltaire.tevm.sh/primitives/block-body) for BlockBody documentation
* [https://ethereum.org/en/developers/docs/blocks/](https://ethereum.org/en/developers/docs/blocks/) for block documentation
#### Since
0.0.0
#### Properties
##### ommers
> `readonly` **ommers**: readonly [`UncleType`](Uncle.mdx#uncletype)\[]
Defined in: [src/primitives/BlockBody/BlockBodyType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/BlockBodyType.ts#L19)
Uncle/ommer blocks
##### transactions
> `readonly` **transactions**: readonly [`Any`](Transaction/index.mdx#any)\[]
Defined in: [src/primitives/BlockBody/BlockBodyType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/BlockBodyType.ts#L17)
Transactions in block
##### withdrawals?
> `readonly` `optional` **withdrawals**: readonly [`WithdrawalType`](Withdrawal.mdx#withdrawaltype)\[]
Defined in: [src/primitives/BlockBody/BlockBodyType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/BlockBodyType.ts#L21)
Withdrawals (post-Shanghai)
## Variables
### BlockBody
> `const` **BlockBody**: `object`
Defined in: [src/primitives/BlockBody/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/index.ts#L25)
#### Type Declaration
##### from()
> **from**: (`params`) => [`BlockBodyType`](#blockbodytype)
###### Parameters
###### params
###### ommers
readonly [`UncleType`](Uncle.mdx#uncletype)\[]
###### transactions
readonly [`Any`](Transaction/index.mdx#any)\[]
###### withdrawals?
readonly [`WithdrawalType`](Withdrawal.mdx#withdrawaltype)\[]
###### Returns
[`BlockBodyType`](#blockbodytype)
## Functions
### \_from()
> **\_from**(`params`): [`BlockBodyType`](#blockbodytype)
Defined in: [src/primitives/BlockBody/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/from.js#L19)
Create BlockBody from components
#### Parameters
##### params
BlockBody parameters
###### ommers
readonly [`UncleType`](Uncle.mdx#uncletype)\[]
Ommers/uncles
###### transactions
readonly [`Any`](Transaction/index.mdx#any)\[]
Transactions
###### withdrawals?
readonly [`WithdrawalType`](Withdrawal.mdx#withdrawaltype)\[]
Withdrawals (optional, post-Shanghai)
#### Returns
[`BlockBodyType`](#blockbodytype)
BlockBody
#### Example
```typescript theme={null}
const body = BlockBody.from({
transactions: [tx1, tx2],
ommers: [],
withdrawals: [withdrawal1, withdrawal2] // Optional
});
```
***
### from()
> **from**(`params`): [`BlockBodyType`](#blockbodytype)
Defined in: [src/primitives/BlockBody/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockBody/index.ts#L16)
#### Parameters
##### params
###### ommers
readonly [`UncleType`](Uncle.mdx#uncletype)\[]
###### transactions
readonly [`Any`](Transaction/index.mdx#any)\[]
###### withdrawals?
readonly [`WithdrawalType`](Withdrawal.mdx#withdrawaltype)\[]
#### Returns
[`BlockBodyType`](#blockbodytype)
# primitives/BlockFilter
Source: https://voltaire.tevm.sh/generated-api/primitives/BlockFilter
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BlockFilter
# primitives/BlockFilter
## Type Aliases
### BlockFilterType
> **BlockFilterType** = `object` & `object`
Defined in: [src/primitives/BlockFilter/BlockFilterType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockFilter/BlockFilterType.ts#L10)
Block filter created by eth\_newBlockFilter
Notifies of new blocks when polled with eth\_getFilterChanges.
Returns array of block hashes.
#### Type Declaration
##### filterId
> `readonly` **filterId**: [`FilterIdType`](FilterId.mdx#filteridtype)
Filter identifier
##### type
> `readonly` **type**: `"block"`
Filter type discriminator
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BlockFilter"`
## Functions
### from()
> **from**(`filterId`): [`BlockFilterType`](#blockfiltertype)
Defined in: [src/primitives/BlockFilter/from.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockFilter/from.js#L13)
Create BlockFilter from filter ID
#### Parameters
##### filterId
[`FilterIdType`](FilterId.mdx#filteridtype)
Filter identifier from eth\_newBlockFilter
#### Returns
[`BlockFilterType`](#blockfiltertype)
#### Example
```javascript theme={null}
import * as BlockFilter from './primitives/BlockFilter/index.js';
import * as FilterId from './primitives/FilterId/index.js';
const filter = BlockFilter.from(FilterId.from("0x1"));
```
# primitives/BlockHash
Source: https://voltaire.tevm.sh/generated-api/primitives/BlockHash
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BlockHash
# primitives/BlockHash
## Classes
### InvalidBlockHashFormatError
Defined in: [src/primitives/BlockHash/errors.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L18)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBlockHashFormatError**(`message`, `details?`): [`InvalidBlockHashFormatError`](#invalidblockhashformaterror)
Defined in: [src/primitives/BlockHash/errors.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L25)
###### Parameters
###### message
`string`
###### details?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidBlockHashFormatError`](#invalidblockhashformaterror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/BlockHash/errors.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L29)
##### name
> **name**: `string`
Defined in: [src/primitives/BlockHash/errors.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L27)
###### Inherited from
`Error.name`
***
### InvalidBlockHashLengthError
Defined in: [src/primitives/BlockHash/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBlockHashLengthError**(`message`, `details?`): [`InvalidBlockHashLengthError`](#invalidblockhashlengtherror)
Defined in: [src/primitives/BlockHash/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L9)
###### Parameters
###### message
`string`
###### details?
###### context?
`Record`\<`string`, `unknown`>
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidBlockHashLengthError`](#invalidblockhashlengtherror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `context?`: `Record`\<`string`, `unknown`>; `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/BlockHash/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L13)
##### name
> **name**: `string`
Defined in: [src/primitives/BlockHash/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### BlockHashType
> **BlockHashType** = `Uint8Array` & `object`
Defined in: [src/primitives/BlockHash/BlockHashType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/BlockHashType.ts#L6)
Block hash (32-byte identifier)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BlockHash"`
##### length
> `readonly` **length**: `32`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/BlockHash/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/index.ts#L14)
Check if two BlockHashes are equal
#### Parameters
##### a
[`BlockHashType`](#blockhashtype)
##### b
[`BlockHashType`](#blockhashtype)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`BlockHashType`](#blockhashtype) = `_from`
Defined in: [src/primitives/BlockHash/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/index.ts#L10)
Create BlockHash from various input types
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`BlockHashType`](#blockhashtype)
#### Throws
***
### fromBytes()
> `const` **fromBytes**: (`bytes`) => [`BlockHashType`](#blockhashtype) = `_fromBytes`
Defined in: [src/primitives/BlockHash/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/index.ts#L11)
Create BlockHash from bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`BlockHashType`](#blockhashtype)
#### Throws
***
### fromHex()
> `const` **fromHex**: (`hex`) => [`BlockHashType`](#blockhashtype) = `_fromHex`
Defined in: [src/primitives/BlockHash/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/index.ts#L12)
Create BlockHash from hex string
#### Parameters
##### hex
`string`
#### Returns
[`BlockHashType`](#blockhashtype)
#### Throws
***
### toHex()
> `const` **toHex**: (`hash`) => `string` = `_toHex`
Defined in: [src/primitives/BlockHash/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHash/index.ts#L13)
Convert BlockHash to hex string
#### Parameters
##### hash
[`BlockHashType`](#blockhashtype)
#### Returns
`string`
# primitives/BlockHeader
Source: https://voltaire.tevm.sh/generated-api/primitives/BlockHeader
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BlockHeader
# primitives/BlockHeader
## Type Aliases
### BlockHeaderType
> **BlockHeaderType** = `object`
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L17)
BlockHeader type - represents Ethereum block header
Contains all metadata and Merkle roots for a block.
Used for block validation and light client proofs.
#### See
* [https://voltaire.tevm.sh/primitives/block-header](https://voltaire.tevm.sh/primitives/block-header) for BlockHeader documentation
* [https://ethereum.org/en/developers/docs/blocks/](https://ethereum.org/en/developers/docs/blocks/) for block documentation
#### Since
0.0.0
#### Properties
##### baseFeePerGas?
> `readonly` `optional` **baseFeePerGas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L49)
EIP-1559: Base fee per gas (post-London)
##### beneficiary
> `readonly` **beneficiary**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L23)
Address receiving block reward (miner/validator)
##### blobGasUsed?
> `readonly` `optional` **blobGasUsed**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L53)
EIP-4844: Total blob gas used (post-Cancun)
##### difficulty
> `readonly` **difficulty**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L33)
Proof-of-work difficulty (0 post-merge)
##### excessBlobGas?
> `readonly` `optional` **excessBlobGas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L55)
EIP-4844: Excess blob gas (post-Cancun)
##### extraData
> `readonly` **extraData**: `Uint8Array`
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L43)
Arbitrary data (max 32 bytes)
##### gasLimit
> `readonly` **gasLimit**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L37)
Maximum gas allowed in block
##### gasUsed
> `readonly` **gasUsed**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L39)
Total gas used by transactions
##### logsBloom
> `readonly` **logsBloom**: `Uint8Array`
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L31)
Bloom filter for logs (256 bytes)
##### mixHash
> `readonly` **mixHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L45)
PoW mix hash (0 post-merge)
##### nonce
> `readonly` **nonce**: `Uint8Array`
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L47)
PoW nonce (8 bytes, 0 post-merge)
##### number
> `readonly` **number**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L35)
Block number
##### ommersHash
> `readonly` **ommersHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L21)
Keccak256 hash of ommers/uncles list RLP
##### parentBeaconBlockRoot?
> `readonly` `optional` **parentBeaconBlockRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L57)
EIP-4788: Parent beacon block root (post-Cancun)
##### parentHash
> `readonly` **parentHash**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L19)
Hash of parent block
##### receiptsRoot
> `readonly` **receiptsRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L29)
Receipts trie root
##### stateRoot
> `readonly` **stateRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L25)
State trie root after block execution
##### timestamp
> `readonly` **timestamp**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L41)
Unix timestamp (seconds)
##### transactionsRoot
> `readonly` **transactionsRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L27)
Transactions trie root
##### withdrawalsRoot?
> `readonly` `optional` **withdrawalsRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BlockHeader/BlockHeaderType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/BlockHeaderType.ts#L51)
Post-merge: Withdrawals trie root (post-Shanghai)
## Variables
### BlockHeader
> `const` **BlockHeader**: `object`
Defined in: [src/primitives/BlockHeader/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/index.ts#L37)
#### Type Declaration
##### from()
> **from**: (`params`) => [`BlockHeaderType`](#blockheadertype)
###### Parameters
###### params
###### baseFeePerGas?
`string` | `number` | `bigint`
###### beneficiary
`string` | [`AddressType`](Address.mdx#addresstype)
###### blobGasUsed?
`string` | `number` | `bigint`
###### difficulty
`string` | `number` | `bigint`
###### excessBlobGas?
`string` | `number` | `bigint`
###### extraData
`Uint8Array`
###### gasLimit
`string` | `number` | `bigint`
###### gasUsed
`string` | `number` | `bigint`
###### logsBloom
`Uint8Array`
###### mixHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### nonce
`Uint8Array`
###### number
`number` | `bigint`
###### ommersHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentBeaconBlockRoot?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentHash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### receiptsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### stateRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### timestamp
`string` | `number` | `bigint`
###### transactionsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### withdrawalsRoot?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Returns
[`BlockHeaderType`](#blockheadertype)
## Functions
### \_from()
> **\_from**(`params`): [`BlockHeaderType`](#blockheadertype)
Defined in: [src/primitives/BlockHeader/from.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/from.js#L63)
Create BlockHeader from components
#### Parameters
##### params
`BlockHeaderParams`
BlockHeader parameters
#### Returns
[`BlockHeaderType`](#blockheadertype)
BlockHeader
#### Example
```typescript theme={null}
const header = BlockHeader.from({
parentHash: "0x1234...",
ommersHash: "0x5678...",
beneficiary: "0xabcd...",
stateRoot: "0xef01...",
transactionsRoot: "0x2345...",
receiptsRoot: "0x6789...",
logsBloom: new Uint8Array(256),
difficulty: 0n,
number: 12345n,
gasLimit: 30000000n,
gasUsed: 21000n,
timestamp: 1234567890n,
extraData: new Uint8Array(0),
mixHash: "0xabcd...",
nonce: new Uint8Array(8),
baseFeePerGas: 1000000000n, // EIP-1559
withdrawalsRoot: "0xdef0...", // Post-Shanghai
blobGasUsed: 262144n, // EIP-4844
excessBlobGas: 0n, // EIP-4844
parentBeaconBlockRoot: "0x0123..." // EIP-4788
});
```
***
### from()
> **from**(`params`): [`BlockHeaderType`](#blockheadertype)
Defined in: [src/primitives/BlockHeader/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockHeader/index.ts#L11)
#### Parameters
##### params
###### baseFeePerGas?
`string` | `number` | `bigint`
###### beneficiary
`string` | [`AddressType`](Address.mdx#addresstype)
###### blobGasUsed?
`string` | `number` | `bigint`
###### difficulty
`string` | `number` | `bigint`
###### excessBlobGas?
`string` | `number` | `bigint`
###### extraData
`Uint8Array`
###### gasLimit
`string` | `number` | `bigint`
###### gasUsed
`string` | `number` | `bigint`
###### logsBloom
`Uint8Array`
###### mixHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### nonce
`Uint8Array`
###### number
`number` | `bigint`
###### ommersHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentBeaconBlockRoot?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentHash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### receiptsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### stateRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### timestamp
`string` | `number` | `bigint`
###### transactionsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### withdrawalsRoot?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
[`BlockHeaderType`](#blockheadertype)
# primitives/BlockNumber
Source: https://voltaire.tevm.sh/generated-api/primitives/BlockNumber
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BlockNumber
# primitives/BlockNumber
## Classes
### InvalidBlockNumberError
Defined in: [src/primitives/BlockNumber/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBlockNumberError**(`message`, `details?`): [`InvalidBlockNumberError`](#invalidblocknumbererror)
Defined in: [src/primitives/BlockNumber/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/errors.js#L8)
###### Parameters
###### message
`string`
###### details?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidBlockNumberError`](#invalidblocknumbererror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/BlockNumber/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/BlockNumber/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/errors.js#L10)
###### Inherited from
`Error.name`
## Type Aliases
### BlockNumberType
> **BlockNumberType** = `bigint` & `object`
Defined in: [src/primitives/BlockNumber/BlockNumberType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/BlockNumberType.ts#L6)
Block number
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BlockNumber"`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/BlockNumber/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/index.ts#L12)
Check if two BlockNumbers are equal
#### Parameters
##### a
[`BlockNumberType`](#blocknumbertype)
##### b
[`BlockNumberType`](#blocknumbertype)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`BlockNumberType`](#blocknumbertype) = `_from`
Defined in: [src/primitives/BlockNumber/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/index.ts#L9)
Create BlockNumber from number or bigint
#### Parameters
##### value
`number` | `bigint`
#### Returns
[`BlockNumberType`](#blocknumbertype)
#### Throws
***
### toBigInt()
> `const` **toBigInt**: (`blockNumber`) => `bigint` = `_toBigInt`
Defined in: [src/primitives/BlockNumber/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/index.ts#L10)
Convert BlockNumber to bigint
#### Parameters
##### blockNumber
[`BlockNumberType`](#blocknumbertype)
#### Returns
`bigint`
***
### toNumber()
> `const` **toNumber**: (`blockNumber`) => `number` = `_toNumber`
Defined in: [src/primitives/BlockNumber/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BlockNumber/index.ts#L11)
Convert BlockNumber to number (unsafe for large values)
#### Parameters
##### blockNumber
[`BlockNumberType`](#blocknumbertype)
#### Returns
`number`
# primitives/BloomFilter
Source: https://voltaire.tevm.sh/generated-api/primitives/BloomFilter
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BloomFilter
# primitives/BloomFilter
## Classes
### InvalidBloomFilterLengthError
Defined in: [src/primitives/BloomFilter/errors.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L59)
Error thrown when BloomFilter data length is invalid
#### Example
```typescript theme={null}
throw new InvalidBloomFilterLengthError(
'Expected 512 hex chars, got 256',
{
value: 256,
expected: '512 hex chars',
code: 'BLOOM_FILTER_INVALID_LENGTH',
docsPath: '/primitives/bloom-filter/from-hex#error-handling'
}
)
```
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidBloomFilterLengthError**(`message`, `options?`): [`InvalidBloomFilterLengthError`](#invalidbloomfilterlengtherror)
Defined in: [src/primitives/BloomFilter/errors.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L70)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidBloomFilterLengthError`](#invalidbloomfilterlengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/BloomFilter/errors.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L79)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidBloomFilterParameterError
Defined in: [src/primitives/BloomFilter/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L19)
Error thrown when BloomFilter parameters are invalid
#### Example
```typescript theme={null}
throw new InvalidBloomFilterParameterError(
'Bloom filter parameters must be positive',
{
value: { m, k },
expected: 'm > 0 and k > 0',
code: 'BLOOM_FILTER_INVALID_PARAMETER',
docsPath: '/primitives/bloom-filter/create#error-handling'
}
)
```
#### Extends
* [`InvalidRangeError`](../index/index.mdx#invalidrangeerror)
#### Constructors
##### Constructor
> **new InvalidBloomFilterParameterError**(`message`, `options?`): [`InvalidBloomFilterParameterError`](#invalidbloomfilterparametererror)
Defined in: [src/primitives/BloomFilter/errors.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L30)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidBloomFilterParameterError`](#invalidbloomfilterparametererror)
###### Overrides
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`constructor`](../index/index.mdx#constructor-11)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`cause`](../index/index.mdx#cause-11)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`code`](../index/index.mdx#code-11)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`context`](../index/index.mdx#context-11)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`docsPath`](../index/index.mdx#docspath-11)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`expected`](../index/index.mdx#expected-5)
##### name
> **name**: `string`
Defined in: [src/primitives/BloomFilter/errors.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/errors.js#L39)
###### Inherited from
`InvalidRangeError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`value`](../index/index.mdx#value-5)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`getErrorChain`](../index/index.mdx#geterrorchain-22)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidRangeError`](../index/index.mdx#invalidrangeerror).[`toJSON`](../index/index.mdx#tojson-22)
## Type Aliases
### BloomFilterType
> **BloomFilterType** = `Uint8Array` & `object`
Defined in: [src/primitives/BloomFilter/BloomFilterType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/BloomFilterType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BloomFilter"`
##### k
> `readonly` **k**: `number`
##### m
> `readonly` **m**: `number`
##### toHex()
> **toHex**(`this`): `string`
###### Parameters
###### this
[`BloomFilterType`](#bloomfiltertype)
###### Returns
`string`
## Variables
### BITS
> `const` **BITS**: `2048` = `2048`
Defined in: [src/primitives/BloomFilter/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/constants.js#L11)
Number of bits in the bloom filter (2048)
***
### DEFAULT\_HASH\_COUNT
> `const` **DEFAULT\_HASH\_COUNT**: `3` = `3`
Defined in: [src/primitives/BloomFilter/constants.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/constants.js#L17)
Default number of hash functions for Ethereum bloom filters
***
### SIZE
> `const` **SIZE**: `256` = `256`
Defined in: [src/primitives/BloomFilter/constants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/constants.js#L5)
Standard Ethereum bloom filter size in bytes (256 bytes = 2048 bits)
## Functions
### add()
> **add**(`filter`, `item`): `void`
Defined in: [src/primitives/BloomFilter/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L21)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
##### item
`Uint8Array`
#### Returns
`void`
***
### BloomFilter()
> **BloomFilter**(`m`, `k`): [`BloomFilterType`](#bloomfiltertype)
Defined in: [src/primitives/BloomFilter/index.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L74)
Factory function for creating BloomFilter instances
#### Parameters
##### m
`number`
##### k
`number`
#### Returns
[`BloomFilterType`](#bloomfiltertype)
***
### combine()
> **combine**(...`filters`): [`BloomFilterType`](#bloomfiltertype)
Defined in: [src/primitives/BloomFilter/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L25)
#### Parameters
##### filters
...[`BloomFilterType`](#bloomfiltertype)\[]
#### Returns
[`BloomFilterType`](#bloomfiltertype)
***
### contains()
> **contains**(`filter`, `item`): `boolean`
Defined in: [src/primitives/BloomFilter/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L29)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
##### item
`Uint8Array`
#### Returns
`boolean`
***
### create()
> **create**(`m`, `k`): [`BloomFilterType`](#bloomfiltertype)
Defined in: [src/primitives/BloomFilter/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L33)
#### Parameters
##### m
`number`
##### k
`number`
#### Returns
[`BloomFilterType`](#bloomfiltertype)
***
### density()
> **density**(`filter`): `number`
Defined in: [src/primitives/BloomFilter/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L37)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
#### Returns
`number`
***
### expectedFalsePositiveRate()
> **expectedFalsePositiveRate**(`filter`, `itemCount`): `number`
Defined in: [src/primitives/BloomFilter/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L41)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
##### itemCount
`number`
#### Returns
`number`
***
### fromHex()
> **fromHex**(`hex`, `m`, `k`): [`BloomFilterType`](#bloomfiltertype)
Defined in: [src/primitives/BloomFilter/index.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L48)
#### Parameters
##### hex
`string`
##### m
`number`
##### k
`number`
#### Returns
[`BloomFilterType`](#bloomfiltertype)
***
### hash()
> **hash**(`item`, `seed`, `m`): `number`
Defined in: [src/primitives/BloomFilter/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L52)
#### Parameters
##### item
`Uint8Array`
##### seed
`number`
##### m
`number`
#### Returns
`number`
***
### isEmpty()
> **isEmpty**(`filter`): `boolean`
Defined in: [src/primitives/BloomFilter/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L56)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
#### Returns
`boolean`
***
### merge()
> **merge**(`filter1`, `filter2`): [`BloomFilterType`](#bloomfiltertype)
Defined in: [src/primitives/BloomFilter/index.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L60)
#### Parameters
##### filter1
[`BloomFilterType`](#bloomfiltertype)
##### filter2
[`BloomFilterType`](#bloomfiltertype)
#### Returns
[`BloomFilterType`](#bloomfiltertype)
***
### toHex()
> **toHex**(`filter`): `string`
Defined in: [src/primitives/BloomFilter/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BloomFilter/index.ts#L67)
#### Parameters
##### filter
[`BloomFilterType`](#bloomfiltertype)
#### Returns
`string`
# primitives/BuilderBid
Source: https://voltaire.tevm.sh/generated-api/primitives/BuilderBid
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BuilderBid
# primitives/BuilderBid
## Classes
### InvalidBuilderBidError
Defined in: [src/primitives/BuilderBid/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/errors.js#L6)
Error thrown when BuilderBid operations fail
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBuilderBidError**(`message`, `details`): [`InvalidBuilderBidError`](#invalidbuilderbiderror)
Defined in: [src/primitives/BuilderBid/errors.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/errors.js#L7)
###### Parameters
###### message
`any`
###### details
`any`
###### Returns
[`InvalidBuilderBidError`](#invalidbuilderbiderror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/BuilderBid/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/errors.js#L10)
##### name
> **name**: `string`
Defined in: [src/primitives/BuilderBid/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/errors.js#L9)
###### Inherited from
`Error.name`
## Type Aliases
### BuilderBidHex
> **BuilderBidHex** = `object`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L102)
BuilderBid with hex strings (common in RPC responses)
#### Properties
##### block\_hash
> `readonly` **block\_hash**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L105)
##### builder\_pubkey
> `readonly` **builder\_pubkey**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L106)
##### gas\_limit
> `readonly` **gas\_limit**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L109)
##### gas\_used
> `readonly` **gas\_used**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L110)
##### parent\_hash
> `readonly` **parent\_hash**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L104)
##### proposer\_fee\_recipient
> `readonly` **proposer\_fee\_recipient**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L108)
##### proposer\_pubkey
> `readonly` **proposer\_pubkey**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L107)
##### signature
> `readonly` **signature**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L112)
##### slot
> `readonly` **slot**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L103)
##### value
> `readonly` **value**: `string`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L111)
***
### BuilderBidLike
> **BuilderBidLike** = [`BuilderBidType`](#builderbidtype) | \{ `blockHash`: [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `string` | `Uint8Array`; `builderPubkey`: `Uint8Array` | `string`; `gasLimit`: [`Type`](Uint.mdx#type) | `bigint` | `number` | `string`; `gasUsed`: [`Type`](Uint.mdx#type) | `bigint` | `number` | `string`; `parentHash`: [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `string` | `Uint8Array`; `proposerFeeRecipient`: [`AddressType`](Address.mdx#addresstype) | `string`; `proposerPubkey`: `Uint8Array` | `string`; `signature`: `Uint8Array` | `string`; `slot`: [`SlotType`](Slot.mdx#slottype) | `bigint` | `number` | `string`; `value`: [`Type`](Uint.mdx#type) | `bigint` | `number` | `string`; }
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L84)
Inputs that can be converted to BuilderBid
***
### BuilderBidType
> **BuilderBidType** = `object`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L19)
BuilderBid type
Represents a block builder bid in Proposer-Builder Separation (PBS).
Block builders compete to provide the most valuable block to validators
through MEV-Boost relays. The bid includes the proposed block details,
value offered to the proposer, and cryptographic signatures.
#### See
* [https://voltaire.tevm.sh/primitives/builder-bid](https://voltaire.tevm.sh/primitives/builder-bid) for BuilderBid documentation
* [https://boost.flashbots.net/](https://boost.flashbots.net/) for MEV-Boost
* [https://ethereum.org/en/roadmap/pbs/](https://ethereum.org/en/roadmap/pbs/) for PBS overview
#### Since
0.0.0
#### Properties
##### blockHash
> `readonly` **blockHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L36)
Proposed block hash
Hash of the block being bid on
##### builderPubkey
> `readonly` **builderPubkey**: `Uint8Array`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L42)
Builder's BLS public key (48 bytes)
Identity of the block builder
##### gasLimit
> `readonly` **gasLimit**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L60)
Block gas limit
Maximum gas allowed in the proposed block
##### gasUsed
> `readonly` **gasUsed**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L66)
Gas used in block
Actual gas consumed by transactions
##### parentHash
> `readonly` **parentHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L30)
Parent block hash
The block being built on top of
##### proposerFeeRecipient
> `readonly` **proposerFeeRecipient**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L54)
Fee recipient address
Where block rewards and tips are sent
##### proposerPubkey
> `readonly` **proposerPubkey**: `Uint8Array`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L48)
Proposer's BLS public key (48 bytes)
Identity of the validator proposing this slot
##### signature
> `readonly` **signature**: `Uint8Array`
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L78)
Builder's BLS signature (96 bytes)
Cryptographic proof of bid authenticity
##### slot
> `readonly` **slot**: [`SlotType`](Slot.mdx#slottype)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L24)
Beacon chain slot number for this bid
Each slot is 12 seconds
##### value
> `readonly` **value**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/BuilderBid/BuilderBidType.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/BuilderBidType.ts#L72)
Bid value to proposer (in wei)
Amount builder pays validator for block inclusion
## Functions
### from()
> **from**(`value`): [`BuilderBidType`](#builderbidtype)
Defined in: [src/primitives/BuilderBid/from.js:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/from.js#L73)
Creates a BuilderBid from various input types
#### Parameters
##### value
[`BuilderBidLike`](#builderbidlike)
BuilderBid input
#### Returns
[`BuilderBidType`](#builderbidtype)
BuilderBid instance
#### Throws
If bid format is invalid
#### Example
```typescript theme={null}
import * as BuilderBid from './BuilderBid/index.js';
const bid = BuilderBid.from({
slot: 123456n,
parentHash: "0x...",
blockHash: "0x...",
builderPubkey: builderKey,
proposerPubkey: proposerKey,
proposerFeeRecipient: feeRecipient,
gasLimit: 30000000n,
gasUsed: 25000000n,
value: 1000000000000000000n,
signature: signature,
});
```
***
### getValue()
> **getValue**(`bid`): `bigint`
Defined in: [src/primitives/BuilderBid/getValue.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/getValue.js#L19)
Gets the bid value in wei
#### Parameters
##### bid
[`BuilderBidType`](#builderbidtype)
BuilderBid instance
#### Returns
`bigint`
Bid value in wei
#### Example
```typescript theme={null}
import * as BuilderBid from './BuilderBid/index.js';
const value = BuilderBid.getValue(bid);
console.log(`Bid: ${value} wei`);
```
***
### toHex()
> **toHex**(`bid`): [`BuilderBidHex`](#builderbidhex)
Defined in: [src/primitives/BuilderBid/toHex.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/toHex.js#L32)
Converts BuilderBid to hex representation (RPC format)
#### Parameters
##### bid
[`BuilderBidType`](#builderbidtype)
BuilderBid instance
#### Returns
[`BuilderBidHex`](#builderbidhex)
BuilderBid with hex strings
#### Example
```typescript theme={null}
import * as BuilderBid from './BuilderBid/index.js';
const hexBid = BuilderBid.toHex(bid);
```
***
### verify()
> **verify**(`bid`, `crypto`): `boolean`
Defined in: [src/primitives/BuilderBid/verify.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BuilderBid/verify.js#L22)
Verifies the builder's BLS signature on the bid
#### Parameters
##### bid
[`BuilderBidType`](#builderbidtype)
BuilderBid instance
##### crypto
Crypto dependencies
###### blsVerify
(`pubkey`, `message`, `signature`) => `boolean`
BLS verification function
#### Returns
`boolean`
True if signature is valid
#### Example
```typescript theme={null}
import * as BuilderBid from './BuilderBid/index.js';
import { blsVerify } from './crypto/bls.js';
const valid = BuilderBid.verify(bid, { blsVerify });
console.log(`Signature valid: ${valid}`);
```
# primitives/Bundle
Source: https://voltaire.tevm.sh/generated-api/primitives/Bundle
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Bundle
# primitives/Bundle
## Classes
### InvalidBundleError
Defined in: [src/primitives/Bundle/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/errors.js#L6)
Error thrown when bundle operations fail
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBundleError**(`message`, `details`): [`InvalidBundleError`](#invalidbundleerror)
Defined in: [src/primitives/Bundle/errors.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/errors.js#L7)
###### Parameters
###### message
`any`
###### details
`any`
###### Returns
[`InvalidBundleError`](#invalidbundleerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/Bundle/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/errors.js#L10)
##### name
> **name**: `string`
Defined in: [src/primitives/Bundle/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/errors.js#L9)
###### Inherited from
`Error.name`
## Type Aliases
### BundleLike
> **BundleLike** = [`BundleType`](#bundletype) | \{ `blockNumber?`: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype) | `bigint` | `number` | `string`; `maxTimestamp?`: [`Type`](Uint.mdx#type) | `bigint` | `number` | `string`; `minTimestamp?`: [`Type`](Uint.mdx#type) | `bigint` | `number` | `string`; `revertingTxHashes?`: ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | `string`)\[]; `transactions`: (`Uint8Array` | `string`)\[]; }
Defined in: [src/primitives/Bundle/BundleType.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L53)
Inputs that can be converted to Bundle
***
### BundleType
> **BundleType** = `object`
Defined in: [src/primitives/Bundle/BundleType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L17)
Bundle type
Represents a transaction bundle for MEV (Maximal Extractable Value) strategies.
Bundles are atomic collections of transactions submitted to block builders via
MEV relays like Flashbots. All transactions in a bundle execute sequentially
in the same block or the bundle is discarded.
#### See
* [https://voltaire.tevm.sh/primitives/bundle](https://voltaire.tevm.sh/primitives/bundle) for Bundle documentation
* [https://docs.flashbots.net/flashbots-auction/overview](https://docs.flashbots.net/flashbots-auction/overview) for Flashbots Auction
#### Since
0.0.0
#### Properties
##### blockNumber?
> `readonly` `optional` **blockNumber**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/Bundle/BundleType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L28)
Target block number for bundle inclusion (optional)
If specified, bundle is only valid for this block
##### maxTimestamp?
> `readonly` `optional` **maxTimestamp**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Bundle/BundleType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L40)
Maximum block timestamp for bundle inclusion (optional)
Bundle will not be included after this timestamp
##### minTimestamp?
> `readonly` `optional` **minTimestamp**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Bundle/BundleType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L34)
Minimum block timestamp for bundle inclusion (optional)
Bundle will not be included before this timestamp
##### revertingTxHashes?
> `readonly` `optional` **revertingTxHashes**: readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/Bundle/BundleType.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L47)
Transaction hashes allowed to revert (optional)
If any other transaction reverts, entire bundle is discarded
If a hash in this array reverts, bundle continues execution
##### transactions
> `readonly` **transactions**: readonly `Uint8Array`\[]
Defined in: [src/primitives/Bundle/BundleType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/BundleType.ts#L22)
Ordered array of signed transaction bytes
All transactions execute sequentially in this order
## Functions
### addTransaction()
> **addTransaction**(`bundle`, `transaction`): [`BundleType`](#bundletype)
Defined in: [src/primitives/Bundle/addTransaction.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/addTransaction.js#L19)
Adds a transaction to the bundle
#### Parameters
##### bundle
[`BundleType`](#bundletype)
Bundle instance
##### transaction
Signed transaction to add
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`BundleType`](#bundletype)
New bundle with added transaction
#### Example
```typescript theme={null}
import * as Bundle from './Bundle/index.js';
const newBundle = Bundle.addTransaction(bundle, signedTx);
```
***
### from()
> **from**(`value`): [`BundleType`](#bundletype)
Defined in: [src/primitives/Bundle/from.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/from.js#L25)
Creates a Bundle from various input types
#### Parameters
##### value
[`BundleLike`](#bundlelike)
Bundle input
#### Returns
[`BundleType`](#bundletype)
Bundle instance
#### Throws
If bundle format is invalid
#### Example
```typescript theme={null}
import * as Bundle from './Bundle/index.js';
const bundle = Bundle.from({
transactions: [tx1, tx2],
blockNumber: 123456n,
});
```
***
### size()
> **size**(`bundle`): `number`
Defined in: [src/primitives/Bundle/size.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/size.js#L19)
Returns the number of transactions in the bundle
#### Parameters
##### bundle
[`BundleType`](#bundletype)
Bundle instance
#### Returns
`number`
Number of transactions
#### Example
```typescript theme={null}
import * as Bundle from './Bundle/index.js';
const count = Bundle.size(bundle);
console.log(`Bundle contains ${count} transactions`);
```
***
### toFlashbotsParams()
> **toFlashbotsParams**(`bundle`): `object`
Defined in: [src/primitives/Bundle/toFlashbotsParams.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/toFlashbotsParams.js#L19)
Converts bundle to Flashbots RPC parameters
#### Parameters
##### bundle
[`BundleType`](#bundletype)
Bundle instance
#### Returns
`object`
Flashbots eth\_sendBundle parameters
#### Example
```typescript theme={null}
import * as Bundle from './Bundle/index.js';
const params = Bundle.toFlashbotsParams(bundle);
await flashbots.request({ method: "eth_sendBundle", params: [params] });
```
***
### toHash()
> **toHash**(`bundle`, `crypto`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Bundle/toHash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundle/toHash.js#L22)
Computes the bundle hash (keccak256 of bundle contents)
#### Parameters
##### bundle
[`BundleType`](#bundletype)
Bundle instance
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 function
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Bundle hash
#### Example
```typescript theme={null}
import * as Bundle from './Bundle/index.js';
import { keccak256 } from './crypto/keccak256.js';
const hash = Bundle.toHash(bundle, { keccak256 });
```
# primitives/BundleHash
Source: https://voltaire.tevm.sh/generated-api/primitives/BundleHash
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/BundleHash
# primitives/BundleHash
## Classes
### InvalidBundleHashError
Defined in: [src/primitives/BundleHash/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/errors.js#L4)
Error thrown when BundleHash operations fail
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidBundleHashError**(`message`, `details?`): [`InvalidBundleHashError`](#invalidbundlehasherror)
Defined in: [src/primitives/BundleHash/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/errors.js#L9)
###### Parameters
###### message
`string`
Error message
###### details?
`Record`\<`string`, `unknown`>
Error details
###### Returns
[`InvalidBundleHashError`](#invalidbundlehasherror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `Record`\<`string`, `unknown`> | `undefined`
Defined in: [src/primitives/BundleHash/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/BundleHash/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### BundleHashLike
> **BundleHashLike** = [`BundleHashType`](#bundlehashtype) | `string` | `Uint8Array`
Defined in: [src/primitives/BundleHash/BundleHashType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/BundleHashType.ts#L22)
Inputs that can be converted to BundleHash
***
### BundleHashType
> **BundleHashType** = `Uint8Array` & `object`
Defined in: [src/primitives/BundleHash/BundleHashType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/BundleHashType.ts#L14)
BundleHash type
Unique identifier for a transaction bundle. Computed as keccak256 of the
bundle contents (concatenated transaction hashes). Used to track bundle
status through MEV relays and block builders.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BundleHash"`
##### length
> `readonly` **length**: `32`
#### See
* [https://voltaire.tevm.sh/primitives/bundle-hash](https://voltaire.tevm.sh/primitives/bundle-hash) for BundleHash documentation
* [https://docs.flashbots.net/flashbots-auction/overview](https://docs.flashbots.net/flashbots-auction/overview) for Flashbots Auction
#### Since
0.0.0
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/BundleHash/BundleHashType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/BundleHashType.ts#L24)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/BundleHash/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/equals.js#L17)
Checks if two BundleHashes are equal
#### Parameters
##### a
[`BundleHashType`](#bundlehashtype)
First hash
##### b
[`BundleHashType`](#bundlehashtype)
Second hash
#### Returns
`boolean`
True if hashes are equal
#### Example
```typescript theme={null}
import * as BundleHash from './BundleHash/index.js';
const equal = BundleHash.equals(hash1, hash2);
```
***
### from()
> **from**(`value`): [`BundleHashType`](#bundlehashtype)
Defined in: [src/primitives/BundleHash/from.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/from.js#L21)
Creates a BundleHash from various input types
#### Parameters
##### value
[`BundleHashLike`](#bundlehashlike)
BundleHash input (hex string or bytes)
#### Returns
[`BundleHashType`](#bundlehashtype)
BundleHash instance
#### Throws
If input format is invalid
#### Example
```typescript theme={null}
import * as BundleHash from './BundleHash/index.js';
const hash = BundleHash.from("0x1234...");
```
***
### fromBundle()
> **fromBundle**(`bundle`, `crypto`): [`BundleHashType`](#bundlehashtype)
Defined in: [src/primitives/BundleHash/fromBundle.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/fromBundle.js#L20)
Computes BundleHash from a Bundle
#### Parameters
##### bundle
[`BundleType`](Bundle.mdx#bundletype)
Bundle instance
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 function
#### Returns
[`BundleHashType`](#bundlehashtype)
Bundle hash
#### Example
```typescript theme={null}
import * as BundleHash from './BundleHash/index.js';
import { keccak256 } from './crypto/keccak256.js';
const hash = BundleHash.fromBundle(bundle, { keccak256 });
```
***
### fromHex()
> **fromHex**(`value`): [`BundleHashType`](#bundlehashtype)
Defined in: [src/primitives/BundleHash/fromHex.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/fromHex.js#L20)
Creates BundleHash from hex string
#### Parameters
##### value
`string`
Hex string (with or without 0x prefix)
#### Returns
[`BundleHashType`](#bundlehashtype)
BundleHash instance
#### Throws
If hex format is invalid
#### Example
```typescript theme={null}
import * as BundleHash from './BundleHash/index.js';
const hash = BundleHash.fromHex("0x1234...");
```
***
### toHex()
> **toHex**(`hash`): `string`
Defined in: [src/primitives/BundleHash/toHex.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/BundleHash/toHex.js#L17)
Converts BundleHash to hex string
#### Parameters
##### hash
[`BundleHashType`](#bundlehashtype)
BundleHash instance
#### Returns
`string`
Hex string with 0x prefix
#### Example
```typescript theme={null}
import * as BundleHash from './BundleHash/index.js';
const hex = BundleHash.toHex(hash);
console.log(hex); // "0x1234..."
```
# primitives/Bundler
Source: https://voltaire.tevm.sh/generated-api/primitives/Bundler
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Bundler
# primitives/Bundler
## Type Aliases
### BundlerType
> **BundlerType** = `Uint8Array` & `object`
Defined in: [src/primitives/Bundler/BundlerType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/BundlerType.ts#L13)
Bundler address type - ERC-4337 bundler node
Bundlers aggregate user operations and submit them to the EntryPoint contract.
They monitor the mempool, simulate operations, and bundle them into transactions.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bundler"`
#### See
* [https://eips.ethereum.org/EIPS/eip-4337](https://eips.ethereum.org/EIPS/eip-4337)
* [https://voltaire.tevm.sh/primitives/bundler](https://voltaire.tevm.sh/primitives/bundler) for Bundler documentation
#### Since
0.0.0
## Variables
### Bundler
> `const` **Bundler**: `object`
Defined in: [src/primitives/Bundler/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/index.ts#L31)
#### Type Declaration
##### equals()
> **equals**: (`bundler1`, `bundler2`) => `boolean`
###### Parameters
###### bundler1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### bundler2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`BundlerType`](#bundlertype)
Create Bundler from address input
###### Parameters
###### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
[`BundlerType`](#bundlertype)
Bundler address
###### Throws
If address format is invalid
###### Example
```typescript theme={null}
const bundler = Bundler.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
##### toHex()
> **toHex**: (`bundler`) => `string`
###### Parameters
###### bundler
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`string`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bundler/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/equals.js#L15)
Check if two Bundler addresses are equal
#### Parameters
##### a
[`BundlerType`](#bundlertype)
First Bundler
##### b
[`BundlerType`](#bundlertype)
Second Bundler
#### Returns
`boolean`
True if addresses are equal
#### Example
```typescript theme={null}
const isEqual = Bundler.equals(bundler1, bundler2);
```
***
### \_toHex()
> **\_toHex**(`bundler`): `string`
Defined in: [src/primitives/Bundler/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/toHex.js#L15)
Convert Bundler to hex string
#### Parameters
##### bundler
[`BundlerType`](#bundlertype)
Bundler address
#### Returns
`string`
Hex string (0x-prefixed)
#### Example
```typescript theme={null}
const hex = Bundler.toHex(bundler);
console.log(hex); // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
***
### equals()
> **equals**(`bundler1`, `bundler2`): `boolean`
Defined in: [src/primitives/Bundler/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/index.ts#L20)
#### Parameters
##### bundler1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### bundler2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`BundlerType`](#bundlertype)
Defined in: [src/primitives/Bundler/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/from.js#L15)
Create Bundler from address input
#### Parameters
##### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
[`BundlerType`](#bundlertype)
Bundler address
#### Throws
If address format is invalid
#### Example
```typescript theme={null}
const bundler = Bundler.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
***
### toHex()
> **toHex**(`bundler`): `string`
Defined in: [src/primitives/Bundler/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bundler/index.ts#L14)
#### Parameters
##### bundler
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`string`
# primitives/Bytecode
Source: https://voltaire.tevm.sh/generated-api/primitives/Bytecode
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Bytecode
# primitives/Bytecode
## Interfaces
### ABIEvent
Defined in: [src/primitives/Bytecode/BytecodeType.ts:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L97)
ABI event extracted from bytecode
#### Properties
##### hash
> **hash**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L99)
##### type
> **type**: `"event"`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L98)
***
### ABIFunction
Defined in: [src/primitives/Bytecode/BytecodeType.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L85)
ABI function extracted from bytecode
#### Properties
##### inputs?
> `optional` **inputs**: \[\{ `name`: `""`; `type`: `"bytes"`; }]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L90)
##### outputs?
> `optional` **outputs**: \[\{ `name`: `""`; `type`: `"bytes"`; }]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L91)
##### payable
> **payable**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L89)
##### selector
> **selector**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L87)
##### stateMutability
> **stateMutability**: `"pure"` | `"view"` | `"nonpayable"` | `"payable"`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L88)
##### type
> **type**: `"function"`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L86)
***
### BasicBlock
Defined in: [src/primitives/Bytecode/BytecodeType.ts:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L134)
Basic block metadata
#### Properties
##### endPc
> **endPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L140)
Ending program counter (exclusive)
##### gasEstimate
> **gasEstimate**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:144](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L144)
Total static gas cost
##### index
> **index**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:136](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L136)
Block index (0-based)
##### instructionCount
> **instructionCount**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L142)
Number of instructions in block
##### isReachable
> **isReachable**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L156)
Whether block is reachable from entry
##### maxStack
> **maxStack**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L148)
Maximum stack depth reached
##### minStack
> **minStack**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:146](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L146)
Minimum stack items required to enter
##### predecessors
> **predecessors**: `number`\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:160](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L160)
Predecessor block indices
##### stackEffect
> **stackEffect**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L150)
Net stack effect (exit - entry)
##### startPc
> **startPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L138)
Starting program counter
##### successors
> **successors**: `number`\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L158)
Successor block indices
##### target?
> `optional` **target**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:154](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L154)
Jump target PC (if terminator is JUMP/JUMPI)
##### terminator
> **terminator**: [`TerminatorType`](#terminatortype)
Defined in: [src/primitives/Bytecode/BytecodeType.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L152)
Block terminator type
***
### BlockAnalysisOptions
Defined in: [src/primitives/Bytecode/BytecodeType.ts:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L166)
Options for analyzeBlocks()
#### Properties
##### buildCFG?
> `optional` **buildCFG**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L170)
Build control flow graph (predecessors/successors)
##### computeReachability?
> `optional` **computeReachability**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:168](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L168)
Compute reachability from entry point
##### includeUnreachable?
> `optional` **includeUnreachable**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L172)
Include unreachable blocks in results
##### validate?
> `optional` **validate**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L174)
Validate bytecode structure
***
### BlockGas
Defined in: [src/primitives/Bytecode/BytecodeType.ts:210](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L210)
Block gas information
#### Properties
##### blockIndex
> **blockIndex**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:211](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L211)
##### endPc
> **endPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:213](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L213)
##### gas
> **gas**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:214](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L214)
##### percentage
> **percentage**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:215](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L215)
##### startPc
> **startPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:212](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L212)
***
### BlockStackInfo
Defined in: [src/primitives/Bytecode/BytecodeType.ts:286](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L286)
Block stack information
#### Properties
##### blockIndex
> **blockIndex**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:287](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L287)
##### endPc
> **endPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:289](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L289)
##### exitDepth
> **exitDepth**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:292](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L292)
##### maxReached
> **maxReached**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:291](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L291)
##### minRequired
> **minRequired**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:290](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L290)
##### stackEffect
> **stackEffect**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:293](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L293)
##### startPc
> **startPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:288](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L288)
***
### ExecutionPath
Defined in: [src/primitives/Bytecode/BytecodeType.ts:231](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L231)
Execution path information
#### Properties
##### blocks
> **blocks**: `number`\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:232](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L232)
##### gas
> **gas**: `bigint`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:233](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L233)
##### instructions
> **instructions**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:234](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L234)
***
### ExpensiveInstruction
Defined in: [src/primitives/Bytecode/BytecodeType.ts:221](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L221)
Expensive instruction information
#### Properties
##### category
> **category**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:225](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L225)
##### gas
> **gas**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:224](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L224)
##### opcode
> **opcode**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:223](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L223)
##### pc
> **pc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:222](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L222)
***
### GasAnalysis
Defined in: [src/primitives/Bytecode/BytecodeType.ts:180](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L180)
Gas analysis result
#### Properties
##### byBlock
> **byBlock**: [`BlockGas`](#blockgas)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:186](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L186)
Gas breakdown by block
##### byInstruction
> **byInstruction**: [`InstructionGas`](#instructiongas)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:184](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L184)
Gas breakdown by instruction
##### expensive
> **expensive**: [`ExpensiveInstruction`](#expensiveinstruction)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:188](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L188)
Expensive instructions (>1000 gas)
##### paths?
> `optional` **paths**: `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:190](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L190)
Path analysis (if enabled)
###### average
> **average**: `bigint`
###### cheapest
> **cheapest**: [`ExecutionPath`](#executionpath)
###### mostExpensive
> **mostExpensive**: [`ExecutionPath`](#executionpath)
##### total
> **total**: `bigint`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:182](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L182)
Total static gas cost
***
### GasAnalysisOptions
Defined in: [src/primitives/Bytecode/BytecodeType.ts:240](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L240)
Options for analyzeGas()
#### Properties
##### analyzePaths?
> `optional` **analyzePaths**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:242](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L242)
Analyze different execution paths
##### context?
> `optional` **context**: `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:248](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L248)
Context for warm/cold gas calculations
###### warmAddresses?
> `optional` **warmAddresses**: `Set`\<`string`>
###### warmSlots?
> `optional` **warmSlots**: `Set`\<`bigint`>
##### includeDynamic?
> `optional` **includeDynamic**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:246](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L246)
Include dynamic gas costs
##### maxPaths?
> `optional` **maxPaths**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:244](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L244)
Maximum paths to explore
***
### InstructionGas
Defined in: [src/primitives/Bytecode/BytecodeType.ts:200](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L200)
Instruction gas information
#### Properties
##### cumulative
> **cumulative**: `bigint`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:204](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L204)
##### gas
> **gas**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:203](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L203)
##### opcode
> **opcode**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:202](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L202)
##### pc
> **pc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:201](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L201)
***
### PrettyPrintOptions
Defined in: [src/primitives/Bytecode/BytecodeType.ts:315](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L315)
Options for prettyPrint()
#### Properties
##### colors?
> `optional` **colors**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:317](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L317)
Enable ANSI color codes
##### compact?
> `optional` **compact**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:335](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L335)
Compact mode (less whitespace)
##### lineNumbers?
> `optional` **lineNumbers**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:329](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L329)
Show line numbers
##### maxWidth?
> `optional` **maxWidth**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:333](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L333)
Maximum output width
##### showBlocks?
> `optional` **showBlocks**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:323](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L323)
Show block boundaries
##### showFusions?
> `optional` **showFusions**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:327](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L327)
Show fusion patterns
##### showGas?
> `optional` **showGas**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:319](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L319)
Show gas costs
##### showJumpArrows?
> `optional` **showJumpArrows**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:325](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L325)
Show jump arrows
##### showStack?
> `optional` **showStack**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:321](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L321)
Show stack effects
##### showSummary?
> `optional` **showSummary**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:331](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L331)
Show summary footer
***
### ScanOptions
Defined in: [src/primitives/Bytecode/BytecodeType.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L105)
Options for scan() iterator
#### Properties
##### detectFusions?
> `optional` **detectFusions**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L111)
Detect and yield fusion patterns
##### endPc?
> `optional` **endPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L115)
Stop iteration at specific PC
##### startPc?
> `optional` **startPc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L113)
Start iteration at specific PC
##### withGas?
> `optional` **withGas**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L107)
Include gas cost for each instruction
##### withStack?
> `optional` **withStack**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L109)
Include stack effect metadata
***
### StackAnalysis
Defined in: [src/primitives/Bytecode/BytecodeType.ts:257](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L257)
Stack analysis result
#### Properties
##### byBlock
> **byBlock**: [`BlockStackInfo`](#blockstackinfo)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:265](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L265)
Stack info by block
##### issues
> **issues**: [`StackIssue`](#stackissue)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:263](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L263)
Stack issues found
##### maxDepth
> **maxDepth**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:261](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L261)
Maximum stack depth reached
##### pathsAnalyzed
> **pathsAnalyzed**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:267](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L267)
Number of paths analyzed
##### valid
> **valid**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:259](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L259)
Whether stack constraints are satisfied
***
### StackAnalysisOptions
Defined in: [src/primitives/Bytecode/BytecodeType.ts:299](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L299)
Options for analyzeStack()
#### Properties
##### analyzePaths?
> `optional` **analyzePaths**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:305](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L305)
Analyze different execution paths
##### failFast?
> `optional` **failFast**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:309](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L309)
Stop at first error
##### initialDepth?
> `optional` **initialDepth**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:301](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L301)
Initial stack depth
##### maxDepth?
> `optional` **maxDepth**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:303](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L303)
Maximum allowed stack depth
##### maxPaths?
> `optional` **maxPaths**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:307](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L307)
Maximum paths to explore
***
### StackIssue
Defined in: [src/primitives/Bytecode/BytecodeType.ts:273](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L273)
Stack issue information
#### Properties
##### actual
> **actual**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:278](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L278)
##### blockIndex
> **blockIndex**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:276](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L276)
##### expected
> **expected**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:277](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L277)
##### message
> **message**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:279](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L279)
##### opcode?
> `optional` **opcode**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:280](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L280)
##### pc
> **pc**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:275](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L275)
##### type
> **type**: `"underflow"` | `"overflow"` | `"unreachable"` | `"inconsistent"`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:274](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L274)
## Type Aliases
### ABIItem
> **ABIItem** = [`ABIFunction`](#abifunction) | [`ABIEvent`](#abievent)
Defined in: [src/primitives/Bytecode/BytecodeType.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L80)
ABI item (function or event)
***
### Analysis
> **Analysis** = `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L42)
Bytecode analysis result
#### Properties
##### instructions
> `readonly` **instructions**: readonly [`Instruction`](#instruction)\[]
Defined in: [src/primitives/Bytecode/BytecodeType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L46)
All instructions
##### jumpDestinations
> `readonly` **jumpDestinations**: `ReadonlySet`\<`number`>
Defined in: [src/primitives/Bytecode/BytecodeType.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L44)
Valid JUMPDEST positions
##### valid
> `readonly` **valid**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L48)
Whether bytecode is valid
***
### BrandedAbi
> **BrandedAbi** = `ReadonlyArray`\<[`ABIItem`](#abiitem)> & `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L75)
Branded ABI type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Abi"`
***
### BrandedBytecodeHex
> **BrandedBytecodeHex** = `string` & `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L70)
Branded hex string for bytecode
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"BytecodeHex"`
***
### Instruction
> **Instruction** = `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L30)
Bytecode instruction
#### Properties
##### opcode
> `readonly` **opcode**: [`Opcode`](#opcode-4)
Defined in: [src/primitives/Bytecode/BytecodeType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L32)
Opcode value
##### position
> `readonly` **position**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L34)
Position in bytecode
##### pushData?
> `readonly` `optional` **pushData**: `Uint8Array`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L36)
Push data if PUSH instruction
***
### JumpDest
> **JumpDest** = `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L20)
Jump destination information
#### Properties
##### position
> `readonly` **position**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L22)
Position in bytecode
##### valid
> `readonly` **valid**: `boolean`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L24)
Whether this is a valid jump destination
***
### Opcode
> **Opcode** = `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L15)
EVM opcode (single byte instruction)
***
### OpcodeMetadata
> **OpcodeMetadata** = `object`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L54)
Opcode metadata
#### Properties
##### gas
> `readonly` **gas**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L60)
Gas cost (base)
##### inputs
> `readonly` **inputs**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L62)
Stack items removed
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L58)
Mnemonic name
##### opcode
> `readonly` **opcode**: [`Opcode`](#opcode-4)
Defined in: [src/primitives/Bytecode/BytecodeType.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L56)
Opcode value
##### outputs
> `readonly` **outputs**: `number`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L64)
Stack items added
***
### TerminatorType
> **TerminatorType** = `"stop"` | `"return"` | `"revert"` | `"invalid"` | `"selfdestruct"` | `"jump"` | `"jumpi"` | `"fallthrough"`
Defined in: [src/primitives/Bytecode/BytecodeType.ts:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/BytecodeType.ts#L121)
Block terminator type
## Variables
### analyze()
> `const` **analyze**: (`code`) => [`Analysis`](#analysis) = `_analyze`
Defined in: [src/primitives/Bytecode/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L56)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
[`Analysis`](#analysis)
***
### analyzeBlocks()
> `const` **analyzeBlocks**: (`bytecode`, `options?`) => [`BasicBlock`](#basicblock)\[] = `_analyzeBlocks`
Defined in: [src/primitives/Bytecode/index.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L57)
#### Parameters
##### bytecode
`BrandedBytecode`
##### options?
[`BlockAnalysisOptions`](#blockanalysisoptions)
#### Returns
[`BasicBlock`](#basicblock)\[]
***
### analyzeGas()
> `const` **analyzeGas**: (`bytecode`, `options?`) => [`GasAnalysis`](#gasanalysis) = `_analyzeGas`
Defined in: [src/primitives/Bytecode/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L61)
#### Parameters
##### bytecode
`BrandedBytecode`
##### options?
[`GasAnalysisOptions`](#gasanalysisoptions)
#### Returns
[`GasAnalysis`](#gasanalysis)
***
### analyzeJumpDestinations()
> `const` **analyzeJumpDestinations**: (`code`) => `ReadonlySet`\<`number`> = `_analyzeJumpDestinations`
Defined in: [src/primitives/Bytecode/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L65)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`ReadonlySet`\<`number`>
***
### analyzeStack()
> `const` **analyzeStack**: (`bytecode`, `options?`) => [`StackAnalysis`](#stackanalysis) = `_analyzeStack`
Defined in: [src/primitives/Bytecode/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L67)
#### Parameters
##### bytecode
`BrandedBytecode`
##### options?
[`StackAnalysisOptions`](#stackanalysisoptions)
#### Returns
[`StackAnalysis`](#stackanalysis)
***
### BrandedBytecode
> `const` **BrandedBytecode**: `object`
Defined in: [src/primitives/Bytecode/index.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L152)
#### Type Declaration
##### \_getNextPc()
> **\_getNextPc**: (`bytecode`, `currentPc`) => `number` | `undefined`
Get next program counter after executing instruction at currentPc
###### Parameters
###### bytecode
`BrandedBytecode`
###### currentPc
`number`
Current program counter
###### Returns
`number` | `undefined`
Next PC, or undefined if at/beyond end
###### Example
```typescript theme={null}
const bytecode = Bytecode("0x6001"); // PUSH1 0x01
getNextPc(bytecode, 0); // 2 (PUSH1 = 1 byte opcode + 1 byte data)
const bytecode2 = Bytecode("0x01"); // ADD
getNextPc(bytecode2, 0); // undefined (would be at EOF)
```
##### analyze()
> **analyze**: (`code`) => [`Analysis`](#analysis)
###### Parameters
###### code
`BrandedBytecode`
###### Returns
[`Analysis`](#analysis)
##### analyzeBlocks()
> **analyzeBlocks**: (`bytecode`, `options?`) => [`BasicBlock`](#basicblock)\[]
###### Parameters
###### bytecode
`BrandedBytecode`
###### options?
[`BlockAnalysisOptions`](#blockanalysisoptions)
###### Returns
[`BasicBlock`](#basicblock)\[]
##### analyzeGas()
> **analyzeGas**: (`bytecode`, `options?`) => [`GasAnalysis`](#gasanalysis)
###### Parameters
###### bytecode
`BrandedBytecode`
###### options?
[`GasAnalysisOptions`](#gasanalysisoptions)
###### Returns
[`GasAnalysis`](#gasanalysis)
##### analyzeJumpDestinations()
> **analyzeJumpDestinations**: (`code`) => `ReadonlySet`\<`number`>
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`ReadonlySet`\<`number`>
##### analyzeStack()
> **analyzeStack**: (`bytecode`, `options?`) => [`StackAnalysis`](#stackanalysis)
###### Parameters
###### bytecode
`BrandedBytecode`
###### options?
[`StackAnalysisOptions`](#stackanalysisoptions)
###### Returns
[`StackAnalysis`](#stackanalysis)
##### detectFusions()
> **detectFusions**: (`code`) => `unknown`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`unknown`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
`BrandedBytecode`
###### b
`BrandedBytecode`
###### Returns
`boolean`
##### extractRuntime()
> **extractRuntime**: (`code`, `offset`) => `BrandedBytecode`
###### Parameters
###### code
`BrandedBytecode`
###### offset
`number`
###### Returns
`BrandedBytecode`
##### formatInstruction()
> **formatInstruction**: (`inst`) => `string`
###### Parameters
###### inst
[`Instruction`](#instruction)
###### Returns
`string`
##### formatInstructions()
> **formatInstructions**: (`code`) => `string`\[]
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`string`\[]
##### from()
> **from**: (`value`) => `BrandedBytecode`
###### Parameters
###### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`BrandedBytecode`
##### fromHex()
> **fromHex**: (`hex`) => `BrandedBytecode`
###### Parameters
###### hex
`string`
###### Returns
`BrandedBytecode`
##### getBlock()
> **getBlock**: (`code`, `pc`) => [`BasicBlock`](#basicblock) | `undefined`
###### Parameters
###### code
`BrandedBytecode`
###### pc
`number`
###### Returns
[`BasicBlock`](#basicblock) | `undefined`
##### getPushSize()
> **getPushSize**: (`opcode`) => `number`
###### Parameters
###### opcode
`number`
###### Returns
`number`
##### hash()
> **hash**: (`code`) => `any`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`any`
##### hasMetadata()
> **hasMetadata**: (`code`) => `boolean`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`boolean`
##### isPush()
> **isPush**: (`opcode`) => `boolean`
###### Parameters
###### opcode
`number`
###### Returns
`boolean`
##### isTerminator()
> **isTerminator**: (`opcode`) => `boolean`
###### Parameters
###### opcode
`number`
###### Returns
`boolean`
##### isValidJumpDest()
> **isValidJumpDest**: (`code`, `offset`) => `boolean`
###### Parameters
###### code
`BrandedBytecode`
###### offset
`number`
###### Returns
`boolean`
##### parseInstructions()
> **parseInstructions**: (`code`) => [`Instruction`](#instruction)\[]
###### Parameters
###### code
`BrandedBytecode`
###### Returns
[`Instruction`](#instruction)\[]
##### prettyPrint()
> **prettyPrint**: (`bytecode`, `options?`) => `string`
###### Parameters
###### bytecode
`BrandedBytecode`
###### options?
[`PrettyPrintOptions`](#prettyprintoptions)
###### Returns
`string`
##### scan()
> **scan**: (`bytecode`, `options?`) => `Generator`\<\{ `gas?`: `number`; `opcode`: `number`; `pc`: `number`; `size`: `number`; `stackEffect?`: \{ `pop`: `number`; `push`: `number`; }; `type`: `"push"` | `"regular"`; `value?`: `bigint`; }>
###### Parameters
###### bytecode
`BrandedBytecode`
###### options?
[`ScanOptions`](#scanoptions)
###### Returns
`Generator`\<\{ `gas?`: `number`; `opcode`: `number`; `pc`: `number`; `size`: `number`; `stackEffect?`: \{ `pop`: `number`; `push`: `number`; }; `type`: `"push"` | `"regular"`; `value?`: `bigint`; }>
##### size()
> **size**: (`code`) => `number`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`number`
##### stripMetadata()
> **stripMetadata**: (`code`) => `BrandedBytecode`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`BrandedBytecode`
##### toAbi()
> **toAbi**: (`bytecode`) => [`BrandedAbi`](#brandedabi)
###### Parameters
###### bytecode
`BrandedBytecode`
###### Returns
[`BrandedAbi`](#brandedabi)
##### toHex()
> **toHex**: (`code`, `prefix?`) => `string`
###### Parameters
###### code
`BrandedBytecode`
###### prefix?
`boolean`
###### Returns
`string`
##### validate()
> **validate**: (`code`) => `boolean`
###### Parameters
###### code
`BrandedBytecode`
###### Returns
`boolean`
***
### detectFusions()
> `const` **detectFusions**: (`code`) => `unknown` = `_detectFusions`
Defined in: [src/primitives/Bytecode/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L71)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`unknown`
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/Bytecode/index.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L72)
#### Parameters
##### a
`BrandedBytecode`
##### b
`BrandedBytecode`
#### Returns
`boolean`
***
### extractRuntime()
> `const` **extractRuntime**: (`code`, `offset`) => `BrandedBytecode` = `_extractRuntime`
Defined in: [src/primitives/Bytecode/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L73)
#### Parameters
##### code
`BrandedBytecode`
##### offset
`number`
#### Returns
`BrandedBytecode`
***
### formatInstruction()
> `const` **formatInstruction**: (`inst`) => `string` = `_formatInstruction`
Defined in: [src/primitives/Bytecode/index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L77)
#### Parameters
##### inst
[`Instruction`](#instruction)
#### Returns
`string`
***
### formatInstructions()
> `const` **formatInstructions**: (`code`) => `string`\[] = `_formatInstructions`
Defined in: [src/primitives/Bytecode/index.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L78)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`string`\[]
***
### from()
> `const` **from**: (`value`) => `BrandedBytecode` = `_from`
Defined in: [src/primitives/Bytecode/index.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L80)
#### Parameters
##### value
`string` | `Uint8Array`
#### Returns
`BrandedBytecode`
***
### fromHex()
> `const` **fromHex**: (`hex`) => `BrandedBytecode` = `_fromHex`
Defined in: [src/primitives/Bytecode/index.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L81)
#### Parameters
##### hex
`string`
#### Returns
`BrandedBytecode`
***
### getBlock()
> `const` **getBlock**: (`code`, `pc`) => [`BasicBlock`](#basicblock) | `undefined` = `_getBlock`
Defined in: [src/primitives/Bytecode/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L82)
#### Parameters
##### code
`BrandedBytecode`
##### pc
`number`
#### Returns
[`BasicBlock`](#basicblock) | `undefined`
***
### getPushSize()
> `const` **getPushSize**: (`opcode`) => `number` = `_getPushSize`
Defined in: [src/primitives/Bytecode/index.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L88)
#### Parameters
##### opcode
`number`
#### Returns
`number`
***
### hash()
> `const` **hash**: (`code`) => `any`
Defined in: [src/primitives/Bytecode/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L53)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`any`
***
### hasMetadata()
> `const` **hasMetadata**: (`code`) => `boolean` = `_hasMetadata`
Defined in: [src/primitives/Bytecode/index.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L89)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`boolean`
***
### isPush()
> `const` **isPush**: (`opcode`) => `boolean` = `_isPush`
Defined in: [src/primitives/Bytecode/index.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L90)
#### Parameters
##### opcode
`number`
#### Returns
`boolean`
***
### isTerminator()
> `const` **isTerminator**: (`opcode`) => `boolean` = `_isTerminator`
Defined in: [src/primitives/Bytecode/index.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L91)
#### Parameters
##### opcode
`number`
#### Returns
`boolean`
***
### isValidJumpDest()
> `const` **isValidJumpDest**: (`code`, `offset`) => `boolean` = `_isValidJumpDest`
Defined in: [src/primitives/Bytecode/index.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L92)
#### Parameters
##### code
`BrandedBytecode`
##### offset
`number`
#### Returns
`boolean`
***
### parseInstructions()
> `const` **parseInstructions**: (`code`) => [`Instruction`](#instruction)\[] = `_parseInstructions`
Defined in: [src/primitives/Bytecode/index.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L94)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
[`Instruction`](#instruction)\[]
***
### prettyPrint()
> `const` **prettyPrint**: (`bytecode`, `options?`) => `string` = `_prettyPrint`
Defined in: [src/primitives/Bytecode/index.ts:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L96)
#### Parameters
##### bytecode
`BrandedBytecode`
##### options?
[`PrettyPrintOptions`](#prettyprintoptions)
#### Returns
`string`
***
### scan()
> `const` **scan**: (`bytecode`, `options?`) => `Generator`\<\{ `gas?`: `number`; `opcode`: `number`; `pc`: `number`; `size`: `number`; `stackEffect?`: \{ `pop`: `number`; `push`: `number`; }; `type`: `"push"` | `"regular"`; `value?`: `bigint`; }> = `_scan`
Defined in: [src/primitives/Bytecode/index.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L100)
#### Parameters
##### bytecode
`BrandedBytecode`
##### options?
[`ScanOptions`](#scanoptions)
#### Returns
`Generator`\<\{ `gas?`: `number`; `opcode`: `number`; `pc`: `number`; `size`: `number`; `stackEffect?`: \{ `pop`: `number`; `push`: `number`; }; `type`: `"push"` | `"regular"`; `value?`: `bigint`; }>
***
### size()
> `const` **size**: (`code`) => `number` = `_size`
Defined in: [src/primitives/Bytecode/index.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L112)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`number`
***
### stripMetadata()
> `const` **stripMetadata**: (`code`) => `BrandedBytecode` = `_stripMetadata`
Defined in: [src/primitives/Bytecode/index.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L113)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`BrandedBytecode`
***
### toAbi()
> `const` **toAbi**: (`bytecode`) => [`BrandedAbi`](#brandedabi) = `_toAbi`
Defined in: [src/primitives/Bytecode/index.ts:116](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L116)
#### Parameters
##### bytecode
`BrandedBytecode`
#### Returns
[`BrandedAbi`](#brandedabi)
***
### toHex()
> `const` **toHex**: (`code`, `prefix?`) => `string` = `_toHex`
Defined in: [src/primitives/Bytecode/index.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L115)
#### Parameters
##### code
`BrandedBytecode`
##### prefix?
`boolean`
#### Returns
`string`
***
### validate()
> `const` **validate**: (`code`) => `boolean` = `_validate`
Defined in: [src/primitives/Bytecode/index.ts:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L117)
#### Parameters
##### code
`BrandedBytecode`
#### Returns
`boolean`
## Functions
### \_getNextPc()
> **\_getNextPc**(`bytecode`, `currentPc`): `number` | `undefined`
Defined in: [src/primitives/Bytecode/getNextPc.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/getNextPc.js#L20)
Get next program counter after executing instruction at currentPc
#### Parameters
##### bytecode
`BrandedBytecode`
##### currentPc
`number`
Current program counter
#### Returns
`number` | `undefined`
Next PC, or undefined if at/beyond end
#### Example
```typescript theme={null}
const bytecode = Bytecode("0x6001"); // PUSH1 0x01
getNextPc(bytecode, 0); // 2 (PUSH1 = 1 byte opcode + 1 byte data)
const bytecode2 = Bytecode("0x01"); // ADD
getNextPc(bytecode2, 0); // undefined (would be at EOF)
```
***
### Bytecode()
> **Bytecode**(`value`): `BrandedBytecode`
Defined in: [src/primitives/Bytecode/index.ts:195](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/index.ts#L195)
Create a Bytecode instance from various input types
Primary constructor - use this for Class API:
```typescript theme={null}
import { Bytecode } from '@tevm/voltaire'
const code = Bytecode("0x6001")
```
#### Parameters
##### value
Bytecode input
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`BrandedBytecode`
Bytecode instance
***
### Hash()
> **Hash**(`deps`): (`code`) => `any`
Defined in: [src/primitives/Bytecode/hash.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytecode/hash.js#L7)
Factory: Compute bytecode hash (keccak256)
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes bytecode hash
> (`code`): `any`
##### Parameters
###### code
`BrandedBytecode`
##### Returns
`any`
# primitives/Bytes
Source: https://voltaire.tevm.sh/generated-api/primitives/Bytes
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Bytes
# primitives/Bytes
## Type Aliases
### Bytes16Type
> **Bytes16Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes16/Bytes16Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes16/Bytes16Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes16"`
##### size
> `readonly` **size**: `16`
***
### Bytes1Type
> **Bytes1Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes1/Bytes1Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes1/Bytes1Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes1"`
##### size
> `readonly` **size**: `1`
***
### Bytes2Type
> **Bytes2Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes2/Bytes2Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes2/Bytes2Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes2"`
##### size
> `readonly` **size**: `2`
***
### Bytes32Type
> **Bytes32Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes32/Bytes32Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes32/Bytes32Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes32"`
##### size
> `readonly` **size**: `32`
***
### Bytes3Type
> **Bytes3Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes3/Bytes3Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes3/Bytes3Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes3"`
##### size
> `readonly` **size**: `3`
***
### Bytes4Type
> **Bytes4Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes4/Bytes4Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes4/Bytes4Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes4"`
##### size
> `readonly` **size**: `4`
***
### Bytes5Type
> **Bytes5Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes5/Bytes5Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes5/Bytes5Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes5"`
##### size
> `readonly` **size**: `5`
***
### Bytes64Type
> **Bytes64Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes64/Bytes64Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes64/Bytes64Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes64"`
##### size
> `readonly` **size**: `64`
***
### Bytes6Type
> **Bytes6Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes6/Bytes6Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes6/Bytes6Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes6"`
##### size
> `readonly` **size**: `6`
***
### Bytes7Type
> **Bytes7Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes7/Bytes7Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes7/Bytes7Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes7"`
##### size
> `readonly` **size**: `7`
***
### Bytes8Type
> **Bytes8Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/Bytes8/Bytes8Type.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/Bytes8/Bytes8Type.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes8"`
##### size
> `readonly` **size**: `8`
***
### BytesType
> **BytesType** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes/BytesType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes/BytesType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes"`
## References
### BrandedBytes
Re-exports [BrandedBytes](../index/namespaces/BrandedBytes.mdx)
***
### Bytes
Re-exports [Bytes](../index/index.mdx#bytes)
***
### Bytes1
Renames and re-exports [BrandedBytes1](../index/namespaces/BrandedBytes1.mdx)
***
### Bytes16
Renames and re-exports [BrandedBytes16](../index/namespaces/BrandedBytes16.mdx)
***
### Bytes2
Renames and re-exports [BrandedBytes2](../index/namespaces/BrandedBytes2.mdx)
***
### Bytes3
Renames and re-exports [BrandedBytes3](../index/namespaces/BrandedBytes3.mdx)
***
### Bytes32
Renames and re-exports [BrandedBytes32](../index/namespaces/BrandedBytes32.mdx)
***
### Bytes4
Renames and re-exports [BrandedBytes4](../index/namespaces/BrandedBytes4.mdx)
***
### Bytes5
Renames and re-exports [BrandedBytes5](../index/namespaces/BrandedBytes5.mdx)
***
### Bytes6
Renames and re-exports [BrandedBytes6](../index/namespaces/BrandedBytes6.mdx)
***
### Bytes64
Renames and re-exports [BrandedBytes64](../index/namespaces/BrandedBytes64.mdx)
***
### Bytes7
Renames and re-exports [BrandedBytes7](../index/namespaces/BrandedBytes7.mdx)
***
### Bytes8
Renames and re-exports [BrandedBytes8](../index/namespaces/BrandedBytes8.mdx)
# primitives/Bytes32
Source: https://voltaire.tevm.sh/generated-api/primitives/Bytes32
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Bytes32
# primitives/Bytes32
Bytes32 - Fixed-size 32-byte array type
Generic 32-byte data structure used throughout Ethereum for various purposes
including storage values, contract data, and numeric representations.
## Classes
### InvalidBytes32HexError
Defined in: [src/primitives/Bytes32/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L10)
Error thrown when Bytes32 hex format is invalid
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidBytes32HexError**(`message?`, `options?`): [`InvalidBytes32HexError`](#invalidbytes32hexerror)
Defined in: [src/primitives/Bytes32/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L21)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected format
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidBytes32HexError`](#invalidbytes32hexerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes32/errors.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L30)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidBytes32LengthError
Defined in: [src/primitives/Bytes32/errors.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L37)
Error thrown when Bytes32 has invalid length
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidBytes32LengthError**(`message?`, `options?`): [`InvalidBytes32LengthError`](#invalidbytes32lengtherror)
Defined in: [src/primitives/Bytes32/errors.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L48)
###### Parameters
###### message?
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected length
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidBytes32LengthError`](#invalidbytes32lengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes32/errors.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L57)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidBytes32ValueError
Defined in: [src/primitives/Bytes32/errors.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L64)
Error thrown when value is invalid for Bytes32
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidBytes32ValueError**(`message`, `options?`): [`InvalidBytes32ValueError`](#invalidbytes32valueerror)
Defined in: [src/primitives/Bytes32/errors.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L75)
###### Parameters
###### message
`string`
Error message
###### options?
Error options
###### cause?
`Error`
Root cause error
###### code?
`string`
Error code
###### context?
`Record`\<`string`, `unknown`>
Additional context
###### docsPath?
`string`
Documentation path
###### expected?
`string`
Expected value
###### value?
`unknown`
Invalid value
###### Returns
[`InvalidBytes32ValueError`](#invalidbytes32valueerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### name
> **name**: `string`
Defined in: [src/primitives/Bytes32/errors.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/errors.js#L84)
###### Inherited from
`ValidationError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
## Type Aliases
### Bytes32Like
> **Bytes32Like** = [`Bytes32Type`](#bytes32type) | `string` | `Uint8Array` | `bigint` | `number`
Defined in: [src/primitives/Bytes32/Bytes32Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/Bytes32Type.ts#L18)
Inputs that can be converted to Bytes32
***
### Bytes32Type
> **Bytes32Type** = `Uint8Array` & `object`
Defined in: [src/primitives/Bytes32/Bytes32Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/Bytes32Type.ts#L11)
Bytes32 - Fixed-size 32-byte array type
Generic 32-byte data structure used throughout Ethereum for various purposes
including storage values, contract data, and numeric representations.
While Hash is specifically for cryptographic hashes, Bytes32 is the general-purpose
32-byte type that can represent any 32-byte data.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Bytes32"`
## Variables
### Bytes32
> `const` **Bytes32**: `object`
Defined in: [src/primitives/Bytes32/index.ts:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/index.ts#L87)
#### Type Declaration
##### bitwiseAnd()
> **bitwiseAnd**: (`a`, `b`) => [`Bytes32Type`](#bytes32type)
Perform bitwise AND on two Bytes32 values
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
Result of a & b
###### Example
```typescript theme={null}
const result = Bytes32.bitwiseAnd(a, b);
```
##### bitwiseOr()
> **bitwiseOr**: (`a`, `b`) => [`Bytes32Type`](#bytes32type)
Perform bitwise OR on two Bytes32 values
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
Result of a | b
###### Example
```typescript theme={null}
const result = Bytes32.bitwiseOr(a, b);
```
##### bitwiseXor()
> **bitwiseXor**: (`a`, `b`) => [`Bytes32Type`](#bytes32type)
Perform bitwise XOR on two Bytes32 values
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
Result of a ^ b
###### Example
```typescript theme={null}
const result = Bytes32.bitwiseXor(a, b);
```
##### clone()
> **clone**: (`bytes32`) => [`Bytes32Type`](#bytes32type)
Create an independent copy of Bytes32
###### Parameters
###### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to clone
###### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with same values
###### Example
```typescript theme={null}
const copy = Bytes32.clone(original);
// Modifying copy won't affect original
```
##### compare()
> **compare**: (`a`, `b`) => `number`
Compare two Bytes32 values lexicographically
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
###### Example
```typescript theme={null}
const sorted = bytes32Array.sort(Bytes32.compare);
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two Bytes32 values are equal
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
`boolean`
True if equal
###### Example
```typescript theme={null}
if (Bytes32.equals(a, b)) {
console.log("Values match");
}
```
##### from()
> **from**: (`value`) => [`Bytes32Type`](#bytes32type)
Create Bytes32 from various input types (universal constructor)
###### Parameters
###### value
Number, bigint, hex string, or Uint8Array
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
###### Throws
If value type is unsupported or invalid
###### Example
```typescript theme={null}
const b1 = Bytes32.from(42); // from number
const b2 = Bytes32.from(42n); // from bigint
const b3 = Bytes32.from('0x' + 'ab'.repeat(32)); // from hex
const b4 = Bytes32.from(new Uint8Array(32)); // from bytes
```
##### fromBigint()
> **fromBigint**: (`value`) => [`Bytes32Type`](#bytes32type)
Create Bytes32 from bigint (big-endian)
###### Parameters
###### value
`bigint`
Bigint to convert (must fit in 256 bits)
###### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
###### Throws
If value is negative or exceeds 256 bits
###### Example
```typescript theme={null}
const b32 = Bytes32.fromBigint(0x123456789abcdef0n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`Bytes32Type`](#bytes32type)
Create Bytes32 from bytes. Input must be exactly 32 bytes.
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Input bytes (must be 32 bytes)
###### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
###### Throws
If bytes length is not 32
###### Example
```typescript theme={null}
const bytes = new Uint8Array(32);
bytes[0] = 1;
const b32 = Bytes32.fromBytes(bytes);
```
##### fromHex()
> **fromHex**: (`hex`) => [`Bytes32Type`](#bytes32type)
Create Bytes32 from hex string (with or without 0x prefix)
###### Parameters
###### hex
`string`
Hex string (64 chars, with or without 0x prefix)
###### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
###### Throws
If hex length is not 64 characters
###### Throws
If hex contains invalid characters
###### Example
```typescript theme={null}
const b32 = Bytes32.fromHex('0x' + 'ab'.repeat(32));
const b32Alt = Bytes32.fromHex('ab'.repeat(32));
```
##### fromNumber()
> **fromNumber**: (`value`) => [`Bytes32Type`](#bytes32type)
Create Bytes32 from number (big-endian, zero-padded)
###### Parameters
###### value
`number`
Number to convert
###### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
###### Example
```typescript theme={null}
const b32 = Bytes32.fromNumber(42);
// Last byte is 42, rest are zeros
```
##### isZero()
> **isZero**: (`bytes32`) => `boolean`
Check if Bytes32 is all zeros
###### Parameters
###### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to check
###### Returns
`boolean`
True if all bytes are zero
###### Example
```typescript theme={null}
if (Bytes32.isZero(b32)) {
console.log("Empty slot");
}
```
##### max()
> **max**: (`a`, `b`) => [`Bytes32Type`](#bytes32type)
Return the maximum of two Bytes32 values (lexicographically)
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
The larger value
###### Example
```typescript theme={null}
const larger = Bytes32.max(a, b);
```
##### min()
> **min**: (`a`, `b`) => [`Bytes32Type`](#bytes32type)
Return the minimum of two Bytes32 values (lexicographically)
###### Parameters
###### a
[`Bytes32Type`](#bytes32type)
First Bytes32
###### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
The smaller value
###### Example
```typescript theme={null}
const smaller = Bytes32.min(a, b);
```
##### SIZE
> **SIZE**: `number`
Size of Bytes32 in bytes
##### toBigint()
> **toBigint**: (`bytes32`) => `bigint`
Convert Bytes32 to bigint (big-endian)
###### Parameters
###### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
###### Returns
`bigint`
Big-endian bigint representation
###### Example
```typescript theme={null}
const value = Bytes32.toBigint(b32);
```
##### toHex()
> **toHex**: (`bytes32`) => `string`
Convert Bytes32 to hex string with 0x prefix
###### Parameters
###### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
###### Returns
`string`
Lowercase hex string with 0x prefix (66 chars total)
###### Example
```typescript theme={null}
const hex = Bytes32.toHex(b32);
// "0x000000000000000000000000000000000000000000000000000000000000002a"
```
##### toNumber()
> **toNumber**: (`bytes32`) => `number`
Convert Bytes32 to number (big-endian)
###### Parameters
###### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
###### Returns
`number`
Number representation
###### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
###### Example
```typescript theme={null}
const value = Bytes32.toNumber(b32);
```
##### zero()
> **zero**: () => [`Bytes32Type`](#bytes32type)
Create a zero-filled Bytes32
###### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with all zeros
###### Example
```typescript theme={null}
const empty = Bytes32.zero();
```
##### ZERO
> **ZERO**: [`Bytes32Type`](#bytes32type)
Zero constant - 32 bytes of zeros
***
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/Bytes32/constants.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/constants.js#L7)
Size of Bytes32 in bytes
***
### ZERO
> `const` **ZERO**: [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/constants.js#L10)
Zero constant - 32 bytes of zeros
## Functions
### \_bitwiseAnd()
> **\_bitwiseAnd**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseAnd.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseAnd.js#L15)
Perform bitwise AND on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a & b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseAnd(a, b);
```
***
### \_bitwiseOr()
> **\_bitwiseOr**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseOr.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseOr.js#L15)
Perform bitwise OR on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a | b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseOr(a, b);
```
***
### \_bitwiseXor()
> **\_bitwiseXor**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseXor.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseXor.js#L15)
Perform bitwise XOR on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a ^ b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseXor(a, b);
```
***
### \_clone()
> **\_clone**(`bytes32`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/clone.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/clone.js#L15)
Create an independent copy of Bytes32
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to clone
#### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with same values
#### Example
```typescript theme={null}
const copy = Bytes32.clone(original);
// Modifying copy won't affect original
```
***
### \_compare()
> **\_compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes32/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/compare.js#L15)
Compare two Bytes32 values lexicographically
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### Example
```typescript theme={null}
const sorted = bytes32Array.sort(Bytes32.compare);
```
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes32/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/equals.js#L17)
Check if two Bytes32 values are equal
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
if (Bytes32.equals(a, b)) {
console.log("Values match");
}
```
***
### \_from()
> **\_from**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/from.js#L22)
Create Bytes32 from various input types (universal constructor)
#### Parameters
##### value
Number, bigint, hex string, or Uint8Array
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If value type is unsupported or invalid
#### Example
```typescript theme={null}
const b1 = Bytes32.from(42); // from number
const b2 = Bytes32.from(42n); // from bigint
const b3 = Bytes32.from('0x' + 'ab'.repeat(32)); // from hex
const b4 = Bytes32.from(new Uint8Array(32)); // from bytes
```
***
### \_fromBigint()
> **\_fromBigint**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromBigint.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromBigint.js#L21)
Create Bytes32 from bigint (big-endian)
#### Parameters
##### value
`bigint`
Bigint to convert (must fit in 256 bits)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If value is negative or exceeds 256 bits
#### Example
```typescript theme={null}
const b32 = Bytes32.fromBigint(0x123456789abcdef0n);
```
***
### \_fromBytes()
> **\_fromBytes**(`bytes`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromBytes.js#L18)
Create Bytes32 from bytes. Input must be exactly 32 bytes.
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Input bytes (must be 32 bytes)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If bytes length is not 32
#### Example
```typescript theme={null}
const bytes = new Uint8Array(32);
bytes[0] = 1;
const b32 = Bytes32.fromBytes(bytes);
```
***
### \_fromHex()
> **\_fromHex**(`hex`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromHex.js#L18)
Create Bytes32 from hex string (with or without 0x prefix)
#### Parameters
##### hex
`string`
Hex string (64 chars, with or without 0x prefix)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If hex length is not 64 characters
#### Throws
If hex contains invalid characters
#### Example
```typescript theme={null}
const b32 = Bytes32.fromHex('0x' + 'ab'.repeat(32));
const b32Alt = Bytes32.fromHex('ab'.repeat(32));
```
***
### \_fromNumber()
> **\_fromNumber**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromNumber.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromNumber.js#L15)
Create Bytes32 from number (big-endian, zero-padded)
#### Parameters
##### value
`number`
Number to convert
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Example
```typescript theme={null}
const b32 = Bytes32.fromNumber(42);
// Last byte is 42, rest are zeros
```
***
### \_isZero()
> **\_isZero**(`bytes32`): `boolean`
Defined in: [src/primitives/Bytes32/isZero.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/isZero.js#L16)
Check if Bytes32 is all zeros
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to check
#### Returns
`boolean`
True if all bytes are zero
#### Example
```typescript theme={null}
if (Bytes32.isZero(b32)) {
console.log("Empty slot");
}
```
***
### \_max()
> **\_max**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/max.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/max.js#L15)
Return the maximum of two Bytes32 values (lexicographically)
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
The larger value
#### Example
```typescript theme={null}
const larger = Bytes32.max(a, b);
```
***
### \_min()
> **\_min**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/min.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/min.js#L15)
Return the minimum of two Bytes32 values (lexicographically)
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
The smaller value
#### Example
```typescript theme={null}
const smaller = Bytes32.min(a, b);
```
***
### \_toBigint()
> **\_toBigint**(`bytes32`): `bigint`
Defined in: [src/primitives/Bytes32/toBigint.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toBigint.js#L12)
Convert Bytes32 to bigint (big-endian)
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`bigint`
Big-endian bigint representation
#### Example
```typescript theme={null}
const value = Bytes32.toBigint(b32);
```
***
### \_toHex()
> **\_toHex**(`bytes32`): `string`
Defined in: [src/primitives/Bytes32/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toHex.js#L13)
Convert Bytes32 to hex string with 0x prefix
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`string`
Lowercase hex string with 0x prefix (66 chars total)
#### Example
```typescript theme={null}
const hex = Bytes32.toHex(b32);
// "0x000000000000000000000000000000000000000000000000000000000000002a"
```
***
### \_toNumber()
> **\_toNumber**(`bytes32`): `number`
Defined in: [src/primitives/Bytes32/toNumber.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toNumber.js#L21)
Convert Bytes32 to number (big-endian)
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`number`
Number representation
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```typescript theme={null}
const value = Bytes32.toNumber(b32);
```
***
### \_zero()
> **\_zero**(): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/zero.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/zero.js#L13)
Create a zero-filled Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with all zeros
#### Example
```typescript theme={null}
const empty = Bytes32.zero();
```
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseAnd.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseAnd.js#L15)
Perform bitwise AND on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a & b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseAnd(a, b);
```
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseOr.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseOr.js#L15)
Perform bitwise OR on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a | b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseOr(a, b);
```
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/bitwiseXor.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/bitwiseXor.js#L15)
Perform bitwise XOR on two Bytes32 values
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
Result of a ^ b
#### Example
```typescript theme={null}
const result = Bytes32.bitwiseXor(a, b);
```
***
### clone()
> **clone**(`bytes32`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/clone.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/clone.js#L15)
Create an independent copy of Bytes32
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to clone
#### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with same values
#### Example
```typescript theme={null}
const copy = Bytes32.clone(original);
// Modifying copy won't affect original
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/Bytes32/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/compare.js#L15)
Compare two Bytes32 values lexicographically
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
`number`
-1 if a \< b, 0 if equal, 1 if a > b
#### Example
```typescript theme={null}
const sorted = bytes32Array.sort(Bytes32.compare);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Bytes32/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/equals.js#L17)
Check if two Bytes32 values are equal
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
if (Bytes32.equals(a, b)) {
console.log("Values match");
}
```
***
### from()
> **from**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/from.js#L22)
Create Bytes32 from various input types (universal constructor)
#### Parameters
##### value
Number, bigint, hex string, or Uint8Array
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If value type is unsupported or invalid
#### Example
```typescript theme={null}
const b1 = Bytes32.from(42); // from number
const b2 = Bytes32.from(42n); // from bigint
const b3 = Bytes32.from('0x' + 'ab'.repeat(32)); // from hex
const b4 = Bytes32.from(new Uint8Array(32)); // from bytes
```
***
### fromBigint()
> **fromBigint**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromBigint.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromBigint.js#L21)
Create Bytes32 from bigint (big-endian)
#### Parameters
##### value
`bigint`
Bigint to convert (must fit in 256 bits)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If value is negative or exceeds 256 bits
#### Example
```typescript theme={null}
const b32 = Bytes32.fromBigint(0x123456789abcdef0n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromBytes.js#L18)
Create Bytes32 from bytes. Input must be exactly 32 bytes.
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Input bytes (must be 32 bytes)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If bytes length is not 32
#### Example
```typescript theme={null}
const bytes = new Uint8Array(32);
bytes[0] = 1;
const b32 = Bytes32.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromHex.js#L18)
Create Bytes32 from hex string (with or without 0x prefix)
#### Parameters
##### hex
`string`
Hex string (64 chars, with or without 0x prefix)
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Throws
If hex length is not 64 characters
#### Throws
If hex contains invalid characters
#### Example
```typescript theme={null}
const b32 = Bytes32.fromHex('0x' + 'ab'.repeat(32));
const b32Alt = Bytes32.fromHex('ab'.repeat(32));
```
***
### fromNumber()
> **fromNumber**(`value`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/fromNumber.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/fromNumber.js#L15)
Create Bytes32 from number (big-endian, zero-padded)
#### Parameters
##### value
`number`
Number to convert
#### Returns
[`Bytes32Type`](#bytes32type)
Bytes32
#### Example
```typescript theme={null}
const b32 = Bytes32.fromNumber(42);
// Last byte is 42, rest are zeros
```
***
### isZero()
> **isZero**(`bytes32`): `boolean`
Defined in: [src/primitives/Bytes32/isZero.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/isZero.js#L16)
Check if Bytes32 is all zeros
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to check
#### Returns
`boolean`
True if all bytes are zero
#### Example
```typescript theme={null}
if (Bytes32.isZero(b32)) {
console.log("Empty slot");
}
```
***
### max()
> **max**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/max.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/max.js#L15)
Return the maximum of two Bytes32 values (lexicographically)
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
The larger value
#### Example
```typescript theme={null}
const larger = Bytes32.max(a, b);
```
***
### min()
> **min**(`a`, `b`): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/min.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/min.js#L15)
Return the minimum of two Bytes32 values (lexicographically)
#### Parameters
##### a
[`Bytes32Type`](#bytes32type)
First Bytes32
##### b
[`Bytes32Type`](#bytes32type)
Second Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
The smaller value
#### Example
```typescript theme={null}
const smaller = Bytes32.min(a, b);
```
***
### toBigint()
> **toBigint**(`bytes32`): `bigint`
Defined in: [src/primitives/Bytes32/toBigint.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toBigint.js#L12)
Convert Bytes32 to bigint (big-endian)
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`bigint`
Big-endian bigint representation
#### Example
```typescript theme={null}
const value = Bytes32.toBigint(b32);
```
***
### toHex()
> **toHex**(`bytes32`): `string`
Defined in: [src/primitives/Bytes32/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toHex.js#L13)
Convert Bytes32 to hex string with 0x prefix
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`string`
Lowercase hex string with 0x prefix (66 chars total)
#### Example
```typescript theme={null}
const hex = Bytes32.toHex(b32);
// "0x000000000000000000000000000000000000000000000000000000000000002a"
```
***
### toNumber()
> **toNumber**(`bytes32`): `number`
Defined in: [src/primitives/Bytes32/toNumber.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/toNumber.js#L21)
Convert Bytes32 to number (big-endian)
#### Parameters
##### bytes32
[`Bytes32Type`](#bytes32type)
Bytes32 to convert
#### Returns
`number`
Number representation
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```typescript theme={null}
const value = Bytes32.toNumber(b32);
```
***
### zero()
> **zero**(): [`Bytes32Type`](#bytes32type)
Defined in: [src/primitives/Bytes32/zero.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Bytes32/zero.js#L13)
Create a zero-filled Bytes32
#### Returns
[`Bytes32Type`](#bytes32type)
New Bytes32 with all zeros
#### Example
```typescript theme={null}
const empty = Bytes32.zero();
```
## References
### default
Renames and re-exports [Bytes32](#bytes32)
# primitives/CallData
Source: https://voltaire.tevm.sh/generated-api/primitives/CallData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/CallData
# primitives/CallData
## Classes
### InvalidCallDataLengthError
Defined in: [src/primitives/CallData/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L4)
Error thrown when calldata is too short (must be at least 4 bytes for selector)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidCallDataLengthError**(`message`, `options?`): [`InvalidCallDataLengthError`](#invalidcalldatalengtherror)
Defined in: [src/primitives/CallData/errors.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L9)
###### Parameters
###### message
`string`
###### options?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidCallDataLengthError`](#invalidcalldatalengtherror)
###### Overrides
`Error.constructor`
#### Properties
##### code
> `readonly` **code**: `"INVALID_CALLDATA_LENGTH"` = `"INVALID_CALLDATA_LENGTH"`
Defined in: [src/primitives/CallData/errors.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L5)
##### expected
> `readonly` **expected**: `string`
Defined in: [src/primitives/CallData/errors.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L7)
##### value
> `readonly` **value**: `unknown`
Defined in: [src/primitives/CallData/errors.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L6)
***
### InvalidHexFormatError
Defined in: [src/primitives/CallData/errors.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L23)
Error thrown when hex string format is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidHexFormatError**(`message`): [`InvalidHexFormatError`](#invalidhexformaterror)
Defined in: [src/primitives/CallData/errors.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L26)
###### Parameters
###### message
`string`
###### Returns
[`InvalidHexFormatError`](#invalidhexformaterror)
###### Overrides
`Error.constructor`
#### Properties
##### code
> `readonly` **code**: `"INVALID_HEX_FORMAT"` = `"INVALID_HEX_FORMAT"`
Defined in: [src/primitives/CallData/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L24)
***
### InvalidValueError
Defined in: [src/primitives/CallData/errors.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L35)
Error thrown when value type is unsupported
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidValueError**(`message`, `options?`): [`InvalidValueError`](#invalidvalueerror)
Defined in: [src/primitives/CallData/errors.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L40)
###### Parameters
###### message
`string`
###### options?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidValueError`](#invalidvalueerror)
###### Overrides
`Error.constructor`
#### Properties
##### code
> `readonly` **code**: `"INVALID_VALUE"` = `"INVALID_VALUE"`
Defined in: [src/primitives/CallData/errors.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L36)
##### expected?
> `readonly` `optional` **expected**: `string`
Defined in: [src/primitives/CallData/errors.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L38)
##### value
> `readonly` **value**: `unknown`
Defined in: [src/primitives/CallData/errors.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/errors.ts#L37)
## Interfaces
### BaseCallData
Defined in: [src/primitives/CallData/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L12)
Base CallData interface with instance methods
#### Extends
* [`CallDataType`](#calldatatype)
#### Indexable
\[`index`: `number`]: `number`
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"CallData"`
Defined in: [src/primitives/CallData/CallDataType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/CallDataType.ts#L10)
###### Inherited from
`CallDataType.[brand]`
#### Methods
##### equals()
> **equals**(`other`): `boolean`
Defined in: [src/primitives/CallData/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L17)
###### Parameters
###### other
[`CallDataType`](#calldatatype)
###### Returns
`boolean`
##### getSelector()
> **getSelector**(): `Uint8Array`
Defined in: [src/primitives/CallData/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L15)
###### Returns
`Uint8Array`
##### hasSelector()
> **hasSelector**(`selector`): `boolean`
Defined in: [src/primitives/CallData/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L16)
###### Parameters
###### selector
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`boolean`
##### toBytes()
> **toBytes**(): `Uint8Array`
Defined in: [src/primitives/CallData/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L14)
###### Returns
`Uint8Array`
##### toHex()
> **toHex**(): `string`
Defined in: [src/primitives/CallData/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L13)
Convert the Uint8Array to a hex encoded string
###### Returns
`string`
The hex encoded string representation of the Uint8Array
###### Overrides
`CallDataType.toHex`
## Type Aliases
### CallDataType
> **CallDataType** = `Uint8Array` & `object`
Defined in: [src/primitives/CallData/CallDataType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/CallDataType.ts#L9)
Branded CallData type for EVM transaction calldata
CallData is a branded Uint8Array containing function selector (first 4 bytes)
followed by ABI-encoded parameters.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"CallData"`
## Variables
### decode()
> `const` **decode**: (`calldata`, `abi`) => `CallDataDecoded` = `BrandedCallData.decode`
Defined in: [src/primitives/CallData/index.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L118)
Decode CallData to structured form
#### Parameters
##### calldata
[`CallDataType`](#calldatatype)
CallData to decode
##### abi
readonly `Item`\[]
ABI specification with function definitions
#### Returns
`CallDataDecoded`
Decoded structure with selector, signature, and parameters
#### Throws
If function not found in ABI or decoding fails
#### Example
```javascript theme={null}
const abi = [{
name: "transfer",
type: "function",
inputs: [
{ name: "to", type: "address" },
{ name: "amount", type: "uint256" }
]
}];
const decoded = CallData.decode(calldata, abi);
console.log(decoded.signature); // "transfer(address,uint256)"
console.log(decoded.parameters[0]); // "0x..."
console.log(decoded.parameters[1]); // bigint
```
***
### encode()
> `const` **encode**: (`signature`, `params`) => [`CallDataType`](#calldatatype) = `CallData.encode`
Defined in: [src/primitives/CallData/index.ts:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L117)
#### Parameters
##### signature
`string`
##### params
`unknown`\[]
#### Returns
[`CallDataType`](#calldatatype)
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `BrandedCallData.equals`
Defined in: [src/primitives/CallData/index.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L114)
Check if two CallData instances are equal (constant-time comparison)
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### a
[`CallDataType`](#calldatatype)
First CallData
##### b
[`CallDataType`](#calldatatype)
Second CallData
#### Returns
`boolean`
True if instances are bytewise identical
#### Example
```javascript theme={null}
const calldata1 = CallData.from("0xa9059cbb...");
const calldata2 = CallData.from("0xa9059cbb...");
console.log(CallData.equals(calldata1, calldata2)); // true
```
***
### from()
> `const` **from**: (`value`) => [`CallDataType`](#calldatatype) = `CallData.from`
Defined in: [src/primitives/CallData/index.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L107)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`CallDataType`](#calldatatype)
***
### fromBytes()
> `const` **fromBytes**: (`value`) => [`CallDataType`](#calldatatype) = `CallData.fromBytes`
Defined in: [src/primitives/CallData/index.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L109)
#### Parameters
##### value
`Uint8Array`
#### Returns
[`CallDataType`](#calldatatype)
***
### fromHex()
> `const` **fromHex**: (`value`) => [`CallDataType`](#calldatatype) = `CallData.fromHex`
Defined in: [src/primitives/CallData/index.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L108)
#### Parameters
##### value
`string`
#### Returns
[`CallDataType`](#calldatatype)
***
### getSelector()
> `const` **getSelector**: (`calldata`) => `Uint8Array`\<`ArrayBufferLike`> = `BrandedCallData.getSelector`
Defined in: [src/primitives/CallData/index.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L112)
Extract 4-byte function selector from CallData
#### Parameters
##### calldata
[`CallDataType`](#calldatatype)
CallData to extract selector from
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte array containing function selector (view, not copy)
#### Example
```javascript theme={null}
const calldata = CallData.from("0xa9059cbb...");
const selector = CallData.getSelector(calldata);
console.log(selector); // Uint8Array [0xa9, 0x05, 0x9c, 0xbb]
```
***
### hasSelector()
> `const` **hasSelector**: (`calldata`, `selector`) => `boolean` = `BrandedCallData.hasSelector`
Defined in: [src/primitives/CallData/index.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L113)
Check if CallData matches a specific function selector
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### calldata
[`CallDataType`](#calldatatype)
CallData to check
##### selector
Expected selector (hex string or bytes)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`boolean`
True if selector matches
#### Example
```javascript theme={null}
const calldata = CallData.from("0xa9059cbb...");
// Check with hex string
CallData.hasSelector(calldata, "0xa9059cbb"); // true
// Check with bytes
CallData.hasSelector(calldata, new Uint8Array([0xa9, 0x05, 0x9c, 0xbb])); // true
```
***
### is()
> `const` **is**: (`value`) => `value is CallDataType` = `BrandedCallData.is`
Defined in: [src/primitives/CallData/index.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L115)
Type guard to check if value is CallData
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is CallDataType`
True if value is CallData
#### Example
```javascript theme={null}
if (CallData.is(value)) {
// value is CallDataType here (type narrowed)
const selector = CallData.getSelector(value);
}
```
***
### isValid()
> `const` **isValid**: (`value`) => `boolean` = `BrandedCallData.isValid`
Defined in: [src/primitives/CallData/index.ts:116](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L116)
Check if value can be converted to CallData
#### Parameters
##### value
`unknown`
Value to validate
#### Returns
`boolean`
True if value can be converted to CallData
#### Example
```javascript theme={null}
CallData.isValid("0xa9059cbb"); // true (valid 4-byte selector)
CallData.isValid("0x1234"); // false (only 2 bytes)
CallData.isValid("0xGGGG"); // false (invalid hex)
CallData.isValid(null); // false
```
***
### MIN\_SIZE
> `const` **MIN\_SIZE**: `number` = `4`
Defined in: [src/primitives/CallData/constants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/constants.js#L5)
Minimum size for calldata (4 bytes for function selector)
***
### SELECTOR\_SIZE
> `const` **SELECTOR\_SIZE**: `number` = `4`
Defined in: [src/primitives/CallData/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/constants.js#L11)
Size of function selector in bytes
***
### toBytes()
> `const` **toBytes**: (`calldata`) => `Uint8Array`\<`ArrayBufferLike`> = `BrandedCallData.toBytes`
Defined in: [src/primitives/CallData/index.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L111)
Return the underlying Uint8Array representation (zero-copy)
#### Parameters
##### calldata
[`CallDataType`](#calldatatype)
CallData to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw byte array (shares underlying buffer)
#### Example
```javascript theme={null}
const calldata = CallData.from("0xa9059cbb");
const bytes = CallData.toBytes(calldata);
console.log(bytes.length); // 4
```
***
### toHex()
> `const` **toHex**: (`calldata`) => [`HexType`](Hex.mdx#hextype) = `BrandedCallData.toHex`
Defined in: [src/primitives/CallData/index.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L110)
Convert CallData to hex string with 0x prefix
#### Parameters
##### calldata
[`CallDataType`](#calldatatype)
CallData to convert
#### Returns
[`HexType`](Hex.mdx#hextype)
Lowercase hex string with 0x prefix
#### Example
```javascript theme={null}
const calldata = CallData.fromBytes(new Uint8Array([0xa9, 0x05, 0x9c, 0xbb]));
console.log(CallData.toHex(calldata)); // "0xa9059cbb"
```
## Functions
### CallData()
> **CallData**(`value`): [`BaseCallData`](#basecalldata)
Defined in: [src/primitives/CallData/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallData/index.ts#L35)
Creates CallData instances with prototype chain
#### Parameters
##### value
Value to convert (hex string or bytes)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`BaseCallData`](#basecalldata)
CallData instance with prototype methods
#### See
[https://voltaire.tevm.sh/primitives/calldata](https://voltaire.tevm.sh/primitives/calldata) for CallData documentation
#### Since
0.0.0
#### Throws
If value format is invalid
#### Example
```typescript theme={null}
import { CallData } from './primitives/CallData/index.js';
const calldata = CallData('0xa9059cbb...');
console.log(calldata.toHex());
```
## References
### default
Renames and re-exports [CallData](#calldata)
# primitives/CallTrace
Source: https://voltaire.tevm.sh/generated-api/primitives/CallTrace
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/CallTrace
# primitives/CallTrace
## Type Aliases
### CallTraceType
> **CallTraceType** = `object`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L12)
Call tree structure from callTracer
Represents a single call (or create) and its nested subcalls
#### See
[https://voltaire.tevm.sh/primitives/call-trace](https://voltaire.tevm.sh/primitives/call-trace) for CallTrace documentation
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"CallTrace"`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L13)
##### calls?
> `readonly` `optional` **calls**: readonly [`CallTraceType`](#calltracetype)\[]
Defined in: [src/primitives/CallTrace/CallTraceType.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L42)
Nested calls made by this call
##### error?
> `readonly` `optional` **error**: `string`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L38)
Error message if call failed
##### from
> `readonly` **from**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/CallTrace/CallTraceType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L24)
Caller address
##### gas
> `readonly` **gas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/CallTrace/CallTraceType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L30)
Gas provided to this call
##### gasUsed
> `readonly` **gasUsed**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/CallTrace/CallTraceType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L32)
Gas actually used by this call
##### input
> `readonly` **input**: `Uint8Array`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L34)
Input data (calldata or init code)
##### output
> `readonly` **output**: `Uint8Array`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L36)
Return data or deployed code
##### revertReason?
> `readonly` `optional` **revertReason**: `string`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L40)
Decoded revert reason (from Error(string) or Panic(uint256))
##### to?
> `readonly` `optional` **to**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/CallTrace/CallTraceType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L26)
Callee address (undefined for CREATE/CREATE2 before completion)
##### type
> `readonly` **type**: `"CALL"` | `"STATICCALL"` | `"DELEGATECALL"` | `"CALLCODE"` | `"CREATE"` | `"CREATE2"` | `"SELFDESTRUCT"`
Defined in: [src/primitives/CallTrace/CallTraceType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L15)
Call type
##### value?
> `readonly` `optional` **value**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/CallTrace/CallTraceType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/CallTraceType.ts#L28)
Call value in wei
## Functions
### \_flatten()
> **\_flatten**(`trace`): [`CallTraceType`](#calltracetype)\[]
Defined in: [src/primitives/CallTrace/flatten.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/flatten.js#L14)
Flattens a call tree into a linear list of all calls
Useful for analyzing all calls in execution order
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
Root call trace
#### Returns
[`CallTraceType`](#calltracetype)\[]
Flat array of all calls (including root)
#### Example
```javascript theme={null}
import { flatten } from './flatten.js';
const allCalls = flatten(rootTrace);
const failedCalls = allCalls.filter(call => call.error);
```
***
### \_from()
> **\_from**(`data`): [`CallTraceType`](#calltracetype)
Defined in: [src/primitives/CallTrace/from.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/from.js#L31)
Creates a CallTrace from raw data
#### Parameters
##### data
CallTrace data
###### calls?
readonly [`CallTraceType`](#calltracetype)\[]
Nested calls
###### error?
`string`
Error message
###### from
[`AddressType`](Address.mdx#addresstype)
Caller address
###### gas
[`Type`](Uint.mdx#type)
Gas provided
###### gasUsed
[`Type`](Uint.mdx#type)
Gas used
###### input
`Uint8Array`\<`ArrayBufferLike`>
Input data
###### output
`Uint8Array`\<`ArrayBufferLike`>
Output data
###### revertReason?
`string`
Decoded revert reason
###### to?
[`AddressType`](Address.mdx#addresstype)
Callee address
###### type
`"CALL"` | `"STATICCALL"` | `"DELEGATECALL"` | `"CALLCODE"` | `"CREATE"` | `"CREATE2"` | `"SELFDESTRUCT"`
Call type
###### value?
[`Type`](Uint.mdx#type)
Call value
#### Returns
[`CallTraceType`](#calltracetype)
CallTrace instance
#### Example
```javascript theme={null}
import { from } from './from.js';
const trace = from({
type: "CALL",
from: fromAddress,
to: toAddress,
gas: 100000n,
gasUsed: 50000n,
input: new Uint8Array(),
output: new Uint8Array()
});
```
***
### \_getCalls()
> **\_getCalls**(`trace`): readonly [`CallTraceType`](#calltracetype)\[]
Defined in: [src/primitives/CallTrace/getCalls.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/getCalls.js#L13)
Gets nested calls from a CallTrace
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
CallTrace to extract calls from
#### Returns
readonly [`CallTraceType`](#calltracetype)\[]
Nested calls (empty array if none)
#### Example
```javascript theme={null}
import { getCalls } from './getCalls.js';
const nestedCalls = getCalls(trace);
console.log(`${nestedCalls.length} nested calls`);
```
***
### \_hasError()
> **\_hasError**(`trace`): `boolean`
Defined in: [src/primitives/CallTrace/hasError.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/hasError.js#L14)
Checks if a CallTrace has an error
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
CallTrace to check
#### Returns
`boolean`
True if call failed
#### Example
```javascript theme={null}
import { hasError } from './hasError.js';
if (hasError(trace)) {
console.error(`Call failed: ${trace.error}`);
}
```
***
### flatten()
> **flatten**(`trace`): [`CallTraceType`](#calltracetype)\[]
Defined in: [src/primitives/CallTrace/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/index.ts#L73)
Flattens a call tree into a linear list
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
Root call trace
#### Returns
[`CallTraceType`](#calltracetype)\[]
Flat array of all calls
#### Example
```typescript theme={null}
import { CallTrace } from './primitives/CallTrace/index.js';
const allCalls = CallTrace.flatten(trace);
```
***
### from()
> **from**(`data`): [`CallTraceType`](#calltracetype)
Defined in: [src/primitives/CallTrace/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/index.ts#L26)
Creates a CallTrace from raw data
#### Parameters
##### data
`Omit`\<[`CallTraceType`](#calltracetype), `brand`>
CallTrace data
#### Returns
[`CallTraceType`](#calltracetype)
CallTrace instance
#### See
[https://voltaire.tevm.sh/primitives/call-trace](https://voltaire.tevm.sh/primitives/call-trace) for CallTrace documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import { CallTrace } from './primitives/CallTrace/index.js';
const trace = CallTrace.from({ type: "CALL", from, to, gas: 100000n, gasUsed: 50000n, input, output });
```
***
### getCalls()
> **getCalls**(`trace`): readonly [`CallTraceType`](#calltracetype)\[]
Defined in: [src/primitives/CallTrace/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/index.ts#L43)
Gets nested calls from a CallTrace
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
CallTrace to extract calls from
#### Returns
readonly [`CallTraceType`](#calltracetype)\[]
Nested calls
#### Example
```typescript theme={null}
import { CallTrace } from './primitives/CallTrace/index.js';
const calls = CallTrace.getCalls(trace);
```
***
### hasError()
> **hasError**(`trace`): `boolean`
Defined in: [src/primitives/CallTrace/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CallTrace/index.ts#L58)
Checks if a CallTrace has an error
#### Parameters
##### trace
[`CallTraceType`](#calltracetype)
CallTrace to check
#### Returns
`boolean`
True if call failed
#### Example
```typescript theme={null}
import { CallTrace } from './primitives/CallTrace/index.js';
if (CallTrace.hasError(trace)) console.error(trace.error);
```
# primitives/ChainHead
Source: https://voltaire.tevm.sh/generated-api/primitives/ChainHead
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ChainHead
# primitives/ChainHead
## Type Aliases
### ChainHeadType
> **ChainHeadType** = `object`
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L22)
Current chain head information
Represents the latest block at the tip of the blockchain.
Typically obtained from eth\_getBlockByNumber("latest").
#### Example
```typescript theme={null}
const chainHead: ChainHeadType = {
number: 18000000n,
hash: blockHash,
timestamp: 1699000000n,
difficulty: 0n, // Post-merge (PoS)
totalDifficulty: 58750003716598352816469n, // Pre-merge cumulative
};
```
#### Properties
##### difficulty?
> `readonly` `optional` **difficulty**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L41)
Block difficulty (0 post-merge)
##### hash
> `readonly` **hash**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L31)
Block hash
##### number
> `readonly` **number**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L26)
Block number
##### timestamp
> `readonly` **timestamp**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L36)
Block timestamp (Unix seconds)
##### totalDifficulty?
> `readonly` `optional` **totalDifficulty**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/ChainHead/ChainHeadType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/ChainHeadType.ts#L46)
Total difficulty from genesis to this block
## Variables
### ChainHead
> `const` **ChainHead**: `object`
Defined in: [src/primitives/ChainHead/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/index.ts#L9)
#### Type Declaration
##### from()
> **from**: (`value`) => [`ChainHeadType`](#chainheadtype) = `_from`
Create ChainHead from block data or RPC response
###### Parameters
###### value
Chain head data
###### difficulty?
`string` | `number` | `bigint`
###### hash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### number
`string` | `number` | `bigint`
###### timestamp
`string` | `number` | `bigint`
###### totalDifficulty?
`string` | `number` | `bigint`
###### Returns
[`ChainHeadType`](#chainheadtype)
ChainHead
###### Example
```typescript theme={null}
const head = ChainHead.from({
number: 18000000n,
hash: blockHash,
timestamp: 1699000000n,
});
```
## Functions
### from()
> **from**(`value`): [`ChainHeadType`](#chainheadtype)
Defined in: [src/primitives/ChainHead/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainHead/from.js#L16)
Create ChainHead from block data or RPC response
#### Parameters
##### value
Chain head data
###### difficulty?
`string` | `number` | `bigint`
###### hash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### number
`string` | `number` | `bigint`
###### timestamp
`string` | `number` | `bigint`
###### totalDifficulty?
`string` | `number` | `bigint`
#### Returns
[`ChainHeadType`](#chainheadtype)
ChainHead
#### Example
```typescript theme={null}
const head = ChainHead.from({
number: 18000000n,
hash: blockHash,
timestamp: 1699000000n,
});
```
# primitives/ChainId
Source: https://voltaire.tevm.sh/generated-api/primitives/ChainId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ChainId
# primitives/ChainId
## Type Aliases
### ChainIdType
> **ChainIdType** = `number` & `object`
Defined in: [src/primitives/ChainId/ChainIdType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/ChainIdType.ts#L7)
Branded ChainId type - prevents chain mixing bugs
Wraps a number representing an EIP-155 chain ID
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ChainId"`
## Variables
### ARBITRUM
> `const` **ARBITRUM**: `42161` = `42161`
Defined in: [src/primitives/ChainId/constants.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L7)
***
### BASE
> `const` **BASE**: `8453` = `8453`
Defined in: [src/primitives/ChainId/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L8)
***
### ChainId
> `const` **ChainId**: `object`
Defined in: [src/primitives/ChainId/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/index.ts#L42)
#### Type Declaration
##### equals()
> **equals**: (`chainId1`, `chainId2`) => `boolean`
###### Parameters
###### chainId1
`number`
###### chainId2
`number`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`ChainIdType`](#chainidtype)
Create ChainId from number
###### Parameters
###### value
`number`
Chain ID number
###### Returns
[`ChainIdType`](#chainidtype)
Branded chain ID
###### Throws
If value is not a non-negative integer
###### Example
```typescript theme={null}
const mainnet = ChainId.from(1);
const sepolia = ChainId.from(11155111);
```
##### isMainnet()
> **isMainnet**: (`chainId`) => `boolean`
###### Parameters
###### chainId
`number`
###### Returns
`boolean`
##### toNumber()
> **toNumber**: (`chainId`) => `number`
###### Parameters
###### chainId
`number`
###### Returns
`number`
***
### GOERLI
> `const` **GOERLI**: `5` = `5`
Defined in: [src/primitives/ChainId/constants.js:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L3)
***
### HOLESKY
> `const` **HOLESKY**: `17000` = `17000`
Defined in: [src/primitives/ChainId/constants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L5)
***
### MAINNET
> `const` **MAINNET**: `1` = `1`
Defined in: [src/primitives/ChainId/constants.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L2)
***
### OPTIMISM
> `const` **OPTIMISM**: `10` = `10`
Defined in: [src/primitives/ChainId/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L6)
***
### POLYGON
> `const` **POLYGON**: `137` = `137`
Defined in: [src/primitives/ChainId/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L9)
***
### SEPOLIA
> `const` **SEPOLIA**: `11155111` = `11155111`
Defined in: [src/primitives/ChainId/constants.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/constants.js#L4)
## Functions
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/ChainId/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/equals.js#L13)
Check if two chain IDs are equal
#### Parameters
##### this
[`ChainIdType`](#chainidtype)
##### other
[`ChainIdType`](#chainidtype)
Other chain ID
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const same = ChainId._equals.call(chainId1, chainId2);
```
***
### \_isMainnet()
> **\_isMainnet**(`this`): `boolean`
Defined in: [src/primitives/ChainId/isMainnet.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/isMainnet.js#L14)
Check if chain ID is Ethereum mainnet
#### Parameters
##### this
`number`
#### Returns
`boolean`
True if mainnet
#### Example
```typescript theme={null}
const isMain = ChainId._isMainnet.call(chainId);
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/ChainId/toNumber.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/toNumber.js#L12)
Convert ChainId to number
#### Parameters
##### this
`number`
#### Returns
`number`
Number
#### Example
```typescript theme={null}
const n = ChainId._toNumber.call(chainId);
```
***
### equals()
> **equals**(`chainId1`, `chainId2`): `boolean`
Defined in: [src/primitives/ChainId/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/index.ts#L30)
#### Parameters
##### chainId1
`number`
##### chainId2
`number`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`ChainIdType`](#chainidtype)
Defined in: [src/primitives/ChainId/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/from.js#L16)
Create ChainId from number
#### Parameters
##### value
`number`
Chain ID number
#### Returns
[`ChainIdType`](#chainidtype)
Branded chain ID
#### Throws
If value is not a non-negative integer
#### Example
```typescript theme={null}
const mainnet = ChainId.from(1);
const sepolia = ChainId.from(11155111);
```
***
### isMainnet()
> **isMainnet**(`chainId`): `boolean`
Defined in: [src/primitives/ChainId/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/index.ts#L34)
#### Parameters
##### chainId
`number`
#### Returns
`boolean`
***
### toNumber()
> **toNumber**(`chainId`): `number`
Defined in: [src/primitives/ChainId/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ChainId/index.ts#L26)
#### Parameters
##### chainId
`number`
#### Returns
`number`
# primitives/CompilerVersion
Source: https://voltaire.tevm.sh/generated-api/primitives/CompilerVersion
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/CompilerVersion
# primitives/CompilerVersion
## Type Aliases
### CompilerVersionType
> **CompilerVersionType** = `string` & `object`
Defined in: [src/primitives/CompilerVersion/CompilerVersionType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/CompilerVersionType.ts#L14)
Branded CompilerVersion type - prevents version confusion
Represents a Solidity or Vyper compiler version string
Format: "v0.8.20+commit.a1b2c3d4" or "0.8.20+commit.a1b2c3d4"
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"CompilerVersion"`
#### Example
```typescript theme={null}
const version: CompilerVersionType = "v0.8.20+commit.a1b2c3d4";
```
## Variables
### CompilerVersion
> `const` **CompilerVersion**: `object`
Defined in: [src/primitives/CompilerVersion/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L51)
#### Type Declaration
##### compare()
> **compare**: (`a`, `b`) => `number`
###### Parameters
###### a
`string`
###### b
`string`
###### Returns
`number`
##### from()
> **from**: (`value`) => [`CompilerVersionType`](#compilerversiontype)
Create CompilerVersion from string
###### Parameters
###### value
`string`
Version string (e.g., "v0.8.20+commit.a1b2c3d4")
###### Returns
[`CompilerVersionType`](#compilerversiontype)
CompilerVersion
###### Throws
If version format is invalid
###### Example
```typescript theme={null}
const version = CompilerVersion.from("v0.8.20+commit.a1b2c3d4");
const version2 = CompilerVersion.from("0.8.20"); // Also valid
```
##### getMajor()
> **getMajor**: (`version`) => `number`
###### Parameters
###### version
`string`
###### Returns
`number`
##### getMinor()
> **getMinor**: (`version`) => `number`
###### Parameters
###### version
`string`
###### Returns
`number`
##### getPatch()
> **getPatch**: (`version`) => `number`
###### Parameters
###### version
`string`
###### Returns
`number`
##### isCompatible()
> **isCompatible**: (`version`, `range`) => `boolean`
###### Parameters
###### version
`string`
###### range
`string`
###### Returns
`boolean`
##### parse()
> **parse**: (`version`) => `object`
###### Parameters
###### version
`string`
###### Returns
`object`
###### commit?
> `optional` **commit**: `string`
###### major
> **major**: `number`
###### minor
> **minor**: `number`
###### patch
> **patch**: `number`
###### prerelease?
> `optional` **prerelease**: `string`
## Functions
### \_compare()
> **\_compare**(`a`, `b`): `number`
Defined in: [src/primitives/CompilerVersion/compare.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/compare.js#L16)
Compare two compiler versions
#### Parameters
##### a
[`CompilerVersionType`](#compilerversiontype)
First version
##### b
[`CompilerVersionType`](#compilerversiontype)
Second version
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### Example
```typescript theme={null}
const result = CompilerVersion.compare("v0.8.20", "v0.8.19");
console.log(result); // 1 (0.8.20 > 0.8.19)
```
***
### \_getMajor()
> **\_getMajor**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/getMajor.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/getMajor.js#L15)
Get major version number
#### Parameters
##### version
[`CompilerVersionType`](#compilerversiontype)
Version to extract from
#### Returns
`number`
Major version
#### Example
```typescript theme={null}
const major = CompilerVersion.getMajor("v0.8.20");
console.log(major); // 0
```
***
### \_getMinor()
> **\_getMinor**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/getMinor.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/getMinor.js#L15)
Get minor version number
#### Parameters
##### version
[`CompilerVersionType`](#compilerversiontype)
Version to extract from
#### Returns
`number`
Minor version
#### Example
```typescript theme={null}
const minor = CompilerVersion.getMinor("v0.8.20");
console.log(minor); // 8
```
***
### \_getPatch()
> **\_getPatch**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/getPatch.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/getPatch.js#L15)
Get patch version number
#### Parameters
##### version
[`CompilerVersionType`](#compilerversiontype)
Version to extract from
#### Returns
`number`
Patch version
#### Example
```typescript theme={null}
const patch = CompilerVersion.getPatch("v0.8.20");
console.log(patch); // 20
```
***
### \_isCompatible()
> **\_isCompatible**(`version`, `range`): `boolean`
Defined in: [src/primitives/CompilerVersion/isCompatible.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/isCompatible.js#L23)
Check if version is compatible with a semver range
Supports basic semver ranges:
* "^0.8.0" - Compatible with 0.8.x (same major.minor)
* "\~0.8.20" - Compatible with 0.8.20-0.8.x (same major.minor, patch >= specified)
* ">=0.8.0" - Greater than or equal
* "0.8.20" - Exact match
#### Parameters
##### version
[`CompilerVersionType`](#compilerversiontype)
Version to check
##### range
`string`
Semver range
#### Returns
`boolean`
True if compatible
#### Example
```typescript theme={null}
const compatible = CompilerVersion.isCompatible("v0.8.20", "^0.8.0");
console.log(compatible); // true
```
***
### \_parse()
> **\_parse**(`version`): `object`
Defined in: [src/primitives/CompilerVersion/parse.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/parse.js#L16)
Parse compiler version into components
#### Parameters
##### version
[`CompilerVersionType`](#compilerversiontype)
Version to parse
#### Returns
`object`
##### commit?
> `optional` **commit**: `string`
##### major
> **major**: `number`
##### minor
> **minor**: `number`
##### patch
> **patch**: `number`
##### prerelease?
> `optional` **prerelease**: `string`
#### Example
```typescript theme={null}
const parsed = CompilerVersion.parse("v0.8.20+commit.a1b2c3d4");
console.log(parsed.major); // 0
console.log(parsed.minor); // 8
console.log(parsed.patch); // 20
console.log(parsed.commit); // "a1b2c3d4"
```
***
### compare()
> **compare**(`a`, `b`): `number`
Defined in: [src/primitives/CompilerVersion/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L27)
#### Parameters
##### a
`string`
##### b
`string`
#### Returns
`number`
***
### from()
> **from**(`value`): [`CompilerVersionType`](#compilerversiontype)
Defined in: [src/primitives/CompilerVersion/from.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/from.js#L14)
Create CompilerVersion from string
#### Parameters
##### value
`string`
Version string (e.g., "v0.8.20+commit.a1b2c3d4")
#### Returns
[`CompilerVersionType`](#compilerversiontype)
CompilerVersion
#### Throws
If version format is invalid
#### Example
```typescript theme={null}
const version = CompilerVersion.from("v0.8.20+commit.a1b2c3d4");
const version2 = CompilerVersion.from("0.8.20"); // Also valid
```
***
### getMajor()
> **getMajor**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L31)
#### Parameters
##### version
`string`
#### Returns
`number`
***
### getMinor()
> **getMinor**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L35)
#### Parameters
##### version
`string`
#### Returns
`number`
***
### getPatch()
> **getPatch**(`version`): `number`
Defined in: [src/primitives/CompilerVersion/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L39)
#### Parameters
##### version
`string`
#### Returns
`number`
***
### isCompatible()
> **isCompatible**(`version`, `range`): `boolean`
Defined in: [src/primitives/CompilerVersion/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L43)
#### Parameters
##### version
`string`
##### range
`string`
#### Returns
`boolean`
***
### parse()
> **parse**(`version`): `object`
Defined in: [src/primitives/CompilerVersion/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/CompilerVersion/index.ts#L17)
#### Parameters
##### version
`string`
#### Returns
`object`
##### commit?
> `optional` **commit**: `string`
##### major
> **major**: `number`
##### minor
> **minor**: `number`
##### patch
> **patch**: `number`
##### prerelease?
> `optional` **prerelease**: `string`
# primitives/ContractCode
Source: https://voltaire.tevm.sh/generated-api/primitives/ContractCode
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ContractCode
# primitives/ContractCode
## Type Aliases
### ContractCodeType
> **ContractCodeType** = `Uint8Array` & `object`
Defined in: [src/primitives/ContractCode/ContractCodeType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/ContractCodeType.ts#L7)
Branded ContractCode type
Full deployed contract bytecode including metadata
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ContractCode"`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ContractCode/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/equals.js#L15)
Check if two ContractCode instances are equal
#### Parameters
##### a
[`ContractCodeType`](#contractcodetype)
First ContractCode
##### b
[`ContractCodeType`](#contractcodetype)
Second ContractCode
#### Returns
`boolean`
true if equal
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const code1 = ContractCode.from("0x6001");
const code2 = ContractCode.from("0x6001");
ContractCode._equals(code1, code2); // true
```
***
### \_extractRuntime()
> **\_extractRuntime**(`code`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/ContractCode/extractRuntime.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/extractRuntime.js#L18)
Extract runtime code from contract code
Strips metadata to return pure runtime bytecode.
Alias for stripMetadata for semantic clarity.
#### Parameters
##### code
[`ContractCodeType`](#contractcodetype)
ContractCode
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
RuntimeCode
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const contract = ContractCode.from("0x6001600155a264...0033");
const runtime = ContractCode._extractRuntime(contract);
```
***
### \_hasMetadata()
> **\_hasMetadata**(`code`): `boolean`
Defined in: [src/primitives/ContractCode/hasMetadata.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/hasMetadata.js#L16)
Check if contract code contains CBOR metadata
Solidity compiler includes CBOR-encoded metadata at the end of deployed bytecode.
The metadata section starts with 0xa2 (CBOR map) and ends with 0x00 0x33 (length).
#### Parameters
##### code
[`ContractCodeType`](#contractcodetype)
ContractCode to check
#### Returns
`boolean`
true if metadata is present
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const code = ContractCode.from("0x6001600155a264...0033");
ContractCode._hasMetadata(code); // true
```
***
### \_stripMetadata()
> **\_stripMetadata**(`code`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/ContractCode/stripMetadata.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/stripMetadata.js#L17)
Strip CBOR metadata from contract code
Returns runtime code without the Solidity compiler metadata.
#### Parameters
##### code
[`ContractCodeType`](#contractcodetype)
ContractCode with metadata
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
RuntimeCode without metadata
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const withMeta = ContractCode.from("0x6001600155a264...0033");
const runtime = ContractCode._stripMetadata(withMeta);
```
***
### \_toHex()
> **\_toHex**(`data`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/ContractCode/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/toHex.js#L15)
Convert ContractCode to hex string
#### Parameters
##### data
[`ContractCodeType`](#contractcodetype)
ContractCode
#### Returns
[`HexType`](Hex.mdx#hextype)
Hex string
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const code = ContractCode.from("0x6001600155");
const hex = ContractCode._toHex(code); // "0x6001600155"
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ContractCode/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/index.ts#L19)
#### Parameters
##### a
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
##### b
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
#### Returns
`boolean`
***
### extractRuntime()
> **extractRuntime**(`value`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/ContractCode/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/index.ts#L44)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
***
### from()
> **from**(`value`): [`ContractCodeType`](#contractcodetype)
Defined in: [src/primitives/ContractCode/from.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/from.js#L18)
Create ContractCode from various input types
#### Parameters
##### value
Hex string or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`ContractCodeType`](#contractcodetype)
ContractCode
#### See
[https://voltaire.tevm.sh/primitives/contract-code](https://voltaire.tevm.sh/primitives/contract-code) for ContractCode documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const code1 = ContractCode.from("0x6001600155");
const code2 = ContractCode.from(new Uint8Array([0x60, 0x01, 0x60, 0x01, 0x55]));
```
***
### fromHex()
> **fromHex**(`hex`): [`ContractCodeType`](#contractcodetype)
Defined in: [src/primitives/ContractCode/fromHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/fromHex.js#L15)
Create ContractCode from hex string
#### Parameters
##### hex
`string`
Hex string
#### Returns
[`ContractCodeType`](#contractcodetype)
ContractCode
#### Throws
If hex string is invalid
#### Example
```javascript theme={null}
import * as ContractCode from './primitives/ContractCode/index.js';
const code = ContractCode.fromHex("0x6001600155");
```
***
### hasMetadata()
> **hasMetadata**(`value`): `boolean`
Defined in: [src/primitives/ContractCode/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/index.ts#L32)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
#### Returns
`boolean`
***
### stripMetadata()
> **stripMetadata**(`value`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/ContractCode/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/index.ts#L38)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
***
### toHex()
> **toHex**(`value`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/ContractCode/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractCode/index.ts#L26)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ContractCodeType`](#contractcodetype)
#### Returns
[`HexType`](Hex.mdx#hextype)
# primitives/ContractResult
Source: https://voltaire.tevm.sh/generated-api/primitives/ContractResult
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ContractResult
# primitives/ContractResult
## Classes
### ContractRevertError
Defined in: [src/primitives/ContractResult/errors.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/errors.ts#L7)
Error thrown when unwrapping a failed contract result
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new ContractRevertError**(`message`, `revertReason`): [`ContractRevertError`](#contractreverterror)
Defined in: [src/primitives/ContractResult/errors.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/errors.ts#L10)
###### Parameters
###### message
`string`
###### revertReason
[`RevertReasonType`](RevertReason.mdx#revertreasontype)
###### Returns
[`ContractRevertError`](#contractreverterror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
##### revertReason
> `readonly` **revertReason**: [`RevertReasonType`](RevertReason.mdx#revertreasontype)
Defined in: [src/primitives/ContractResult/errors.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/errors.ts#L8)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Type Aliases
### ContractResultType
> **ContractResultType** = [`SuccessResult`](#successresult) | [`FailureResult`](#failureresult)
Defined in: [src/primitives/ContractResult/ContractResultType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L31)
ContractResult union type
***
### FailureResult
> **FailureResult** = `object`
Defined in: [src/primitives/ContractResult/ContractResultType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L23)
Failed contract call
#### Properties
##### revertReason
> `readonly` **revertReason**: [`RevertReasonType`](RevertReason.mdx#revertreasontype)
Defined in: [src/primitives/ContractResult/ContractResultType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L25)
##### success
> `readonly` **success**: `false`
Defined in: [src/primitives/ContractResult/ContractResultType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L24)
***
### SuccessResult
> **SuccessResult** = `object`
Defined in: [src/primitives/ContractResult/ContractResultType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L15)
Successful contract call
#### Properties
##### data
> `readonly` **data**: [`ReturnDataType`](ReturnData.mdx#returndatatype)
Defined in: [src/primitives/ContractResult/ContractResultType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L17)
##### success
> `readonly` **success**: `true`
Defined in: [src/primitives/ContractResult/ContractResultType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/ContractResultType.ts#L16)
## Functions
### \_failure()
> **\_failure**(`revertReason`): [`FailureResult`](#failureresult)
Defined in: [src/primitives/ContractResult/failure.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/failure.js#L12)
Create failed ContractResult
#### Parameters
##### revertReason
[`RevertReasonType`](RevertReason.mdx#revertreasontype)
Revert reason
#### Returns
[`FailureResult`](#failureresult)
Failure result
#### Example
```typescript theme={null}
const result = ContractResult.failure(revertReason);
```
***
### \_from()
> **\_from**(`isSuccess`, `data`): [`ContractResultType`](#contractresulttype)
Defined in: [src/primitives/ContractResult/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/from.js#L19)
Create ContractResult from return data and success flag
#### Parameters
##### isSuccess
`boolean`
Whether call succeeded
##### data
Return data
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`ContractResultType`](#contractresulttype)
Contract result
#### Example
```typescript theme={null}
const result = ContractResult.from(true, "0x0000...");
const failResult = ContractResult.from(false, "0x08c379a0...");
```
***
### \_isFailure()
> **\_isFailure**(`result`): `result is FailureResult`
Defined in: [src/primitives/ContractResult/isFailure.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/isFailure.js#L14)
Check if result is failure
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
Contract result
#### Returns
`result is FailureResult`
True if failure
#### Example
```typescript theme={null}
if (ContractResult.isFailure(result)) {
console.log(result.revertReason);
}
```
***
### \_isSuccess()
> **\_isSuccess**(`result`): `result is SuccessResult`
Defined in: [src/primitives/ContractResult/isSuccess.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/isSuccess.js#L14)
Check if result is successful
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
Contract result
#### Returns
`result is SuccessResult`
True if success
#### Example
```typescript theme={null}
if (ContractResult.isSuccess(result)) {
console.log(result.data);
}
```
***
### \_success()
> **\_success**(`data`): [`SuccessResult`](#successresult)
Defined in: [src/primitives/ContractResult/success.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/success.js#L12)
Create successful ContractResult
#### Parameters
##### data
[`ReturnDataType`](ReturnData.mdx#returndatatype)
Return data
#### Returns
[`SuccessResult`](#successresult)
Success result
#### Example
```typescript theme={null}
const result = ContractResult.success(returnData);
```
***
### \_unwrap()
> **\_unwrap**(`result`): [`ReturnDataType`](ReturnData.mdx#returndatatype)
Defined in: [src/primitives/ContractResult/unwrap.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/unwrap.js#L20)
Unwrap successful result or throw on failure
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
Contract result
#### Returns
[`ReturnDataType`](ReturnData.mdx#returndatatype)
Return data
#### Throws
If result is failure
#### Example
```typescript theme={null}
try {
const data = ContractResult.unwrap(result);
} catch (error) {
console.log(error.revertReason);
}
```
***
### \_unwrapOr()
> **\_unwrapOr**(`result`, `defaultValue`): [`ReturnDataType`](ReturnData.mdx#returndatatype)
Defined in: [src/primitives/ContractResult/unwrapOr.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/unwrapOr.js#L13)
Unwrap result or return default value on failure
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
Contract result
##### defaultValue
[`ReturnDataType`](ReturnData.mdx#returndatatype)
Default value
#### Returns
[`ReturnDataType`](ReturnData.mdx#returndatatype)
Return data or default
#### Example
```typescript theme={null}
const data = ContractResult.unwrapOr(result, ReturnData.fromHex("0x"));
```
***
### failure()
> **failure**(`revertReason`): [`FailureResult`](#failureresult)
Defined in: [src/primitives/ContractResult/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L43)
Create failed ContractResult
#### Parameters
##### revertReason
[`RevertReasonType`](RevertReason.mdx#revertreasontype)
#### Returns
[`FailureResult`](#failureresult)
***
### from()
> **from**(`isSuccess`, `data`): [`ContractResultType`](#contractresulttype)
Defined in: [src/primitives/ContractResult/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L26)
Create ContractResult from return data and success flag
#### Parameters
##### isSuccess
`boolean`
##### data
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`ContractResultType`](#contractresulttype)
***
### isFailure()
> **isFailure**(`result`): `result is FailureResult`
Defined in: [src/primitives/ContractResult/index.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L57)
Check if result is failure (type guard)
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
#### Returns
`result is FailureResult`
***
### isSuccess()
> **isSuccess**(`result`): `result is SuccessResult`
Defined in: [src/primitives/ContractResult/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L50)
Check if result is successful (type guard)
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
#### Returns
`result is SuccessResult`
***
### success()
> **success**(`data`): [`SuccessResult`](#successresult)
Defined in: [src/primitives/ContractResult/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L36)
Create successful ContractResult
#### Parameters
##### data
[`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`SuccessResult`](#successresult)
***
### unwrap()
> **unwrap**(`result`): [`ReturnDataType`](ReturnData.mdx#returndatatype)
Defined in: [src/primitives/ContractResult/index.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L64)
Unwrap successful result or throw on failure
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
#### Returns
[`ReturnDataType`](ReturnData.mdx#returndatatype)
***
### unwrapOr()
> **unwrapOr**(`result`, `defaultValue`): [`ReturnDataType`](ReturnData.mdx#returndatatype)
Defined in: [src/primitives/ContractResult/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractResult/index.ts#L71)
Unwrap result or return default value on failure
#### Parameters
##### result
[`ContractResultType`](#contractresulttype)
##### defaultValue
[`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`ReturnDataType`](ReturnData.mdx#returndatatype)
# primitives/ContractSignature
Source: https://voltaire.tevm.sh/generated-api/primitives/ContractSignature
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ContractSignature
# primitives/ContractSignature
## Classes
### ContractCallError
Defined in: [src/primitives/ContractSignature/errors.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L17)
Error thrown when contract call for signature validation fails
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new ContractCallError**(`message`, `context?`): [`ContractCallError`](#contractcallerror)
Defined in: [src/primitives/ContractSignature/errors.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L18)
###### Parameters
###### message
`string`
###### context?
`unknown`
###### Returns
[`ContractCallError`](#contractcallerror)
###### Overrides
`Error.constructor`
#### Properties
##### context?
> `optional` **context**: `unknown`
Defined in: [src/primitives/ContractSignature/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L24)
***
### ContractSignatureError
Defined in: [src/primitives/ContractSignature/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L4)
Error thrown when EIP-1271 signature validation fails
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new ContractSignatureError**(`message`, `context?`): [`ContractSignatureError`](#contractsignatureerror)
Defined in: [src/primitives/ContractSignature/errors.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L5)
###### Parameters
###### message
`string`
###### context?
`unknown`
###### Returns
[`ContractSignatureError`](#contractsignatureerror)
###### Overrides
`Error.constructor`
#### Properties
##### context?
> `optional` **context**: `unknown`
Defined in: [src/primitives/ContractSignature/errors.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/errors.ts#L11)
## Variables
### EIP1271\_MAGIC\_VALUE
> `const` **EIP1271\_MAGIC\_VALUE**: `"0x1626ba7e"` = `"0x1626ba7e"`
Defined in: [src/primitives/ContractSignature/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/constants.js#L11)
Magic value returned by isValidSignature for valid signatures
bytes4(keccak256("isValidSignature(bytes32,bytes)"))
***
### IS\_VALID\_SIGNATURE\_SELECTOR
> `const` **IS\_VALID\_SIGNATURE\_SELECTOR**: `"0x1626ba7e"` = `"0x1626ba7e"`
Defined in: [src/primitives/ContractSignature/constants.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/constants.js#L16)
Function selector for isValidSignature(bytes32,bytes)
## Functions
### isValidSignature()
> **isValidSignature**(`provider`, `contractAddress`, `hash`, `signature`): `Promise`\<`boolean`>
Defined in: [src/primitives/ContractSignature/isValidSignature.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/isValidSignature.js#L32)
Check if a contract signature is valid via EIP-1271
Calls the contract's isValidSignature(bytes32,bytes) method and checks
if it returns the magic value 0x1626ba7e.
#### Parameters
##### provider
JSON-RPC provider
###### request
(`method`, `params`) => `Promise`\<`unknown`>
JSON-RPC request method
##### contractAddress
Contract address to call
`string` | [`AddressType`](Address.mdx#addresstype)
##### hash
Message hash (bytes32)
`Uint8Array`\<`ArrayBufferLike`> | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### signature
`Uint8Array`\<`ArrayBufferLike`>
Signature bytes
#### Returns
`Promise`\<`boolean`>
True if signature is valid
#### See
[https://eips.ethereum.org/EIPS/eip-1271](https://eips.ethereum.org/EIPS/eip-1271)
#### Throws
If the contract call fails
#### Example
```javascript theme={null}
import { isValidSignature } from './primitives/ContractSignature/isValidSignature.js';
const isValid = await isValidSignature(
provider,
'0x1234...', // contract address
messageHash,
signatureBytes
);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`provider`, `address`, `hash`, `signature`) => `Promise`\<`boolean`>
Defined in: [src/primitives/ContractSignature/verifySignature.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ContractSignature/verifySignature.js#L13)
Factory: Create unified signature verification for EOA and contract accounts
#### Parameters
##### deps
Crypto dependencies
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
Address derivation from public key
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
secp256k1 public key recovery
#### Returns
> (`provider`, `address`, `hash`, `signature`): `Promise`\<`boolean`>
##### Parameters
###### provider
###### request
(`method`, `params`) => `Promise`\<`unknown`>
###### address
`string` | [`AddressType`](Address.mdx#addresstype)
###### hash
`Uint8Array`\<`ArrayBufferLike`> | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### signature
`Uint8Array`\<`ArrayBufferLike`> | \{ `r`: `Uint8Array`; `s`: `Uint8Array`; `v`: `number`; }
##### Returns
`Promise`\<`boolean`>
# primitives/DecodedData
Source: https://voltaire.tevm.sh/generated-api/primitives/DecodedData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/DecodedData
# primitives/DecodedData
## Type Aliases
### DecodedDataType
> **DecodedDataType**\<`T`> = `object`
Defined in: [src/primitives/DecodedData/DecodedDataType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DecodedData/DecodedDataType.ts#L9)
DecodedData - Generic decoded structure from ABI-encoded data
Represents decoded values with their corresponding ABI types.
Useful for working with ABI-encoded data in a type-safe manner.
#### Type Parameters
##### T
`T` = `unknown`
The type of the decoded values
#### Properties
##### types
> `readonly` **types**: readonly `string`\[]
Defined in: [src/primitives/DecodedData/DecodedDataType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DecodedData/DecodedDataType.ts#L11)
##### values
> `readonly` **values**: `T`
Defined in: [src/primitives/DecodedData/DecodedDataType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DecodedData/DecodedDataType.ts#L10)
## Functions
### \_from()
> **\_from**\<`T`>(`values`, `types`): [`DecodedDataType`](#decodeddatatype)\<`T`>
Defined in: [src/primitives/DecodedData/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DecodedData/from.js#L17)
Create DecodedData from values and types
#### Type Parameters
##### T
`T`
#### Parameters
##### values
`T`
Decoded values
##### types
readonly `string`\[]
ABI types
#### Returns
[`DecodedDataType`](#decodeddatatype)\<`T`>
DecodedData
#### Example
```typescript theme={null}
const data = DecodedData.from(
{ amount: 100n, recipient: "0x..." },
["uint256", "address"]
);
```
***
### from()
> **from**\<`T`>(`values`, `types`): [`DecodedDataType`](#decodeddatatype)\<`T`>
Defined in: [src/primitives/DecodedData/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DecodedData/index.ts#L9)
Create DecodedData from values and types
#### Type Parameters
##### T
`T`
#### Parameters
##### values
`T`
##### types
readonly `string`\[]
#### Returns
[`DecodedDataType`](#decodeddatatype)\<`T`>
# primitives/Domain
Source: https://voltaire.tevm.sh/generated-api/primitives/Domain
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Domain
# primitives/Domain
## Classes
### InvalidDomainError
Defined in: [src/primitives/Domain/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/errors.js#L4)
Error thrown when Domain is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidDomainError**(`message`, `context?`): [`InvalidDomainError`](#invaliddomainerror)
Defined in: [src/primitives/Domain/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/errors.js#L9)
###### Parameters
###### message
`string`
###### context?
`any`
###### Returns
[`InvalidDomainError`](#invaliddomainerror)
###### Overrides
`Error.constructor`
#### Properties
##### context
> **context**: `any`
Defined in: [src/primitives/Domain/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/Domain/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### DomainType
> **DomainType** = `object`
Defined in: [src/primitives/Domain/DomainType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L19)
EIP-712 Domain Separator structure
Used to create domain-specific signatures for dApps
At least one field must be defined
#### Properties
##### chainId?
> `readonly` `optional` **chainId**: [`ChainIdType`](ChainId.mdx#chainidtype)
Defined in: [src/primitives/Domain/DomainType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L22)
##### name?
> `readonly` `optional` **name**: `string`
Defined in: [src/primitives/Domain/DomainType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L20)
##### salt?
> `readonly` `optional` **salt**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Domain/DomainType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L24)
##### verifyingContract?
> `readonly` `optional` **verifyingContract**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Domain/DomainType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L23)
##### version?
> `readonly` `optional` **version**: `string`
Defined in: [src/primitives/Domain/DomainType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/DomainType.ts#L21)
***
### ERC5267Response
> **ERC5267Response** = `object`
Defined in: [src/primitives/Domain/ERC5267Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L11)
ERC-5267 eip712Domain() return type
Standardized format for returning EIP-712 domain parameters
from smart contracts implementing ERC-5267.
#### See
[https://eips.ethereum.org/EIPS/eip-5267](https://eips.ethereum.org/EIPS/eip-5267)
#### Properties
##### chainId
> `readonly` **chainId**: `bigint`
Defined in: [src/primitives/Domain/ERC5267Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L15)
##### extensions
> `readonly` **extensions**: readonly `bigint`\[]
Defined in: [src/primitives/Domain/ERC5267Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L18)
##### fields
> `readonly` **fields**: `Uint8Array`
Defined in: [src/primitives/Domain/ERC5267Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L12)
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/Domain/ERC5267Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L13)
##### salt
> `readonly` **salt**: `Uint8Array`
Defined in: [src/primitives/Domain/ERC5267Type.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L17)
##### verifyingContract
> `readonly` **verifyingContract**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Domain/ERC5267Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L16)
##### version
> `readonly` **version**: `string`
Defined in: [src/primitives/Domain/ERC5267Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L14)
## Variables
### ERC5267\_FIELDS
> `const` **ERC5267\_FIELDS**: `object`
Defined in: [src/primitives/Domain/ERC5267Type.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/ERC5267Type.ts#L32)
Field bitmap positions (ERC-5267 spec)
Each bit indicates presence of corresponding field:
* 0x01: name
* 0x02: version
* 0x04: chainId
* 0x08: verifyingContract
* 0x10: salt
* 0x20: extensions (reserved for future use)
#### Type Declaration
##### CHAIN\_ID
> `readonly` **CHAIN\_ID**: `4` = `0x04`
##### EXTENSIONS
> `readonly` **EXTENSIONS**: `32` = `0x20`
##### NAME
> `readonly` **NAME**: `1` = `0x01`
##### SALT
> `readonly` **SALT**: `16` = `0x10`
##### VERIFYING\_CONTRACT
> `readonly` **VERIFYING\_CONTRACT**: `8` = `0x08`
##### VERSION
> `readonly` **VERSION**: `2` = `0x02`
## Functions
### \_encodeData()
> **\_encodeData**(`primaryType`, `data`, `types`, `crypto`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Domain/encodeData.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/encodeData.js#L21)
Encode EIP-712 data structure
encodeData(primaryType, data, types) = encodeType(primaryType, types) || encodeValue(data)
#### Parameters
##### primaryType
`string`
Primary type name
##### data
`any`
Data object
##### types
`Record`\<`string`, readonly `EIP712Field`\[]>
Type definitions
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded data
***
### \_encodeType()
> **\_encodeType**(`primaryType`, `types`): `string`
Defined in: [src/primitives/Domain/encodeType.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/encodeType.js#L15)
Encode EIP-712 type definition
Example: "Mail(Person from,Person to,string contents)Person(string name,address wallet)"
#### Parameters
##### primaryType
`string`
Primary type name
##### types
`Record`\<`string`, readonly `EIP712Field`\[]>
Type definitions
#### Returns
`string`
Encoded type string
***
### \_encodeValue()
> **\_encodeValue**(`type`, `value`, `types`, `crypto`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Domain/encodeValue.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/encodeValue.js#L20)
Encode EIP-712 value according to type
#### Parameters
##### type
`string`
Field type
##### value
`any`
Field value
##### types
`Record`\<`string`, readonly `EIP712Field`\[]>
Type definitions
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded value (32 bytes)
***
### \_from()
> **\_from**(`domain`): [`DomainType`](#domaintype)
Defined in: [src/primitives/Domain/from.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/from.js#L28)
Create Domain from object
#### Parameters
##### domain
Domain object
###### chainId?
`number` | [`ChainIdType`](ChainId.mdx#chainidtype)
EIP-155 chain ID
###### name?
`string`
dApp name
###### salt?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Salt for disambiguation
###### verifyingContract?
`string` | [`AddressType`](Address.mdx#addresstype)
Contract address
###### version?
`string`
Domain version
#### Returns
[`DomainType`](#domaintype)
Domain
#### Throws
If domain has no fields
#### Example
```javascript theme={null}
import * as Domain from './primitives/Domain/index.js';
const domain = Domain.from({
name: 'MyDApp',
version: '1',
chainId: 1,
verifyingContract: '0x123...'
});
```
***
### \_getEIP712DomainType()
> **\_getEIP712DomainType**(`domain`): `object`\[]
Defined in: [src/primitives/Domain/getEIP712DomainType.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/getEIP712DomainType.js#L7)
Get EIP712Domain type definition based on domain fields present
#### Parameters
##### domain
[`DomainType`](#domaintype)
Domain
#### Returns
`object`\[]
Type definition
***
### \_getFieldsBitmap()
> **\_getFieldsBitmap**(`domain`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Domain/getFieldsBitmap.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/getFieldsBitmap.js#L26)
Calculate ERC-5267 field bitmap
Returns 1-byte value where each bit indicates presence of a field:
* 0x01: name
* 0x02: version
* 0x04: chainId
* 0x08: verifyingContract
* 0x10: salt
* 0x20: extensions
#### Parameters
##### domain
[`DomainType`](#domaintype)
EIP-712 domain
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
* 1-byte bitmap
#### See
[https://eips.ethereum.org/EIPS/eip-5267](https://eips.ethereum.org/EIPS/eip-5267)
#### Example
```javascript theme={null}
const domain = { name: "Test", version: "1", chainId: 1n };
const bitmap = getFieldsBitmap(domain);
// bitmap[0] === 0x07 (name + version + chainId bits set)
```
***
### \_hashType()
> **\_hashType**(`primaryType`, `types`, `crypto`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Domain/hashType.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/hashType.js#L14)
Hash EIP-712 type definition
typeHash = keccak256(encodeType(primaryType, types))
#### Parameters
##### primaryType
`string`
Primary type name
##### types
`Record`\<`string`, readonly `EIP712Field`\[]>
Type definitions
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Type hash (32 bytes)
***
### \_toErc5267Response()
> **\_toErc5267Response**(`domain`): [`ERC5267Response`](#erc5267response)
Defined in: [src/primitives/Domain/toErc5267Response.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/toErc5267Response.js#L37)
Convert Domain to ERC-5267 eip712Domain() response format
Calculates field bitmap based on which domain fields are present,
then returns standardized tuple format. Missing fields are filled
with appropriate default values per ERC-5267 spec.
#### Parameters
##### domain
[`DomainType`](#domaintype)
EIP-712 domain
#### Returns
[`ERC5267Response`](#erc5267response)
* ERC-5267 formatted response
#### See
[https://eips.ethereum.org/EIPS/eip-5267](https://eips.ethereum.org/EIPS/eip-5267)
#### Example
```javascript theme={null}
import * as Domain from './primitives/Domain/index.js';
const domain = Domain.from({
name: "MyContract",
version: "1.0.0",
chainId: 1,
verifyingContract: "0x1234567890123456789012345678901234567890"
});
const response = Domain.toErc5267Response(domain);
// response.fields[0] === 0x0f (name + version + chainId + verifyingContract)
// response.name === "MyContract"
// response.version === "1.0.0"
// response.chainId === 1n
// response.verifyingContract === domain.verifyingContract
// response.salt === new Uint8Array(32) (all zeros)
// response.extensions === []
```
***
### \_toHash()
> **\_toHash**(`domain`, `crypto`): [`DomainSeparatorType`](DomainSeparator.mdx#domainseparatortype)
Defined in: [src/primitives/Domain/toHash.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/toHash.js#L18)
Compute EIP-712 domain separator hash
#### Parameters
##### domain
[`DomainType`](#domaintype)
Domain
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
[`DomainSeparatorType`](DomainSeparator.mdx#domainseparatortype)
Domain separator hash
#### Example
```javascript theme={null}
import { keccak256 } from './crypto/Keccak256/index.js';
const domainSep = Domain.toHash(domain, { keccak256 });
```
***
### encodeData()
> **encodeData**(`primaryType`, `data`, `types`, `crypto`): `Uint8Array`
Defined in: [src/primitives/Domain/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L46)
#### Parameters
##### primaryType
`string`
##### data
`any`
##### types
`Record`\<`string`, readonly `object`\[]>
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
`Uint8Array`
***
### encodeType()
> **encodeType**(`primaryType`, `types`): `string`
Defined in: [src/primitives/Domain/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L61)
#### Parameters
##### primaryType
`string`
##### types
`Record`\<`string`, readonly `object`\[]>
#### Returns
`string`
***
### encodeValue()
> **encodeValue**(`type`, `value`, `types`, `crypto`): `Uint8Array`
Defined in: [src/primitives/Domain/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L71)
#### Parameters
##### type
`string`
##### value
`any`
##### types
`Record`\<`string`, readonly `object`\[]>
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
`Uint8Array`
***
### from()
> **from**(`domain`): [`DomainType`](#domaintype)
Defined in: [src/primitives/Domain/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L27)
#### Parameters
##### domain
###### chainId?
`number` | [`ChainIdType`](ChainId.mdx#chainidtype)
###### name?
`string`
###### salt?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### verifyingContract?
`string` | [`AddressType`](Address.mdx#addresstype)
###### version?
`string`
#### Returns
[`DomainType`](#domaintype)
***
### getEIP712DomainType()
> **getEIP712DomainType**(`domain`): `object`\[]
Defined in: [src/primitives/Domain/index.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L99)
#### Parameters
##### domain
[`DomainType`](#domaintype)
#### Returns
`object`\[]
***
### getFieldsBitmap()
> **getFieldsBitmap**(`domain`): `Uint8Array`
Defined in: [src/primitives/Domain/index.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L105)
#### Parameters
##### domain
[`DomainType`](#domaintype)
#### Returns
`Uint8Array`
***
### hashType()
> **hashType**(`primaryType`, `types`, `crypto`): `Uint8Array`
Defined in: [src/primitives/Domain/index.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L86)
#### Parameters
##### primaryType
`string`
##### types
`Record`\<`string`, readonly `object`\[]>
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
`Uint8Array`
***
### toErc5267Response()
> **toErc5267Response**(`domain`): [`ERC5267Response`](#erc5267response)
Defined in: [src/primitives/Domain/index.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L111)
#### Parameters
##### domain
[`DomainType`](#domaintype)
#### Returns
[`ERC5267Response`](#erc5267response)
***
### toHash()
> **toHash**(`domain`, `crypto`): [`DomainSeparatorType`](DomainSeparator.mdx#domainseparatortype)
Defined in: [src/primitives/Domain/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Domain/index.ts#L37)
#### Parameters
##### domain
[`DomainType`](#domaintype)
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
[`DomainSeparatorType`](DomainSeparator.mdx#domainseparatortype)
# primitives/DomainSeparator
Source: https://voltaire.tevm.sh/generated-api/primitives/DomainSeparator
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/DomainSeparator
# primitives/DomainSeparator
## Classes
### InvalidDomainSeparatorLengthError
Defined in: [src/primitives/DomainSeparator/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/errors.js#L4)
Error thrown when DomainSeparator length is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidDomainSeparatorLengthError**(`message`, `context`): [`InvalidDomainSeparatorLengthError`](#invaliddomainseparatorlengtherror)
Defined in: [src/primitives/DomainSeparator/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/errors.js#L9)
###### Parameters
###### message
`string`
###### context
`Record`\<`string`, `unknown`>
###### Returns
[`InvalidDomainSeparatorLengthError`](#invaliddomainseparatorlengtherror)
###### Overrides
`Error.constructor`
#### Properties
##### context
> **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/DomainSeparator/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/DomainSeparator/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### DomainSeparatorType
> **DomainSeparatorType** = `Uint8Array` & `object`
Defined in: [src/primitives/DomainSeparator/DomainSeparatorType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/DomainSeparatorType.ts#L7)
EIP-712 Domain Separator - keccak256 hash of domain separator
Used in EIP-712 signature verification for domain separation
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"DomainSeparator"`
##### length
> `readonly` **length**: `32`
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/DomainSeparator/DomainSeparatorType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/DomainSeparatorType.ts#L12)
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/DomainSeparator/equals.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/equals.js#L12)
Check if two DomainSeparators are equal
#### Parameters
##### a
[`DomainSeparatorType`](#domainseparatortype)
First DomainSeparator
##### b
[`DomainSeparatorType`](#domainseparatortype)
Second DomainSeparator
#### Returns
`boolean`
True if equal
#### Example
```javascript theme={null}
const equal = DomainSeparator.equals(sep1, sep2);
```
***
### \_from()
> **\_from**(`value`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/from.js#L17)
Create DomainSeparator from string or bytes
#### Parameters
##### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
DomainSeparator bytes
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as DomainSeparator from './primitives/DomainSeparator/index.js';
const sep = DomainSeparator.from('0x1234...');
const sep2 = DomainSeparator.from(new Uint8Array(32));
```
***
### \_fromBytes()
> **\_fromBytes**(`bytes`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/fromBytes.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/fromBytes.js#L14)
Create DomainSeparator from bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
32-byte array
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
DomainSeparator
#### Throws
If bytes length is not 32
#### Example
```javascript theme={null}
const sep = DomainSeparator.fromBytes(new Uint8Array(32));
```
***
### \_fromHex()
> **\_fromHex**(`hex`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/fromHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/fromHex.js#L15)
Create DomainSeparator from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix (must be 66 chars with 0x or 64 without)
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
DomainSeparator
#### Throws
If hex string is invalid or wrong length
#### Example
```javascript theme={null}
const sep = DomainSeparator.fromHex('0x1234...');
```
***
### \_toHex()
> **\_toHex**(`separator`): `string`
Defined in: [src/primitives/DomainSeparator/toHex.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/toHex.js#L14)
Convert DomainSeparator to hex string with 0x prefix
#### Parameters
##### separator
[`DomainSeparatorType`](#domainseparatortype)
DomainSeparator
#### Returns
`string`
Hex string with 0x prefix
#### Example
```javascript theme={null}
const hex = DomainSeparator.toHex(separator);
console.log(hex); // '0x1234...'
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/DomainSeparator/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/index.ts#L42)
#### Parameters
##### a
[`DomainSeparatorType`](#domainseparatortype)
##### b
[`DomainSeparatorType`](#domainseparatortype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/index.ts#L18)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
***
### fromBytes()
> **fromBytes**(`bytes`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/index.ts#L24)
#### Parameters
##### bytes
`Uint8Array`
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
***
### fromHex()
> **fromHex**(`hex`): [`DomainSeparatorType`](#domainseparatortype)
Defined in: [src/primitives/DomainSeparator/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/index.ts#L30)
#### Parameters
##### hex
`string`
#### Returns
[`DomainSeparatorType`](#domainseparatortype)
***
### toHex()
> **toHex**(`separator`): `string`
Defined in: [src/primitives/DomainSeparator/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/DomainSeparator/index.ts#L36)
#### Parameters
##### separator
[`DomainSeparatorType`](#domainseparatortype)
#### Returns
`string`
# primitives/EffectiveGasPrice
Source: https://voltaire.tevm.sh/generated-api/primitives/EffectiveGasPrice
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/EffectiveGasPrice
# primitives/EffectiveGasPrice
## Type Aliases
### EffectiveGasPriceType
> **EffectiveGasPriceType** = `bigint` & `object`
Defined in: [src/primitives/EffectiveGasPrice/EffectiveGasPriceType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/EffectiveGasPriceType.ts#L10)
Branded EffectiveGasPrice type - EIP-1559 effective gas price
Represents the actual gas price paid in a transaction
Calculated as: min(baseFee + priorityFee, maxFeePerGas)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EffectiveGasPrice"`
#### See
[https://eips.ethereum.org/EIPS/eip-1559](https://eips.ethereum.org/EIPS/eip-1559)
## Variables
### EffectiveGasPrice
> `const` **EffectiveGasPrice**: `object`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L54)
#### Type Declaration
##### calculate()
> **calculate**: (`baseFee`, `maxFee`, `maxPriorityFee`) => [`EffectiveGasPriceType`](#effectivegaspricetype)
Calculate effective gas price from EIP-1559 fee parameters
Formula: min(baseFee + min(maxPriorityFee, maxFee - baseFee), maxFee)
###### Parameters
###### baseFee
`bigint`
Base fee per gas
###### maxFee
`bigint`
Maximum fee per gas
###### maxPriorityFee
`bigint`
Maximum priority fee per gas
###### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective gas price
###### Example
```typescript theme={null}
const baseFee = 25000000000n; // 25 Gwei
const maxFee = 100000000000n; // 100 Gwei
const maxPriorityFee = 2000000000n; // 2 Gwei
const effective = EffectiveGasPrice.calculate(baseFee, maxFee, maxPriorityFee);
// Returns 27000000000n (25 + 2 Gwei)
```
##### compare()
> **compare**: (`effectivePrice1`, `effectivePrice2`) => `number`
###### Parameters
###### effectivePrice1
`string` | `number` | `bigint`
###### effectivePrice2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`effectivePrice1`, `effectivePrice2`) => `boolean`
###### Parameters
###### effectivePrice1
`string` | `number` | `bigint`
###### effectivePrice2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`EffectiveGasPriceType`](#effectivegaspricetype)
Create EffectiveGasPrice from bigint, number, or hex string
###### Parameters
###### value
Effective price in Wei
`string` | `number` | `bigint`
###### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Branded effective gas price
###### Throws
If value is negative or invalid format
###### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n); // 27 Gwei
const effectivePrice2 = EffectiveGasPrice.from("0x64da46800");
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`EffectiveGasPriceType`](#effectivegaspricetype)
Create EffectiveGasPrice from Gwei value
###### Parameters
###### gwei
Value in Gwei
`number` | `bigint`
###### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective price in Wei
###### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.fromGwei(27n); // 27 Gwei = 27000000000 Wei
```
##### fromWei()
> **fromWei**: (`wei`) => [`EffectiveGasPriceType`](#effectivegaspricetype)
Create EffectiveGasPrice from Wei value (alias for from)
###### Parameters
###### wei
Value in Wei
`string` | `number` | `bigint`
###### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective price
###### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.fromWei(27000000000n);
```
##### toBigInt()
> **toBigInt**: (`effectivePrice`) => `bigint`
###### Parameters
###### effectivePrice
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGwei()
> **toGwei**: (`effectivePrice`) => `bigint`
###### Parameters
###### effectivePrice
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`effectivePrice`) => `number`
###### Parameters
###### effectivePrice
`string` | `number` | `bigint`
###### Returns
`number`
##### toWei()
> **toWei**: (`effectivePrice`) => `bigint`
###### Parameters
###### effectivePrice
`string` | `number` | `bigint`
###### Returns
`bigint`
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/EffectiveGasPrice/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/compare.js#L15)
Compare two EffectiveGasPrice values
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
##### other
[`EffectiveGasPriceType`](#effectivegaspricetype)
Value to compare
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const price1 = EffectiveGasPrice.from(27000000000n);
const price2 = EffectiveGasPrice.from(30000000000n);
EffectiveGasPrice.compare(price1, price2); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/EffectiveGasPrice/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/equals.js#L15)
Check if two EffectiveGasPrice values are equal
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
##### other
[`EffectiveGasPriceType`](#effectivegaspricetype)
Value to compare
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const price1 = EffectiveGasPrice.from(27000000000n);
const price2 = EffectiveGasPrice.from(27000000000n);
EffectiveGasPrice.equals(price1, price2); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/toBigInt.js#L13)
Convert EffectiveGasPrice to bigint (identity function)
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
#### Returns
`bigint`
Value as bigint
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n);
EffectiveGasPrice.toBigInt(effectivePrice); // 27000000000n
```
***
### \_toGwei()
> **\_toGwei**(`this`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/toGwei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/toGwei.js#L13)
Convert EffectiveGasPrice to Gwei
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
#### Returns
`bigint`
Value in Gwei
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n);
EffectiveGasPrice.toGwei(effectivePrice); // 27n Gwei
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/EffectiveGasPrice/toNumber.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/toNumber.js#L14)
Convert EffectiveGasPrice to number
WARNING: May lose precision for large values
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
#### Returns
`number`
Value as number
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n);
EffectiveGasPrice.toNumber(effectivePrice); // 27000000000
```
***
### \_toWei()
> **\_toWei**(`this`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/toWei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/toWei.js#L13)
Convert EffectiveGasPrice to Wei (identity function)
#### Parameters
##### this
[`EffectiveGasPriceType`](#effectivegaspricetype)
#### Returns
`bigint`
Value in Wei
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n);
EffectiveGasPrice.toWei(effectivePrice); // 27000000000n Wei
```
***
### calculate()
> **calculate**(`baseFee`, `maxFee`, `maxPriorityFee`): [`EffectiveGasPriceType`](#effectivegaspricetype)
Defined in: [src/primitives/EffectiveGasPrice/calculate.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/calculate.js#L19)
Calculate effective gas price from EIP-1559 fee parameters
Formula: min(baseFee + min(maxPriorityFee, maxFee - baseFee), maxFee)
#### Parameters
##### baseFee
`bigint`
Base fee per gas
##### maxFee
`bigint`
Maximum fee per gas
##### maxPriorityFee
`bigint`
Maximum priority fee per gas
#### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective gas price
#### Example
```typescript theme={null}
const baseFee = 25000000000n; // 25 Gwei
const maxFee = 100000000000n; // 100 Gwei
const maxPriorityFee = 2000000000n; // 2 Gwei
const effective = EffectiveGasPrice.calculate(baseFee, maxFee, maxPriorityFee);
// Returns 27000000000n (25 + 2 Gwei)
```
***
### compare()
> **compare**(`effectivePrice1`, `effectivePrice2`): `number`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L43)
#### Parameters
##### effectivePrice1
`string` | `number` | `bigint`
##### effectivePrice2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`effectivePrice1`, `effectivePrice2`): `boolean`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L36)
#### Parameters
##### effectivePrice1
`string` | `number` | `bigint`
##### effectivePrice2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`EffectiveGasPriceType`](#effectivegaspricetype)
Defined in: [src/primitives/EffectiveGasPrice/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/from.js#L16)
Create EffectiveGasPrice from bigint, number, or hex string
#### Parameters
##### value
Effective price in Wei
`string` | `number` | `bigint`
#### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Branded effective gas price
#### Throws
If value is negative or invalid format
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.from(27000000000n); // 27 Gwei
const effectivePrice2 = EffectiveGasPrice.from("0x64da46800");
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`EffectiveGasPriceType`](#effectivegaspricetype)
Defined in: [src/primitives/EffectiveGasPrice/fromGwei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/fromGwei.js#L12)
Create EffectiveGasPrice from Gwei value
#### Parameters
##### gwei
Value in Gwei
`number` | `bigint`
#### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective price in Wei
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.fromGwei(27n); // 27 Gwei = 27000000000 Wei
```
***
### fromWei()
> **fromWei**(`wei`): [`EffectiveGasPriceType`](#effectivegaspricetype)
Defined in: [src/primitives/EffectiveGasPrice/fromWei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/fromWei.js#L12)
Create EffectiveGasPrice from Wei value (alias for from)
#### Parameters
##### wei
Value in Wei
`string` | `number` | `bigint`
#### Returns
[`EffectiveGasPriceType`](#effectivegaspricetype)
Effective price
#### Example
```typescript theme={null}
const effectivePrice = EffectiveGasPrice.fromWei(27000000000n);
```
***
### toBigInt()
> **toBigInt**(`effectivePrice`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L32)
#### Parameters
##### effectivePrice
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toGwei()
> **toGwei**(`effectivePrice`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L20)
#### Parameters
##### effectivePrice
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toNumber()
> **toNumber**(`effectivePrice`): `number`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L28)
#### Parameters
##### effectivePrice
`string` | `number` | `bigint`
#### Returns
`number`
***
### toWei()
> **toWei**(`effectivePrice`): `bigint`
Defined in: [src/primitives/EffectiveGasPrice/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EffectiveGasPrice/index.ts#L24)
#### Parameters
##### effectivePrice
`string` | `number` | `bigint`
#### Returns
`bigint`
# primitives/EncodedData
Source: https://voltaire.tevm.sh/generated-api/primitives/EncodedData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/EncodedData
# primitives/EncodedData
## Classes
### InvalidHexFormatError
Defined in: [src/primitives/EncodedData/errors.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/errors.ts#L6)
Error thrown when hex string format is invalid
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new InvalidHexFormatError**(`message`, `context?`): [`InvalidHexFormatError`](#invalidhexformaterror)
Defined in: [src/primitives/EncodedData/errors.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/errors.ts#L7)
###### Parameters
###### message
`string`
###### context?
`Record`\<`string`, `unknown`>
###### Returns
[`InvalidHexFormatError`](#invalidhexformaterror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
***
### InvalidValueError
Defined in: [src/primitives/EncodedData/errors.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/errors.ts#L16)
Error thrown when value type is unsupported
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new InvalidValueError**(`message`, `context?`): [`InvalidValueError`](#invalidvalueerror)
Defined in: [src/primitives/EncodedData/errors.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/errors.ts#L17)
###### Parameters
###### message
`string`
###### context?
`Record`\<`string`, `unknown`>
###### Returns
[`InvalidValueError`](#invalidvalueerror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Type Aliases
### EncodedDataType
> **EncodedDataType** = `` `0x${string}` `` & `object`
Defined in: [src/primitives/EncodedData/EncodedDataType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/EncodedDataType.ts#L9)
EncodedData - ABI-encoded hex data
Branded hex string representing ABI-encoded data.
Can be decoded using ABI specifications.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EncodedData"`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/EncodedData/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/equals.js#L13)
Check if two EncodedData instances are equal
#### Parameters
##### a
[`EncodedDataType`](#encodeddatatype)
First EncodedData
##### b
[`EncodedDataType`](#encodeddatatype)
Second EncodedData
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const isEqual = EncodedData.equals(data1, data2);
```
***
### \_from()
> **\_from**(`value`): [`EncodedDataType`](#encodeddatatype)
Defined in: [src/primitives/EncodedData/from.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/from.js#L18)
Create EncodedData from various input types
#### Parameters
##### value
Hex string or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`EncodedDataType`](#encodeddatatype)
EncodedData
#### Throws
If value type is unsupported
#### Throws
If hex string is invalid
#### Example
```typescript theme={null}
const data1 = EncodedData.from("0x0000...");
const data2 = EncodedData.from(new Uint8Array([0, 0, ...]));
```
***
### \_fromBytes()
> **\_fromBytes**(`value`): [`EncodedDataType`](#encodeddatatype)
Defined in: [src/primitives/EncodedData/fromBytes.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/fromBytes.js#L14)
Create EncodedData from Uint8Array
#### Parameters
##### value
`Uint8Array`\<`ArrayBufferLike`>
Byte array
#### Returns
[`EncodedDataType`](#encodeddatatype)
EncodedData
#### Example
```typescript theme={null}
const data = EncodedData.fromBytes(new Uint8Array([0, 0, 0, 1]));
```
***
### \_toBytes()
> **\_toBytes**(`data`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/EncodedData/toBytes.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/toBytes.js#L14)
Convert EncodedData to Uint8Array
#### Parameters
##### data
[`EncodedDataType`](#encodeddatatype)
EncodedData
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Byte array
#### Example
```typescript theme={null}
const bytes = EncodedData.toBytes(data);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/EncodedData/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/index.ts#L34)
Check if two EncodedData instances are equal
#### Parameters
##### a
[`EncodedDataType`](#encodeddatatype)
##### b
[`EncodedDataType`](#encodeddatatype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`EncodedDataType`](#encodeddatatype)
Defined in: [src/primitives/EncodedData/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/index.ts#L13)
Create EncodedData from various input types
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`EncodedDataType`](#encodeddatatype)
***
### fromBytes()
> **fromBytes**(`value`): [`EncodedDataType`](#encodeddatatype)
Defined in: [src/primitives/EncodedData/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/index.ts#L20)
Create EncodedData from Uint8Array
#### Parameters
##### value
`Uint8Array`
#### Returns
[`EncodedDataType`](#encodeddatatype)
***
### toBytes()
> **toBytes**(`data`): `Uint8Array`
Defined in: [src/primitives/EncodedData/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EncodedData/index.ts#L27)
Convert EncodedData to Uint8Array
#### Parameters
##### data
[`EncodedDataType`](#encodeddatatype)
#### Returns
`Uint8Array`
# primitives/Ens
Source: https://voltaire.tevm.sh/generated-api/primitives/Ens
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Ens
# primitives/Ens
## Classes
### DisallowedCharacterError
Defined in: [src/primitives/Ens/errors.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L74)
Disallowed character error (prohibited ENS character)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new DisallowedCharacterError**(`options`): [`DisallowedCharacterError`](#disallowedcharactererror)
Defined in: [src/primitives/Ens/errors.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L75)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`DisallowedCharacterError`](#disallowedcharactererror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### EmptyLabelError
Defined in: [src/primitives/Ens/errors.ts:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L96)
Empty label error (zero-length label segment)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new EmptyLabelError**(`options`): [`EmptyLabelError`](#emptylabelerror)
Defined in: [src/primitives/Ens/errors.ts:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L97)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`EmptyLabelError`](#emptylabelerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### IllegalMixtureError
Defined in: [src/primitives/Ens/errors.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L30)
Illegal mixture error (incompatible script combinations)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new IllegalMixtureError**(`options`): [`IllegalMixtureError`](#illegalmixtureerror)
Defined in: [src/primitives/Ens/errors.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L31)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`IllegalMixtureError`](#illegalmixtureerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidLabelExtensionError
Defined in: [src/primitives/Ens/errors.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L8)
Invalid label extension error (double-dash at positions 2-3)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidLabelExtensionError**(`options`): [`InvalidLabelExtensionError`](#invalidlabelextensionerror)
Defined in: [src/primitives/Ens/errors.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L9)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`InvalidLabelExtensionError`](#invalidlabelextensionerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidUtf8Error
Defined in: [src/primitives/Ens/errors.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L118)
Invalid UTF-8 error (malformed UTF-8 encoding)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidUtf8Error**(`options`): [`InvalidUtf8Error`](#invalidutf8error)
Defined in: [src/primitives/Ens/errors.ts:119](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L119)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`InvalidUtf8Error`](#invalidutf8error)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### WholeConfusableError
Defined in: [src/primitives/Ens/errors.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L52)
Whole confusable error (name resembles different script)
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new WholeConfusableError**(`options`): [`WholeConfusableError`](#wholeconfusableerror)
Defined in: [src/primitives/Ens/errors.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/errors.ts#L53)
###### Parameters
###### options
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### value
`string`
###### Returns
[`WholeConfusableError`](#wholeconfusableerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
## Type Aliases
### Ens
> **Ens** = `string` & `object`
Defined in: [src/primitives/Ens/EnsType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/EnsType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Ens"`
## Variables
### \_beautify()
> `const` **\_beautify**: (`name`) => [`Ens`](#ens) = `_beautifyImpl`
Defined in: [src/primitives/Ens/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L18)
#### Parameters
##### name
[`Ens`](#ens)
#### Returns
[`Ens`](#ens)
***
### \_labelhash()
> `const` **\_labelhash**: (`label`) => `Uint8Array`
Defined in: [src/primitives/Ens/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L38)
#### Parameters
##### label
[`Ens`](#ens)
#### Returns
`Uint8Array`
***
### \_namehash()
> `const` **\_namehash**: (`name`) => `Uint8Array`
Defined in: [src/primitives/Ens/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L37)
#### Parameters
##### name
[`Ens`](#ens)
#### Returns
`Uint8Array`
***
### \_normalize()
> `const` **\_normalize**: (`name`) => [`Ens`](#ens) = `_normalizeImpl`
Defined in: [src/primitives/Ens/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L28)
#### Parameters
##### name
[`Ens`](#ens)
#### Returns
[`Ens`](#ens)
***
### from()
> `const` **from**: (`name`) => [`Ens`](#ens) = `fromImpl`
Defined in: [src/primitives/Ens/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L19)
#### Parameters
##### name
`string`
#### Returns
[`Ens`](#ens)
***
### is()
> `const` **is**: (`value`) => `value is Ens` = `isImpl`
Defined in: [src/primitives/Ens/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L20)
#### Parameters
##### value
`unknown`
#### Returns
`value is Ens`
***
### isValid()
> `const` **isValid**: (`name`) => `boolean` = `isValidImpl`
Defined in: [src/primitives/Ens/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L21)
#### Parameters
##### name
`string`
#### Returns
`boolean`
***
### Labelhash()
> `const` **Labelhash**: (`deps`) => (`label`) => `Uint8Array` = `LabelhashImpl`
Defined in: [src/primitives/Ens/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L22)
#### Parameters
##### deps
###### keccak256
(`data`) => `Uint8Array`
#### Returns
> (`label`): `Uint8Array`
##### Parameters
###### label
[`Ens`](#ens)
##### Returns
`Uint8Array`
***
### Namehash()
> `const` **Namehash**: (`deps`) => (`name`) => `Uint8Array` = `NamehashImpl`
Defined in: [src/primitives/Ens/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L25)
#### Parameters
##### deps
###### keccak256
(`data`) => `Uint8Array`
#### Returns
> (`name`): `Uint8Array`
##### Parameters
###### name
[`Ens`](#ens)
##### Returns
`Uint8Array`
***
### toString()
> `const` **toString**: (`name`) => `string` = `toStringImpl`
Defined in: [src/primitives/Ens/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L30)
#### Parameters
##### name
[`Ens`](#ens)
#### Returns
`string`
***
### validate()
> `const` **validate**: (`name`) => `void` = `validateImpl`
Defined in: [src/primitives/Ens/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L31)
#### Parameters
##### name
`string`
#### Returns
`void`
## Functions
### beautify()
> **beautify**(`name`): [`Ens`](#ens)
Defined in: [src/primitives/Ens/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L58)
#### Parameters
##### name
`string` | [`Ens`](#ens)
#### Returns
[`Ens`](#ens)
***
### labelhash()
> **labelhash**(`label`): `Uint8Array`
Defined in: [src/primitives/Ens/index.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L66)
#### Parameters
##### label
`string` | [`Ens`](#ens)
#### Returns
`Uint8Array`
***
### namehash()
> **namehash**(`name`): `Uint8Array`
Defined in: [src/primitives/Ens/index.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L62)
#### Parameters
##### name
`string` | [`Ens`](#ens)
#### Returns
`Uint8Array`
***
### normalize()
> **normalize**(`name`): [`Ens`](#ens)
Defined in: [src/primitives/Ens/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Ens/index.ts#L54)
#### Parameters
##### name
`string` | [`Ens`](#ens)
#### Returns
[`Ens`](#ens)
# primitives/EntryPoint
Source: https://voltaire.tevm.sh/generated-api/primitives/EntryPoint
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/EntryPoint
# primitives/EntryPoint
## Type Aliases
### EntryPointType
> **EntryPointType** = `Uint8Array` & `object`
Defined in: [src/primitives/EntryPoint/EntryPointType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/EntryPointType.ts#L10)
EntryPoint address type - ERC-4337 entry point contract
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EntryPoint"`
#### See
* [https://eips.ethereum.org/EIPS/eip-4337](https://eips.ethereum.org/EIPS/eip-4337)
* [https://voltaire.tevm.sh/primitives/entry-point](https://voltaire.tevm.sh/primitives/entry-point) for EntryPoint documentation
#### Since
0.0.0
## Variables
### EntryPoint
> `const` **EntryPoint**: `object`
Defined in: [src/primitives/EntryPoint/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/index.ts#L34)
#### Type Declaration
##### equals()
> **equals**: (`entryPoint1`, `entryPoint2`) => `boolean`
###### Parameters
###### entryPoint1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### entryPoint2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`EntryPointType`](#entrypointtype)
Create EntryPoint from address input
###### Parameters
###### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
[`EntryPointType`](#entrypointtype)
EntryPoint address
###### Throws
If address format is invalid
###### Example
```typescript theme={null}
const entryPoint = EntryPoint.from("0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789");
const entryPoint2 = EntryPoint.from(ENTRYPOINT_V07);
```
##### toHex()
> **toHex**: (`entryPoint`) => `string`
###### Parameters
###### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`string`
***
### ENTRYPOINT\_V06
> `const` **ENTRYPOINT\_V06**: [`EntryPointType`](#entrypointtype)
Defined in: [src/primitives/EntryPoint/constants.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/constants.js#L7)
EntryPoint v0.6.0 address
***
### ENTRYPOINT\_V07
> `const` **ENTRYPOINT\_V07**: [`EntryPointType`](#entrypointtype)
Defined in: [src/primitives/EntryPoint/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/constants.js#L15)
EntryPoint v0.7.0 address
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/EntryPoint/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/equals.js#L15)
Check if two EntryPoint addresses are equal
#### Parameters
##### a
[`EntryPointType`](#entrypointtype)
First EntryPoint
##### b
[`EntryPointType`](#entrypointtype)
Second EntryPoint
#### Returns
`boolean`
True if addresses are equal
#### Example
```typescript theme={null}
const isEqual = EntryPoint.equals(entryPoint1, entryPoint2);
```
***
### \_toHex()
> **\_toHex**(`entryPoint`): `string`
Defined in: [src/primitives/EntryPoint/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/toHex.js#L15)
Convert EntryPoint to hex string
#### Parameters
##### entryPoint
[`EntryPointType`](#entrypointtype)
EntryPoint address
#### Returns
`string`
Hex string (0x-prefixed)
#### Example
```typescript theme={null}
const hex = EntryPoint.toHex(entryPoint);
console.log(hex); // "0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789"
```
***
### equals()
> **equals**(`entryPoint1`, `entryPoint2`): `boolean`
Defined in: [src/primitives/EntryPoint/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/index.ts#L23)
#### Parameters
##### entryPoint1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### entryPoint2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`EntryPointType`](#entrypointtype)
Defined in: [src/primitives/EntryPoint/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/from.js#L16)
Create EntryPoint from address input
#### Parameters
##### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
[`EntryPointType`](#entrypointtype)
EntryPoint address
#### Throws
If address format is invalid
#### Example
```typescript theme={null}
const entryPoint = EntryPoint.from("0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789");
const entryPoint2 = EntryPoint.from(ENTRYPOINT_V07);
```
***
### toHex()
> **toHex**(`entryPoint`): `string`
Defined in: [src/primitives/EntryPoint/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EntryPoint/index.ts#L17)
#### Parameters
##### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`string`
# primitives/Epoch
Source: https://voltaire.tevm.sh/generated-api/primitives/Epoch
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Epoch
# primitives/Epoch
## Type Aliases
### EpochType
> **EpochType** = `bigint` & `object`
Defined in: [src/primitives/Epoch/EpochType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/EpochType.ts#L13)
Epoch type
Represents a consensus layer epoch (32 slots = 6.4 minutes).
Epochs are used for validator duties, finality, and checkpoint organization.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Epoch"`
#### See
* [https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
* [https://github.com/ethereum/consensus-specs](https://github.com/ethereum/consensus-specs) for Consensus specifications
#### Since
0.0.0
## Variables
### Epoch
> `const` **Epoch**: `object`
Defined in: [src/primitives/Epoch/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/index.ts#L11)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if Epoch values are equal
###### Parameters
###### a
[`EpochType`](#epochtype)
First epoch
###### b
[`EpochType`](#epochtype)
Second epoch
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const a = Epoch.from(100000n);
const b = Epoch.from(100000n);
const result = Epoch.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`EpochType`](#epochtype)
Create Epoch from number, bigint, or string
###### Parameters
###### value
Epoch number (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
###### Returns
[`EpochType`](#epochtype)
Epoch value
###### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
###### Since
0.0.0
###### Throws
If value is negative or invalid
###### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch1 = Epoch.from(100000n);
const epoch2 = Epoch.from(100000);
const epoch3 = Epoch.from("0x186a0");
```
##### toBigInt()
> **toBigInt**: (`epoch`) => `bigint`
Convert Epoch to bigint
###### Parameters
###### epoch
[`EpochType`](#epochtype)
Epoch value
###### Returns
`bigint`
BigInt representation
###### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(100000);
const big = Epoch.toBigInt(epoch); // 100000n
```
##### toNumber()
> **toNumber**: (`epoch`) => `number`
Convert Epoch to number
###### Parameters
###### epoch
[`EpochType`](#epochtype)
Epoch value
###### Returns
`number`
Number representation
###### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
###### Since
0.0.0
###### Throws
If epoch exceeds safe integer range
###### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(100000n);
const num = Epoch.toNumber(epoch); // 100000
```
##### toSlot()
> **toSlot**: (`epoch`) => [`SlotType`](Slot.mdx#slottype)
Convert Epoch to the first Slot of that epoch
Each epoch contains 32 slots. This function returns the first slot: slot = epoch \* 32.
###### Parameters
###### epoch
[`EpochType`](#epochtype)
Epoch value
###### Returns
[`SlotType`](Slot.mdx#slottype)
First slot of the epoch
###### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(3n);
const slot = Epoch.toSlot(epoch); // 96n (3 * 32)
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Epoch/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/equals.js#L18)
Check if Epoch values are equal
#### Parameters
##### a
[`EpochType`](#epochtype)
First epoch
##### b
[`EpochType`](#epochtype)
Second epoch
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const a = Epoch.from(100000n);
const b = Epoch.from(100000n);
const result = Epoch.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`EpochType`](#epochtype)
Defined in: [src/primitives/Epoch/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/from.js#L17)
Create Epoch from number, bigint, or string
#### Parameters
##### value
Epoch number (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
#### Returns
[`EpochType`](#epochtype)
Epoch value
#### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
#### Since
0.0.0
#### Throws
If value is negative or invalid
#### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch1 = Epoch.from(100000n);
const epoch2 = Epoch.from(100000);
const epoch3 = Epoch.from("0x186a0");
```
***
### toBigInt()
> **toBigInt**(`epoch`): `bigint`
Defined in: [src/primitives/Epoch/toBigInt.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/toBigInt.js#L16)
Convert Epoch to bigint
#### Parameters
##### epoch
[`EpochType`](#epochtype)
Epoch value
#### Returns
`bigint`
BigInt representation
#### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(100000);
const big = Epoch.toBigInt(epoch); // 100000n
```
***
### toNumber()
> **toNumber**(`epoch`): `number`
Defined in: [src/primitives/Epoch/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/toNumber.js#L16)
Convert Epoch to number
#### Parameters
##### epoch
[`EpochType`](#epochtype)
Epoch value
#### Returns
`number`
Number representation
#### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
#### Since
0.0.0
#### Throws
If epoch exceeds safe integer range
#### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(100000n);
const num = Epoch.toNumber(epoch); // 100000
```
***
### toSlot()
> **toSlot**(`epoch`): [`SlotType`](Slot.mdx#slottype)
Defined in: [src/primitives/Epoch/toSlot.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Epoch/toSlot.js#L20)
Convert Epoch to the first Slot of that epoch
Each epoch contains 32 slots. This function returns the first slot: slot = epoch \* 32.
#### Parameters
##### epoch
[`EpochType`](#epochtype)
Epoch value
#### Returns
[`SlotType`](Slot.mdx#slottype)
First slot of the epoch
#### See
[https://voltaire.tevm.sh/primitives/epoch](https://voltaire.tevm.sh/primitives/epoch) for Epoch documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Epoch from './primitives/Epoch/index.js';
const epoch = Epoch.from(3n);
const slot = Epoch.toSlot(epoch); // 96n (3 * 32)
```
# primitives/ErrorSignature
Source: https://voltaire.tevm.sh/generated-api/primitives/ErrorSignature
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ErrorSignature
# primitives/ErrorSignature
## Type Aliases
### ErrorSignatureLike
> **ErrorSignatureLike** = [`ErrorSignatureType`](#errorsignaturetype) | `string` | `Uint8Array`
Defined in: [src/primitives/ErrorSignature/ErrorSignatureType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/ErrorSignatureType.ts#L8)
***
### ErrorSignatureType
> **ErrorSignatureType** = `Uint8Array` & `object`
Defined in: [src/primitives/ErrorSignature/ErrorSignatureType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/ErrorSignatureType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ErrorSignature"`
##### length
> `readonly` **length**: `4`
## Variables
### ErrorSignature
> `const` **ErrorSignature**: `object`
Defined in: [src/primitives/ErrorSignature/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L54)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two ErrorSignatures are equal
###### Parameters
###### a
[`ErrorSignatureType`](#errorsignaturetype)
###### b
[`ErrorSignatureType`](#errorsignaturetype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`ErrorSignatureType`](#errorsignaturetype)
Create ErrorSignature from various input types
###### Parameters
###### value
[`ErrorSignatureLike`](#errorsignaturelike)
###### Returns
[`ErrorSignatureType`](#errorsignaturetype)
##### fromHex()
> **fromHex**: (`hex`) => [`ErrorSignatureType`](#errorsignaturetype)
Create ErrorSignature from hex string
###### Parameters
###### hex
`string`
###### Returns
[`ErrorSignatureType`](#errorsignaturetype)
##### fromSignature()
> **fromSignature**: (`signature`) => [`ErrorSignatureType`](#errorsignaturetype)
Compute ErrorSignature from error signature string
###### Parameters
###### signature
`string`
###### Returns
[`ErrorSignatureType`](#errorsignaturetype)
##### toHex()
> **toHex**: (`signature`) => `string`
Convert ErrorSignature to hex string
###### Parameters
###### signature
[`ErrorSignatureType`](#errorsignaturetype)
###### Returns
`string`
***
### SIZE
> `const` **SIZE**: `4` = `4`
Defined in: [src/primitives/ErrorSignature/ErrorSignatureType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/ErrorSignatureType.ts#L10)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ErrorSignature/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L49)
Check if two ErrorSignatures are equal
#### Parameters
##### a
[`ErrorSignatureType`](#errorsignaturetype)
##### b
[`ErrorSignatureType`](#errorsignaturetype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`ErrorSignatureType`](#errorsignaturetype)
Defined in: [src/primitives/ErrorSignature/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L21)
Create ErrorSignature from various input types
#### Parameters
##### value
[`ErrorSignatureLike`](#errorsignaturelike)
#### Returns
[`ErrorSignatureType`](#errorsignaturetype)
***
### fromHex()
> **fromHex**(`hex`): [`ErrorSignatureType`](#errorsignaturetype)
Defined in: [src/primitives/ErrorSignature/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L28)
Create ErrorSignature from hex string
#### Parameters
##### hex
`string`
#### Returns
[`ErrorSignatureType`](#errorsignaturetype)
***
### fromSignature()
> **fromSignature**(`signature`): [`ErrorSignatureType`](#errorsignaturetype)
Defined in: [src/primitives/ErrorSignature/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L35)
Compute ErrorSignature from error signature string
#### Parameters
##### signature
`string`
#### Returns
[`ErrorSignatureType`](#errorsignaturetype)
***
### toHex()
> **toHex**(`signature`): `string`
Defined in: [src/primitives/ErrorSignature/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ErrorSignature/index.ts#L42)
Convert ErrorSignature to hex string
#### Parameters
##### signature
[`ErrorSignatureType`](#errorsignaturetype)
#### Returns
`string`
# primitives/EventLog
Source: https://voltaire.tevm.sh/generated-api/primitives/EventLog
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/EventLog
# primitives/EventLog
## Interfaces
### EventLogConstructor()
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L42)
> **EventLogConstructor**(`params`): `EventLogPrototype`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L43)
#### Parameters
##### params
###### address
[`AddressType`](Address.mdx#addresstype)
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### blockNumber?
`bigint`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### logIndex?
`number`
###### removed?
`boolean`
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### transactionIndex?
`number`
#### Returns
`EventLogPrototype`
#### Properties
##### clone()
> **clone**: \<`T`>(`log`) => `T`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L58)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
`T`
##### copy()
> **copy**: \<`T`>(`log`) => `T`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L59)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
`T`
##### filter()
> **filter**: \<`T`>(`logs`, `filter`) => `T`\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L61)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### logs
readonly `T`\[]
###### filter
[`Filter`](#filter-1)\<[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[] | `undefined`, readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[] | `undefined`>
###### Returns
`T`\[]
##### filterLogs()
> **filterLogs**: \<`T`>(`logs`, `filter`) => `T`\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L60)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### logs
readonly `T`\[]
###### filter
[`Filter`](#filter-1)\<[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[] | `undefined`, readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[] | `undefined`>
###### Returns
`T`\[]
##### getIndexed()
> **getIndexed**: \<`T`>(`log`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L49)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
##### getIndexedTopics()
> **getIndexedTopics**: \<`T`>(`log`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L47)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
##### getSignature()
> **getSignature**: \<`T`>(`log`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L48)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
##### getTopic0()
> **getTopic0**: \<`T`>(`log`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L46)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
##### isRemoved()
> **isRemoved**: \<`T`>(`log`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L56)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
`boolean`
##### matches()
> **matches**: \<`T`>(`log`, `filterTopics`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L51)
Check if log matches topic filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterTopics
readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[]
Topic filter array
###### Returns
`boolean`
True if log matches topic filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesTopics(log, [topic0, null, topic2]);
```
##### matchesAddr()
> **matchesAddr**: \<`T`>(`log`, `filterAddress`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L53)
Check if log matches address filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterAddress
Address or array of addresses to match
[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[]
###### Returns
`boolean`
True if log matches address filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesAddress(log, Address.from("0x..."));
```
##### matchesAddress()
> **matchesAddress**: \<`T`>(`log`, `filterAddress`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L52)
Check if log matches address filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterAddress
Address or array of addresses to match
[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[]
###### Returns
`boolean`
True if log matches address filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesAddress(log, Address.from("0x..."));
```
##### matchesAll()
> **matchesAll**: \<`T`>(`log`, `filter`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L55)
Check if log matches complete filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filter
`Filter`
Complete filter object
###### Returns
`boolean`
True if log matches all filter criteria
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesFilter(log, {
address: Address.from("0x..."),
topics: [topic0, null, topic2],
fromBlock: 100n,
toBlock: 200n,
});
```
##### matchesFilter()
> **matchesFilter**: \<`T`>(`log`, `filter`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L54)
Check if log matches complete filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filter
`Filter`
Complete filter object
###### Returns
`boolean`
True if log matches all filter criteria
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesFilter(log, {
address: Address.from("0x..."),
topics: [topic0, null, topic2],
fromBlock: 100n,
toBlock: 200n,
});
```
##### matchesTopics()
> **matchesTopics**: \<`T`>(`log`, `filterTopics`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L50)
Check if log matches topic filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterTopics
readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[]
Topic filter array
###### Returns
`boolean`
True if log matches topic filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesTopics(log, [topic0, null, topic2]);
```
##### prototype
> **prototype**: `EventLogPrototype`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L44)
##### sort()
> **sort**: \<`T`>(`logs`) => `T`\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L63)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### logs
readonly `T`\[]
###### Returns
`T`\[]
##### sortLogs()
> **sortLogs**: \<`T`>(`logs`) => `T`\[]
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L62)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### logs
readonly `T`\[]
###### Returns
`T`\[]
##### wasRemoved()
> **wasRemoved**: \<`T`>(`log`) => `boolean`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L57)
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)
###### Parameters
###### log
`T`
###### Returns
`boolean`
#### Methods
##### create()
> **create**(`params`): `EventLogPrototype`
Defined in: [src/primitives/EventLog/EventLogConstructor.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogConstructor.ts#L45)
###### Parameters
###### params
###### address
[`AddressType`](Address.mdx#addresstype)
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### blockNumber?
`bigint`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### logIndex?
`number`
###### removed?
`boolean`
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### transactionIndex?
`number`
###### Returns
`EventLogPrototype`
## Type Aliases
### EventLogType
> **EventLogType**\<`TAddress`, `TTopics`> = `object` & `object`
Defined in: [src/primitives/EventLog/EventLogType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L8)
Branded EventLog type
#### Type Declaration
##### address
> **address**: `TAddress`
Contract address that emitted the log
##### blockHash?
> `optional` **blockHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Block hash
##### blockNumber?
> `optional` **blockNumber**: `bigint`
Block number where log was emitted
##### data
> **data**: `Uint8Array`
Event data (non-indexed parameters)
##### logIndex?
> `optional` **logIndex**: `number`
Log index in block
##### removed?
> `optional` **removed**: `boolean`
Log removed due to chain reorganization
##### topics
> **topics**: `TTopics`
Event topics (topic0 = event signature, topic1-3 = indexed parameters)
##### transactionHash?
> `optional` **transactionHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Transaction hash that generated the log
##### transactionIndex?
> `optional` **transactionIndex**: `number`
Transaction index in block
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EventLog"`
#### Type Parameters
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TTopics
`TTopics` *extends* readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] = readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
***
### Filter
> **Filter**\<`TAddress`, `TTopics`> = `object`
Defined in: [src/primitives/EventLog/EventLogType.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L53)
Event log filter for querying logs
#### Type Parameters
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[] | `undefined` = [`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[] | `undefined`
##### TTopics
`TTopics` *extends* readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[] | `undefined` = readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[] | `undefined`
#### Properties
##### address?
> `optional` **address**: `TAddress`
Defined in: [src/primitives/EventLog/EventLogType.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L63)
Contract address(es) to filter by
##### blockHash?
> `optional` **blockHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/EventLog/EventLogType.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L71)
Block hash to filter by (alternative to fromBlock/toBlock)
##### fromBlock?
> `optional` **fromBlock**: `bigint`
Defined in: [src/primitives/EventLog/EventLogType.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L67)
Starting block number
##### toBlock?
> `optional` **toBlock**: `bigint`
Defined in: [src/primitives/EventLog/EventLogType.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L69)
Ending block number
##### topics?
> `optional` **topics**: `TTopics`
Defined in: [src/primitives/EventLog/EventLogType.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/EventLogType.ts#L65)
Topic filters (null entries match any topic, arrays match any of the hashes)
## Variables
### BrandedEventLog
> `const` **BrandedEventLog**: `object`
Defined in: [src/primitives/EventLog/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/index.ts#L50)
#### Type Declaration
##### clone()
> **clone**: \<`T`>(`log`) => `T`
Clone event log with deep copy of topics and data
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
###### Parameters
###### log
`T`
Event log
###### Returns
`T`
Cloned log
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const cloned = EventLog.clone(log);
```
##### copy()
> **copy**: \<`T`>(`log`) => `T`
Copy event log (alias for clone)
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log
###### Returns
`T`
Copied log
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const copied = EventLog.copy(log);
```
##### create()
> **create**: (`params`) => [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
Create event log
###### Parameters
###### params
Event log parameters
###### address
[`AddressType`](Address.mdx#addresstype)
Contract address
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Block hash
###### blockNumber?
`bigint`
Block number
###### data
`Uint8Array`\<`ArrayBufferLike`>
Event data
###### logIndex?
`number`
Log index
###### removed?
`boolean`
Whether log was removed
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Event topics
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Transaction hash
###### transactionIndex?
`number`
Transaction index
###### Returns
[`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
EventLog object
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
import * as Hash from './primitives/Hash/index.js';
const log = EventLog.create({
address: Address.from("0x..."),
topics: [Hash.from("0x...")],
data: new Uint8Array([1, 2, 3]),
});
```
##### filterLogs()
> **filterLogs**: \<`T`>(`logs`, `filter`) => `T`\[]
Filter array of logs by filter criteria
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### logs
readonly `T`\[]
Array of event logs
###### filter
`Filter`
Filter criteria
###### Returns
`T`\[]
Filtered array of logs
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const logs = [log1, log2, log3];
const filtered = EventLog.filterLogs(logs, {
address: Address.from("0x..."),
topics: [topic0, null],
});
```
##### from()
> **from**: (`params`) => `BrandedEventLog`
Create EventLog from parameters
###### Parameters
###### params
Event log parameters
###### address
[`AddressType`](Address.mdx#addresstype)
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### blockNumber?
`bigint`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### logIndex?
`number`
###### removed?
`boolean`
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### transactionIndex?
`number`
###### Returns
`BrandedEventLog`
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
import * as Hash from './primitives/Hash/index.js';
const log = EventLog.from({
address: Address.from("0x..."),
topics: [Hash.from("0x...")],
data: new Uint8Array([1, 2, 3]),
});
```
##### getIndexed()
> **getIndexed**: \<`T`>(`log`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Get indexed parameters (alias for getIndexedTopics)
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log
###### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Array of indexed topic hashes
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const indexed = EventLog.getIndexed(log);
```
##### getIndexedTopics()
> **getIndexedTopics**: \<`T`>(`log`) => readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Get indexed topics (topic1-topic3) from log
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
###### Parameters
###### log
`T`
Event log
###### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Array of indexed topic hashes
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const indexed = EventLog.getIndexedTopics(log);
```
##### getSignature()
> **getSignature**: \<`T`>(`log`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Get event signature (alias for getTopic0)
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Event signature hash or undefined if no topics
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const sig = EventLog.getSignature(log);
```
##### getTopic0()
> **getTopic0**: \<`T`>(`log`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Get topic0 (event signature) from log
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
###### Parameters
###### log
`T`
Event log
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Topic0 hash or undefined if no topics
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const topic0 = EventLog.getTopic0(log);
```
##### isRemoved()
> **isRemoved**: \<`T`>(`log`) => `boolean`
Check if log was removed
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
###### Parameters
###### log
`T`
Event log
###### Returns
`boolean`
True if log was removed
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data, removed: true });
const removed = EventLog.isRemoved(log);
```
##### matchesAddress()
> **matchesAddress**: \<`T`>(`log`, `filterAddress`) => `boolean`
Check if log matches address filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterAddress
Address or array of addresses to match
[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[]
###### Returns
`boolean`
True if log matches address filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesAddress(log, Address.from("0x..."));
```
##### matchesFilter()
> **matchesFilter**: \<`T`>(`log`, `filter`) => `boolean`
Check if log matches complete filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filter
`Filter`
Complete filter object
###### Returns
`boolean`
True if log matches all filter criteria
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesFilter(log, {
address: Address.from("0x..."),
topics: [topic0, null, topic2],
fromBlock: 100n,
toBlock: 200n,
});
```
##### matchesTopics()
> **matchesTopics**: \<`T`>(`log`, `filterTopics`) => `boolean`
Check if log matches topic filter
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log to check
###### filterTopics
readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[]
Topic filter array
###### Returns
`boolean`
True if log matches topic filter
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesTopics(log, [topic0, null, topic2]);
```
##### sortLogs()
> **sortLogs**: \<`T`>(`logs`) => `T`\[]
Sort logs by block number and log index
###### Type Parameters
###### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
###### Parameters
###### logs
readonly `T`\[]
Array of event logs
###### Returns
`T`\[]
Sorted array of logs
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const logs = [log3, log1, log2];
const sorted = EventLog.sortLogs(logs);
```
##### wasRemoved()
> **wasRemoved**: \<`T`>(`log`) => `boolean`
Check if log was removed (alias for isRemoved)
###### Type Parameters
###### T
`T` *extends* `BrandedEventLog`
###### Parameters
###### log
`T`
Event log
###### Returns
`boolean`
True if log was removed
###### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data, removed: true });
const removed = EventLog.wasRemoved(log);
```
## Functions
### clone()
> **clone**\<`T`>(`log`): `T`
Defined in: [src/primitives/EventLog/clone.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/clone.js#L21)
Clone event log with deep copy of topics and data
#### Type Parameters
##### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
#### Parameters
##### log
`T`
Event log
#### Returns
`T`
Cloned log
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const cloned = EventLog.clone(log);
```
***
### copy()
> **copy**\<`T`>(`log`): `T`
Defined in: [src/primitives/EventLog/copy.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/copy.js#L23)
Copy event log (alias for clone)
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log
#### Returns
`T`
Copied log
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const copied = EventLog.copy(log);
```
***
### create()
> **create**(`params`): [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
Defined in: [src/primitives/EventLog/create.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/create.js#L36)
Create event log
#### Parameters
##### params
Event log parameters
###### address
[`AddressType`](Address.mdx#addresstype)
Contract address
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Block hash
###### blockNumber?
`bigint`
Block number
###### data
`Uint8Array`\<`ArrayBufferLike`>
Event data
###### logIndex?
`number`
Log index
###### removed?
`boolean`
Whether log was removed
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Event topics
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Transaction hash
###### transactionIndex?
`number`
Transaction index
#### Returns
[`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
EventLog object
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
import * as Hash from './primitives/Hash/index.js';
const log = EventLog.create({
address: Address.from("0x..."),
topics: [Hash.from("0x...")],
data: new Uint8Array([1, 2, 3]),
});
```
***
### filterLogs()
> **filterLogs**\<`T`>(`logs`, `filter`): `T`\[]
Defined in: [src/primitives/EventLog/filterLogs.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/filterLogs.js#L28)
Filter array of logs by filter criteria
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### logs
readonly `T`\[]
Array of event logs
##### filter
`Filter`
Filter criteria
#### Returns
`T`\[]
Filtered array of logs
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const logs = [log1, log2, log3];
const filtered = EventLog.filterLogs(logs, {
address: Address.from("0x..."),
topics: [topic0, null],
});
```
***
### from()
> **from**(`params`): `BrandedEventLog`
Defined in: [src/primitives/EventLog/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/from.js#L27)
Create EventLog from parameters
#### Parameters
##### params
Event log parameters
###### address
[`AddressType`](Address.mdx#addresstype)
###### blockHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### blockNumber?
`bigint`
###### data
`Uint8Array`\<`ArrayBufferLike`>
###### logIndex?
`number`
###### removed?
`boolean`
###### topics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
###### transactionHash?
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### transactionIndex?
`number`
#### Returns
`BrandedEventLog`
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
import * as Hash from './primitives/Hash/index.js';
const log = EventLog.from({
address: Address.from("0x..."),
topics: [Hash.from("0x...")],
data: new Uint8Array([1, 2, 3]),
});
```
***
### getIndexed()
> **getIndexed**\<`T`>(`log`): readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/EventLog/getIndexed.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/getIndexed.js#L24)
Get indexed parameters (alias for getIndexedTopics)
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log
#### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Array of indexed topic hashes
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const indexed = EventLog.getIndexed(log);
```
***
### getIndexedTopics()
> **getIndexedTopics**\<`T`>(`log`): readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/EventLog/getIndexedTopics.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/getIndexedTopics.js#L22)
Get indexed topics (topic1-topic3) from log
#### Type Parameters
##### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
#### Parameters
##### log
`T`
Event log
#### Returns
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Array of indexed topic hashes
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const indexed = EventLog.getIndexedTopics(log);
```
***
### getSignature()
> **getSignature**\<`T`>(`log`): [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Defined in: [src/primitives/EventLog/getSignature.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/getSignature.js#L24)
Get event signature (alias for getTopic0)
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Event signature hash or undefined if no topics
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const sig = EventLog.getSignature(log);
```
***
### getTopic0()
> **getTopic0**\<`T`>(`log`): [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Defined in: [src/primitives/EventLog/getTopic0.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/getTopic0.js#L22)
Get topic0 (event signature) from log
#### Type Parameters
##### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
#### Parameters
##### log
`T`
Event log
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype) | `undefined`
Topic0 hash or undefined if no topics
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const topic0 = EventLog.getTopic0(log);
```
***
### isRemoved()
> **isRemoved**\<`T`>(`log`): `boolean`
Defined in: [src/primitives/EventLog/isRemoved.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/isRemoved.js#L21)
Check if log was removed
#### Type Parameters
##### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
#### Parameters
##### log
`T`
Event log
#### Returns
`boolean`
True if log was removed
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data, removed: true });
const removed = EventLog.isRemoved(log);
```
***
### matchesAddress()
> **matchesAddress**\<`T`>(`log`, `filterAddress`): `boolean`
Defined in: [src/primitives/EventLog/matchesAddress.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/matchesAddress.js#L26)
Check if log matches address filter
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log to check
##### filterAddress
Address or array of addresses to match
[`AddressType`](Address.mdx#addresstype) | [`AddressType`](Address.mdx#addresstype)\[]
#### Returns
`boolean`
True if log matches address filter
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesAddress(log, Address.from("0x..."));
```
***
### matchesFilter()
> **matchesFilter**\<`T`>(`log`, `filter`): `boolean`
Defined in: [src/primitives/EventLog/matchesFilter.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/matchesFilter.js#L34)
Check if log matches complete filter
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log to check
##### filter
`Filter`
Complete filter object
#### Returns
`boolean`
True if log matches all filter criteria
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
import * as Address from './primitives/Address/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesFilter(log, {
address: Address.from("0x..."),
topics: [topic0, null, topic2],
fromBlock: 100n,
toBlock: 200n,
});
```
***
### matchesTopics()
> **matchesTopics**\<`T`>(`log`, `filterTopics`): `boolean`
Defined in: [src/primitives/EventLog/matchesTopics.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/matchesTopics.js#L26)
Check if log matches topic filter
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log to check
##### filterTopics
readonly ([`HashType`](../index/namespaces/HashType.mdx#hashtype) | [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`)\[]
Topic filter array
#### Returns
`boolean`
True if log matches topic filter
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data });
const matches = EventLog.matchesTopics(log, [topic0, null, topic2]);
```
***
### sortLogs()
> **sortLogs**\<`T`>(`logs`): `T`\[]
Defined in: [src/primitives/EventLog/sortLogs.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/sortLogs.js#L21)
Sort logs by block number and log index
#### Type Parameters
##### T
`T` *extends* [`EventLogType`](#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
#### Parameters
##### logs
readonly `T`\[]
Array of event logs
#### Returns
`T`\[]
Sorted array of logs
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const logs = [log3, log1, log2];
const sorted = EventLog.sortLogs(logs);
```
***
### wasRemoved()
> **wasRemoved**\<`T`>(`log`): `boolean`
Defined in: [src/primitives/EventLog/wasRemoved.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventLog/wasRemoved.js#L23)
Check if log was removed (alias for isRemoved)
#### Type Parameters
##### T
`T` *extends* `BrandedEventLog`
#### Parameters
##### log
`T`
Event log
#### Returns
`boolean`
True if log was removed
#### See
[https://voltaire.tevm.sh/primitives/eventlog](https://voltaire.tevm.sh/primitives/eventlog) for EventLog documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as EventLog from './primitives/EventLog/index.js';
const log = EventLog.create({ address, topics, data, removed: true });
const removed = EventLog.wasRemoved(log);
```
## References
### BrandedEventLogType
Renames and re-exports [EventLogType](#eventlogtype)
# primitives/EventSignature
Source: https://voltaire.tevm.sh/generated-api/primitives/EventSignature
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/EventSignature
# primitives/EventSignature
## Type Aliases
### EventSignatureLike
> **EventSignatureLike** = [`EventSignatureType`](#eventsignaturetype) | `string` | `Uint8Array`
Defined in: [src/primitives/EventSignature/EventSignatureType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/EventSignatureType.ts#L8)
***
### EventSignatureType
> **EventSignatureType** = `Uint8Array` & `object`
Defined in: [src/primitives/EventSignature/EventSignatureType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/EventSignatureType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"EventSignature"`
##### length
> `readonly` **length**: `32`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/EventSignature/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L15)
#### Parameters
##### a
[`EventSignatureType`](#eventsignaturetype)
##### b
[`EventSignatureType`](#eventsignaturetype)
#### Returns
`boolean`
***
### EventSignature
> `const` **EventSignature**: `object`
Defined in: [src/primitives/EventSignature/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L24)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`EventSignatureType`](#eventsignaturetype)
###### b
[`EventSignatureType`](#eventsignaturetype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`EventSignatureType`](#eventsignaturetype)
###### Parameters
###### value
[`EventSignatureLike`](#eventsignaturelike)
###### Returns
[`EventSignatureType`](#eventsignaturetype)
##### fromHex()
> **fromHex**: (`hex`) => [`EventSignatureType`](#eventsignaturetype)
###### Parameters
###### hex
`string`
###### Returns
[`EventSignatureType`](#eventsignaturetype)
##### fromSignature()
> **fromSignature**: (`signature`) => [`EventSignatureType`](#eventsignaturetype)
###### Parameters
###### signature
`string`
###### Returns
[`EventSignatureType`](#eventsignaturetype)
##### toHex()
> **toHex**: (`signature`) => `string`
###### Parameters
###### signature
[`EventSignatureType`](#eventsignaturetype)
###### Returns
`string`
***
### from()
> `const` **from**: (`value`) => [`EventSignatureType`](#eventsignaturetype) = `_from`
Defined in: [src/primitives/EventSignature/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L17)
#### Parameters
##### value
[`EventSignatureLike`](#eventsignaturelike)
#### Returns
[`EventSignatureType`](#eventsignaturetype)
***
### fromHex()
> `const` **fromHex**: (`hex`) => [`EventSignatureType`](#eventsignaturetype) = `_fromHex`
Defined in: [src/primitives/EventSignature/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L18)
#### Parameters
##### hex
`string`
#### Returns
[`EventSignatureType`](#eventsignaturetype)
***
### fromSignature()
> `const` **fromSignature**: (`signature`) => [`EventSignatureType`](#eventsignaturetype) = `_fromSignature`
Defined in: [src/primitives/EventSignature/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L19)
#### Parameters
##### signature
`string`
#### Returns
[`EventSignatureType`](#eventsignaturetype)
***
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/EventSignature/EventSignatureType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/EventSignatureType.ts#L10)
***
### toHex()
> `const` **toHex**: (`signature`) => `string` = `_toHex`
Defined in: [src/primitives/EventSignature/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/EventSignature/index.ts#L21)
#### Parameters
##### signature
[`EventSignatureType`](#eventsignaturetype)
#### Returns
`string`
# primitives/FeeOracle
Source: https://voltaire.tevm.sh/generated-api/primitives/FeeOracle
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/FeeOracle
# primitives/FeeOracle
FeeOracle - Gas price estimation and fee data
Provides current gas prices, EIP-1559 fee estimation, and fee watching.
## Example
```typescript theme={null}
import { FeeOracle } from '@tevm/voltaire/FeeOracle';
const oracle = FeeOracle({ provider });
// Get current fees
const feeData = await oracle.getFeeData();
console.log(`Gas price: ${feeData.gasPrice}`);
console.log(`Base fee: ${feeData.baseFeePerGas}`);
// Estimate EIP-1559 fees with priority
const fees = await oracle.estimateEip1559Fees({ priority: 'high' });
const tx = {
maxFeePerGas: fees.maxFeePerGas,
maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
};
// Watch for fee updates
const unsubscribe = oracle.watchFees(
(data) => console.log(`New base fee: ${data.baseFeePerGas}`),
{ pollingInterval: 12000 }
);
```
## Interfaces
### FeeEstimateOptions
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L27)
Fee estimation options
#### Properties
##### baseFeeMultiplier?
> `optional` **baseFeeMultiplier**: `number`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L31)
Multiplier for base fee (default: 1.25 for 25% buffer)
##### priority?
> `optional` **priority**: `"low"` | `"medium"` | `"high"`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L29)
Priority level for fee estimation
***
### FeeOracleInstance
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L37)
FeeOracle instance - provides gas price estimation
#### Methods
##### estimateEip1559Fees()
> **estimateEip1559Fees**(`options?`): `Promise`\<\{ `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; }>
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L68)
Estimate fees for an EIP-1559 transaction
###### Parameters
###### options?
[`FeeEstimateOptions`](#feeestimateoptions)
Fee estimation options
###### Returns
`Promise`\<\{ `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; }>
Suggested maxFeePerGas and maxPriorityFeePerGas
###### Example
```typescript theme={null}
const fees = await oracle.estimateEip1559Fees({ priority: 'high' });
const tx = {
maxFeePerGas: fees.maxFeePerGas,
maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
// ...
};
```
##### getFeeData()
> **getFeeData**(): `Promise`\<[`FeeDataType`](#feedatatype)>
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L50)
Get current fee data from the network
###### Returns
`Promise`\<[`FeeDataType`](#feedatatype)>
Current fee data including gas prices and base fees
###### Example
```typescript theme={null}
const feeData = await oracle.getFeeData();
console.log(`Gas price: ${feeData.gasPrice}`);
console.log(`Base fee: ${feeData.baseFeePerGas}`);
```
##### watchFees()
> **watchFees**(`callback`, `options?`): () => `void`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L89)
Watch for fee updates
###### Parameters
###### callback
(`feeData`) => `void`
Called when fees change
###### options?
Watch options
###### pollingInterval?
`number`
###### signal?
`AbortSignal`
###### Returns
Unsubscribe function
> (): `void`
###### Returns
`void`
###### Example
```typescript theme={null}
const unsubscribe = oracle.watchFees(
(feeData) => console.log(`New base fee: ${feeData.baseFeePerGas}`),
{ pollingInterval: 12000 }
);
// Later: unsubscribe();
```
***
### FeeOracleOptions
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L98)
Options for creating a FeeOracle
#### Properties
##### historyBlocks?
> `optional` **historyBlocks**: `number`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L106)
History blocks to analyze for priority fee (default: 4)
##### priorityFeePercentile?
> `optional` **priorityFeePercentile**: `number`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L104)
Default priority fee percentile (default: 50)
##### provider
> **provider**: `object`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L100)
EIP-1193 provider
###### request()
> **request**(`args`): `Promise`\<`unknown`>
###### Parameters
###### args
###### method
`string`
###### params?
`unknown`\[]
###### Returns
`Promise`\<`unknown`>
## Type Aliases
### FeeDataType
> **FeeDataType** = `object` & `object`
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L9)
Fee data returned by FeeOracle
Contains current gas price information for transaction fee estimation.
Supports both legacy (gasPrice) and EIP-1559 (maxFeePerGas, maxPriorityFeePerGas) fee models.
#### Type Declaration
##### baseFeePerGas
> `readonly` **baseFeePerGas**: `bigint` | `null`
Current base fee per gas (EIP-1559)
##### blobBaseFee
> `readonly` **blobBaseFee**: `bigint` | `null`
Current blob base fee (EIP-4844, null if not supported)
##### blockNumber
> `readonly` **blockNumber**: `bigint`
Block number this data was fetched from
##### gasPrice
> `readonly` **gasPrice**: `bigint`
Current gas price (legacy transactions)
##### maxFeePerGas
> `readonly` **maxFeePerGas**: `bigint` | `null`
Suggested max fee per gas (EIP-1559)
##### maxPriorityFeePerGas
> `readonly` **maxPriorityFeePerGas**: `bigint` | `null`
Suggested max priority fee per gas (EIP-1559)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"FeeData"`
***
### FeeOracleFactory()
> **FeeOracleFactory** = (`options`) => [`FeeOracleInstance`](#feeoracleinstance)
Defined in: [src/primitives/FeeOracle/FeeOracleType.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracleType.ts#L112)
FeeOracle factory function type
#### Parameters
##### options
[`FeeOracleOptions`](#feeoracleoptions)
#### Returns
[`FeeOracleInstance`](#feeoracleinstance)
## Functions
### FeeOracle()
> **FeeOracle**(`options`): [`FeeOracleInstance`](#feeoracleinstance)
Defined in: [src/primitives/FeeOracle/FeeOracle.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FeeOracle/FeeOracle.js#L44)
Create a FeeOracle instance
#### Parameters
##### options
[`FeeOracleOptions`](#feeoracleoptions)
#### Returns
[`FeeOracleInstance`](#feeoracleinstance)
#### Example
```typescript theme={null}
const oracle = FeeOracle({ provider });
// Get current fees
const feeData = await oracle.getFeeData();
console.log(`Base fee: ${feeData.baseFeePerGas}`);
// Estimate EIP-1559 fees
const fees = await oracle.estimateEip1559Fees({ priority: 'high' });
// Watch for fee updates
oracle.watchFees((data) => console.log(data));
```
# primitives/FilterId
Source: https://voltaire.tevm.sh/generated-api/primitives/FilterId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/FilterId
# primitives/FilterId
## Classes
### InvalidFilterIdError
Defined in: [src/primitives/FilterId/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/errors.js#L4)
Error thrown when FilterId is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidFilterIdError**(`message`, `details?`): [`InvalidFilterIdError`](#invalidfilteriderror)
Defined in: [src/primitives/FilterId/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/errors.js#L9)
###### Parameters
###### message
`string`
###### details?
`object`
###### Returns
[`InvalidFilterIdError`](#invalidfilteriderror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `object` | `undefined`
Defined in: [src/primitives/FilterId/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/errors.js#L13)
##### name
> **name**: `string`
Defined in: [src/primitives/FilterId/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### FilterIdType
> **FilterIdType** = `string` & `object`
Defined in: [src/primitives/FilterId/FilterIdType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/FilterIdType.ts#L8)
Filter identifier returned by eth\_newFilter, eth\_newBlockFilter, eth\_newPendingTransactionFilter
Opaque identifier used to track active filters on a node. Typically a hex string like "0x1".
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"FilterId"`
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/FilterId/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/equals.js#L13)
Compare two FilterIds for equality
#### Parameters
##### a
[`FilterIdType`](#filteridtype)
##### b
[`FilterIdType`](#filteridtype)
#### Returns
`boolean`
#### Example
```javascript theme={null}
import * as FilterId from './primitives/FilterId/index.js';
const equal = FilterId.equals(id1, id2);
```
***
### from()
> **from**(`value`): [`FilterIdType`](#filteridtype)
Defined in: [src/primitives/FilterId/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/from.js#L15)
Create FilterId from string
#### Parameters
##### value
`string`
Filter ID string
#### Returns
[`FilterIdType`](#filteridtype)
#### Throws
#### Example
```javascript theme={null}
import * as FilterId from './primitives/FilterId/index.js';
const id = FilterId.from("0x1");
```
***
### toString()
> **toString**(`filterId`): `string`
Defined in: [src/primitives/FilterId/toString.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FilterId/toString.js#L13)
Convert FilterId to string
#### Parameters
##### filterId
[`FilterIdType`](#filteridtype)
#### Returns
`string`
#### Example
```javascript theme={null}
import * as FilterId from './primitives/FilterId/index.js';
const str = FilterId.toString(id); // "0x1"
```
# primitives/ForkId
Source: https://voltaire.tevm.sh/generated-api/primitives/ForkId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ForkId
# primitives/ForkId
## Type Aliases
### ForkIdType
> **ForkIdType** = `object`
Defined in: [src/primitives/ForkId/ForkIdType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/ForkIdType.ts#L9)
EIP-2124 Fork Identifier
Used in DevP2P for fork detection and network validation
#### See
[https://eips.ethereum.org/EIPS/eip-2124](https://eips.ethereum.org/EIPS/eip-2124)
#### Properties
##### hash
> `readonly` **hash**: `Uint8Array`
Defined in: [src/primitives/ForkId/ForkIdType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/ForkIdType.ts#L13)
CRC32 checksum of all fork hashes up to this point (4 bytes)
##### next
> `readonly` **next**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/ForkId/ForkIdType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/ForkIdType.ts#L18)
Block number of next upcoming fork (0 if no known forks)
## Variables
### ForkId
> `const` **ForkId**: `object`
Defined in: [src/primitives/ForkId/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/index.ts#L28)
#### Type Declaration
##### from()
> **from**: (`value`) => [`ForkIdType`](#forkidtype)
Create ForkId from hash and next block number
###### Parameters
###### value
Fork ID components
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
###### Returns
[`ForkIdType`](#forkidtype)
ForkId
###### Example
```typescript theme={null}
const forkId = ForkId.from({
hash: new Uint8Array([0xfc, 0x64, 0xec, 0x04]),
next: 1920000n,
});
```
##### matches()
> **matches**: (`local`, `remote`) => `boolean`
###### Parameters
###### local
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
###### remote
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
###### Returns
`boolean`
##### toBytes()
> **toBytes**: (`forkId`) => `Uint8Array`
###### Parameters
###### forkId
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
###### Returns
`Uint8Array`
## Functions
### \_matches()
> **\_matches**(`local`, `remote`): `boolean`
Defined in: [src/primitives/ForkId/matches.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/matches.js#L23)
Check if two ForkIds are compatible (EIP-2124 fork validation)
Compatible if:
1. Hashes match and next blocks match (identical)
2. Hashes match and remote next is 0 (remote knows of no future forks)
3. Hashes match and local next is 0 (local knows of no future forks)
4. Hashes differ but remote next is >= local next (remote is ahead but compatible)
#### Parameters
##### local
[`ForkIdType`](#forkidtype)
Local ForkId
##### remote
[`ForkIdType`](#forkidtype)
Remote peer's ForkId
#### Returns
`boolean`
True if compatible
#### Example
```typescript theme={null}
const compatible = ForkId.matches(localForkId, peerForkId);
if (!compatible) {
console.log("Fork incompatible - disconnect peer");
}
```
***
### \_toBytes()
> **\_toBytes**(`forkId`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/ForkId/toBytes.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/toBytes.js#L15)
Encode ForkId to bytes (for DevP2P handshake)
Format: \[hash (4 bytes) || next (8 bytes big-endian)]
#### Parameters
##### forkId
[`ForkIdType`](#forkidtype)
ForkId to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
12-byte encoding
#### Example
```typescript theme={null}
const bytes = ForkId.toBytes(forkId);
console.log(bytes.length); // 12
```
***
### from()
> **from**(`value`): [`ForkIdType`](#forkidtype)
Defined in: [src/primitives/ForkId/from.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/from.js#L18)
Create ForkId from hash and next block number
#### Parameters
##### value
Fork ID components
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
#### Returns
[`ForkIdType`](#forkidtype)
ForkId
#### Example
```typescript theme={null}
const forkId = ForkId.from({
hash: new Uint8Array([0xfc, 0x64, 0xec, 0x04]),
next: 1920000n,
});
```
***
### matches()
> **matches**(`local`, `remote`): `boolean`
Defined in: [src/primitives/ForkId/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/index.ts#L17)
#### Parameters
##### local
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
##### remote
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### toBytes()
> **toBytes**(`forkId`): `Uint8Array`
Defined in: [src/primitives/ForkId/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ForkId/index.ts#L13)
#### Parameters
##### forkId
###### hash
`string` | `number` | `Uint8Array`\<`ArrayBufferLike`>
###### next
`string` | `number` | `bigint`
#### Returns
`Uint8Array`
# primitives/FunctionSignature
Source: https://voltaire.tevm.sh/generated-api/primitives/FunctionSignature
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/FunctionSignature
# primitives/FunctionSignature
## Type Aliases
### FunctionSignatureLike
> **FunctionSignatureLike** = [`FunctionSignatureType`](#functionsignaturetype) | `string` | [`SelectorType`](Selector.mdx#selectortype)
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L10)
***
### FunctionSignatureType
> **FunctionSignatureType** = `object`
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L3)
#### Properties
##### inputs
> `readonly` **inputs**: readonly `string`\[]
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L7)
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L6)
##### selector
> `readonly` **selector**: [`SelectorType`](Selector.mdx#selectortype)
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L4)
##### signature
> `readonly` **signature**: `string`
Defined in: [src/primitives/FunctionSignature/FunctionSignatureType.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/FunctionSignatureType.ts#L5)
## Variables
### FunctionSignature
> `const` **FunctionSignature**: `object`
Defined in: [src/primitives/FunctionSignature/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L44)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`FunctionSignatureType`](#functionsignaturetype)
###### b
[`FunctionSignatureType`](#functionsignaturetype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`FunctionSignatureType`](#functionsignaturetype)
###### Parameters
###### value
[`FunctionSignatureLike`](#functionsignaturelike)
###### Returns
[`FunctionSignatureType`](#functionsignaturetype)
##### fromSignature()
> **fromSignature**: (`signature`) => [`FunctionSignatureType`](#functionsignaturetype)
###### Parameters
###### signature
`string`
###### Returns
[`FunctionSignatureType`](#functionsignaturetype)
##### parseSignature()
> **parseSignature**: (`signature`) => `object`
###### Parameters
###### signature
`string`
###### Returns
`object`
###### inputs
> **inputs**: `string`\[]
###### name
> **name**: `string`
##### toHex()
> **toHex**: (`functionSig`) => `string`
###### Parameters
###### functionSig
[`FunctionSignatureType`](#functionsignaturetype)
###### Returns
`string`
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/FunctionSignature/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L17)
#### Parameters
##### a
[`FunctionSignatureType`](#functionsignaturetype)
##### b
[`FunctionSignatureType`](#functionsignaturetype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`FunctionSignatureType`](#functionsignaturetype)
Defined in: [src/primitives/FunctionSignature/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L24)
#### Parameters
##### value
[`FunctionSignatureLike`](#functionsignaturelike)
#### Returns
[`FunctionSignatureType`](#functionsignaturetype)
***
### fromSignature()
> **fromSignature**(`signature`): [`FunctionSignatureType`](#functionsignaturetype)
Defined in: [src/primitives/FunctionSignature/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L28)
#### Parameters
##### signature
`string`
#### Returns
[`FunctionSignatureType`](#functionsignaturetype)
***
### parseSignature()
> **parseSignature**(`signature`): `object`
Defined in: [src/primitives/FunctionSignature/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L32)
#### Parameters
##### signature
`string`
#### Returns
`object`
##### inputs
> **inputs**: `string`\[]
##### name
> **name**: `string`
***
### toHex()
> **toHex**(`functionSig`): `string`
Defined in: [src/primitives/FunctionSignature/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/FunctionSignature/index.ts#L39)
#### Parameters
##### functionSig
[`FunctionSignatureType`](#functionsignaturetype)
#### Returns
`string`
# primitives/Gas
Source: https://voltaire.tevm.sh/generated-api/primitives/Gas
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Gas
# primitives/Gas
## Type Aliases
### GasLimitType
> **GasLimitType** = `bigint` & `object`
Defined in: [src/primitives/Gas/GasLimitType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/GasLimitType.ts#L7)
Branded GasLimit type - prevents gas parameter confusion
Represents maximum gas units for a transaction as a branded bigint
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"GasLimit"`
***
### GasPriceType
> **GasPriceType** = `bigint` & `object`
Defined in: [src/primitives/Gas/GasPriceType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/GasPriceType.ts#L7)
Branded GasPrice type - prevents gas parameter confusion
Represents gas price in wei per gas unit as a branded bigint
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"GasPrice"`
## Variables
### DEFAULT\_LIMIT
> `const` **DEFAULT\_LIMIT**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Gas/gasLimitConstants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitConstants.js#L6)
***
### ERC20\_TRANSFER
> `const` **ERC20\_TRANSFER**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Gas/gasLimitConstants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitConstants.js#L5)
***
### GasLimit
> `const` **GasLimit**: `object`
Defined in: [src/primitives/Gas/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L54)
#### Type Declaration
##### from()
> **from**: (`value`) => [`GasLimitType`](#gaslimittype) = `gasLimitFrom`
Create GasLimit from number, bigint, or hex string
###### Parameters
###### value
Value to convert
`string` | `number` | `bigint`
###### Returns
[`GasLimitType`](#gaslimittype)
Gas limit
###### Example
```typescript theme={null}
const limit1 = GasLimit.from(21000);
const limit2 = GasLimit.from(21000n);
const limit3 = GasLimit.from("0x5208");
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint` = `gasLimitToBigInt`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`value`) => `number` = `gasLimitToNumber`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`number`
***
### GasPrice
> `const` **GasPrice**: `object`
Defined in: [src/primitives/Gas/index.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L60)
#### Type Declaration
##### from()
> **from**: (`value`) => [`GasPriceType`](#gaspricetype) = `gasPriceFrom`
Create GasPrice from number, bigint, or hex string
###### Parameters
###### value
Value in wei
`string` | `number` | `bigint`
###### Returns
[`GasPriceType`](#gaspricetype)
Gas price
###### Example
```typescript theme={null}
const price1 = GasPrice.from(20_000_000_000); // 20 gwei
const price2 = GasPrice.from(20_000_000_000n);
const price3 = GasPrice.from("0x4a817c800");
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`GasPriceType`](#gaspricetype) = `gasPriceFromGwei`
Create GasPrice from gwei
###### Parameters
###### gwei
Value in gwei
`number` | `bigint`
###### Returns
[`GasPriceType`](#gaspricetype)
Gas price in wei
###### Example
```typescript theme={null}
const price = GasPrice.fromGwei(20); // 20 gwei = 20000000000 wei
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint` = `gasPriceToBigInt`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGwei()
> **toGwei**: (`value`) => `bigint` = `gasPriceToGwei`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
***
### SIMPLE\_TRANSFER
> `const` **SIMPLE\_TRANSFER**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Gas/gasLimitConstants.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitConstants.js#L4)
## Functions
### \_gasLimitToBigInt()
> **\_gasLimitToBigInt**(`this`): `bigint`
Defined in: [src/primitives/Gas/gasLimitToBigInt.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitToBigInt.js#L14)
Convert GasLimit to bigint
#### Parameters
##### this
[`GasLimitType`](#gaslimittype)
#### Returns
`bigint`
BigInt
#### Example
```typescript theme={null}
const n = GasLimit._toBigInt.call(limit);
```
***
### \_gasLimitToNumber()
> **\_gasLimitToNumber**(`this`): `number`
Defined in: [src/primitives/Gas/gasLimitToNumber.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitToNumber.js#L15)
Convert GasLimit to number
#### Parameters
##### this
[`GasLimitType`](#gaslimittype)
#### Returns
`number`
Number
#### Throws
If value exceeds safe integer range
#### Example
```typescript theme={null}
const n = GasLimit._toNumber.call(limit);
```
***
### \_gasPriceToBigInt()
> **\_gasPriceToBigInt**(`this`): `bigint`
Defined in: [src/primitives/Gas/gasPriceToBigInt.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasPriceToBigInt.js#L14)
Convert GasPrice to bigint
#### Parameters
##### this
[`GasPriceType`](#gaspricetype)
#### Returns
`bigint`
BigInt in wei
#### Example
```typescript theme={null}
const n = GasPrice._toBigInt.call(price);
```
***
### \_gasPriceToGwei()
> **\_gasPriceToGwei**(`this`): `bigint`
Defined in: [src/primitives/Gas/gasPriceToGwei.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasPriceToGwei.js#L16)
Convert GasPrice to gwei
#### Parameters
##### this
[`GasPriceType`](#gaspricetype)
#### Returns
`bigint`
Value in gwei
#### Example
```typescript theme={null}
const gwei = GasPrice._toGwei.call(price);
```
***
### gasLimitFrom()
> **gasLimitFrom**(`value`): [`GasLimitType`](#gaslimittype)
Defined in: [src/primitives/Gas/gasLimitFrom.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasLimitFrom.js#L16)
Create GasLimit from number, bigint, or hex string
#### Parameters
##### value
Value to convert
`string` | `number` | `bigint`
#### Returns
[`GasLimitType`](#gaslimittype)
Gas limit
#### Example
```typescript theme={null}
const limit1 = GasLimit.from(21000);
const limit2 = GasLimit.from(21000n);
const limit3 = GasLimit.from("0x5208");
```
***
### gasLimitToBigInt()
> **gasLimitToBigInt**(`value`): `bigint`
Defined in: [src/primitives/Gas/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L27)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### gasLimitToNumber()
> **gasLimitToNumber**(`value`): `number`
Defined in: [src/primitives/Gas/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L31)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`number`
***
### gasPriceFrom()
> **gasPriceFrom**(`value`): [`GasPriceType`](#gaspricetype)
Defined in: [src/primitives/Gas/gasPriceFrom.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasPriceFrom.js#L16)
Create GasPrice from number, bigint, or hex string
#### Parameters
##### value
Value in wei
`string` | `number` | `bigint`
#### Returns
[`GasPriceType`](#gaspricetype)
Gas price
#### Example
```typescript theme={null}
const price1 = GasPrice.from(20_000_000_000); // 20 gwei
const price2 = GasPrice.from(20_000_000_000n);
const price3 = GasPrice.from("0x4a817c800");
```
***
### gasPriceFromGwei()
> **gasPriceFromGwei**(`gwei`): [`GasPriceType`](#gaspricetype)
Defined in: [src/primitives/Gas/gasPriceFromGwei.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/gasPriceFromGwei.js#L16)
Create GasPrice from gwei
#### Parameters
##### gwei
Value in gwei
`number` | `bigint`
#### Returns
[`GasPriceType`](#gaspricetype)
Gas price in wei
#### Example
```typescript theme={null}
const price = GasPrice.fromGwei(20); // 20 gwei = 20000000000 wei
```
***
### gasPriceToBigInt()
> **gasPriceToBigInt**(`value`): `bigint`
Defined in: [src/primitives/Gas/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L42)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### gasPriceToGwei()
> **gasPriceToGwei**(`value`): `bigint`
Defined in: [src/primitives/Gas/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Gas/index.ts#L46)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/primitives/GasConstants/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / primitives/GasConstants
# primitives/GasConstants
## Namespaces
* [Precompile](namespaces/Precompile.mdx)
## Type Aliases
### CallDetails
> **CallDetails** = `object`
Defined in: [src/primitives/GasConstants/types.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L44)
Call operation details
#### Properties
##### gas
> **gas**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L48)
##### hasValue
> **hasValue**: `boolean`
Defined in: [src/primitives/GasConstants/types.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L46)
##### isNewAccount
> **isNewAccount**: `boolean`
Defined in: [src/primitives/GasConstants/types.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L47)
##### isWarm
> **isWarm**: `boolean`
Defined in: [src/primitives/GasConstants/types.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L45)
***
### Config
> **Config** = `object`
Defined in: [src/primitives/GasConstants/types.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L18)
Gas configuration for hardfork-specific calculations
#### Properties
##### hardfork
> **hardfork**: [`Hardfork`](#hardfork-1)
Defined in: [src/primitives/GasConstants/types.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L19)
***
### CostResult
> **CostResult** = `object`
Defined in: [src/primitives/GasConstants/types.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L25)
Gas cost calculation result
#### Properties
##### base
> **base**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L26)
##### dynamic
> **dynamic**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L27)
##### total
> **total**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L28)
***
### Hardfork
> **Hardfork** = `"homestead"` | `"byzantium"` | `"constantinople"` | `"istanbul"` | `"berlin"` | `"london"` | `"paris"` | `"shanghai"` | `"cancun"`
Defined in: [src/primitives/GasConstants/types.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L4)
Ethereum hardfork identifiers
***
### MemoryExpansion
> **MemoryExpansion** = `object`
Defined in: [src/primitives/GasConstants/types.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L34)
Memory expansion details
#### Properties
##### expansionCost
> **expansionCost**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L37)
##### newCost
> **newCost**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L36)
##### oldCost
> **oldCost**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L35)
##### words
> **words**: `bigint`
Defined in: [src/primitives/GasConstants/types.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/types.ts#L38)
## Variables
### BlobBaseFee
> `const` **BlobBaseFee**: `2n` = `2n`
Defined in: [src/primitives/GasConstants/constants.js:325](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L325)
BLOBBASEFEE opcode cost (2 gas)
***
### BlobHash
> `const` **BlobHash**: `3n` = `3n`
Defined in: [src/primitives/GasConstants/constants.js:319](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L319)
BLOBHASH opcode cost (3 gas)
***
### BrandedGasConstants
> `const` **BrandedGasConstants**: `object`
Defined in: [src/primitives/GasConstants/index.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/index.ts#L74)
#### Type Declaration
##### calculateCallCost()
> **calculateCallCost**: (`isWarm`, `hasValue`, `isNewAccount`, `availableGas`) => `object`
Calculate CALL operation gas cost
###### Parameters
###### isWarm
`boolean`
Whether target account is warm
###### hasValue
`boolean`
Whether call transfers value
###### isNewAccount
`boolean`
Whether target account doesn't exist
###### availableGas
`bigint`
Gas available for the call
###### Returns
`object`
Gas cost breakdown
###### base
> **base**: `bigint`
###### dynamic
> **dynamic**: `bigint`
###### forwarded
> **forwarded**: `bigint`
###### stipend
> **stipend**: `bigint`
###### total
> **total**: `bigint`
###### Example
```typescript theme={null}
const result = calculateCallCost(true, true, false, 100000n);
// { base, dynamic, stipend, forwarded, total }
```
##### calculateCopyCost()
> **calculateCopyCost**: (`size`) => `bigint`
Calculate copy operation gas cost
###### Parameters
###### size
`bigint`
Size of data to copy in bytes
###### Returns
`bigint`
Gas cost
##### calculateCreateCost()
> **calculateCreateCost**: (`initcodeSize`, `deployedSize`) => `object`
Calculate contract creation gas cost
###### Parameters
###### initcodeSize
`bigint`
Size of initcode in bytes
###### deployedSize
`bigint`
Size of deployed bytecode in bytes
###### Returns
`object`
Gas cost breakdown
###### base
> **base**: `bigint`
###### dynamic
> **dynamic**: `bigint`
###### total
> **total**: `bigint`
###### Throws
If initcode size exceeds maximum
###### Example
```typescript theme={null}
const result = calculateCreateCost(1000n, 500n);
// { base: 32000n, initcode: ..., deployed: ..., total: ... }
```
##### calculateKeccak256Cost()
> **calculateKeccak256Cost**: (`dataSize`) => `bigint`
Calculate KECCAK256 gas cost
###### Parameters
###### dataSize
`bigint`
Size of data in bytes
###### Returns
`bigint`
Total gas cost
###### Example
```typescript theme={null}
const cost = calculateKeccak256Cost(64n); // 30 + (2 * 6) = 42 gas
```
##### calculateLogCost()
> **calculateLogCost**: (`topicCount`, `dataSize`) => `bigint`
Calculate LOG gas cost
###### Parameters
###### topicCount
`bigint`
Number of topics (0-4)
###### dataSize
`bigint`
Size of log data in bytes
###### Returns
`bigint`
Total gas cost
###### Example
```typescript theme={null}
const cost = calculateLogCost(2n, 64n); // LOG2 with 64 bytes
// 375 + (2 * 375) + (64 * 8) = 1637 gas
```
##### calculateMaxRefund()
> **calculateMaxRefund**: (`gasUsed`) => `bigint`
Calculate maximum gas refund
###### Parameters
###### gasUsed
`bigint`
Total gas used in transaction
###### Returns
`bigint`
Maximum refundable gas
##### calculateMemoryExpansionCost()
> **calculateMemoryExpansionCost**: (`oldSize`, `newSize`) => `object`
Calculate memory expansion cost
###### Parameters
###### oldSize
`bigint`
Previous memory size in bytes
###### newSize
`bigint`
New memory size in bytes
###### Returns
`object`
Memory expansion cost
###### expansionCost
> **expansionCost**: `bigint`
###### newCost
> **newCost**: `bigint`
###### oldCost
> **oldCost**: `bigint`
###### words
> **words**: `bigint`
###### Example
```typescript theme={null}
const expansion = calculateMemoryExpansionCost(64n, 128n);
// { oldCost, newCost, expansionCost, words }
```
##### calculateSstoreCost()
> **calculateSstoreCost**: (`isWarm`, `currentValue`, `newValue`) => `object`
Calculate SSTORE gas cost
###### Parameters
###### isWarm
`boolean`
Whether slot is warm (previously accessed)
###### currentValue
`bigint`
Current storage value (0n if empty)
###### newValue
`bigint`
New storage value
###### Returns
`object`
Gas cost and potential refund
###### cost
> **cost**: `bigint`
###### refund
> **refund**: `bigint`
###### Example
```typescript theme={null}
const result = calculateSstoreCost(false, 0n, 100n);
// { cost: 22100n, refund: 0n } - cold + set
```
##### calculateTxIntrinsicGas()
> **calculateTxIntrinsicGas**: (`data`, `isCreate`) => `bigint`
Calculate transaction intrinsic gas cost
###### Parameters
###### data
`Uint8Array`\<`ArrayBufferLike`>
Transaction calldata
###### isCreate
`boolean`
Whether transaction creates a contract
###### Returns
`bigint`
Intrinsic gas cost
###### Example
```typescript theme={null}
const data = new Uint8Array([0, 1, 2, 0, 0]);
const cost = calculateTxIntrinsicGas(data, false);
// 21000 + (3 * 4) + (2 * 16) = 21044 gas
```
##### callCost()
> **callCost**: (`this`) => `object`
Calculate CALL operation gas cost (convenience form with this:)
###### Parameters
###### this
###### availableGas
`bigint`
###### hasValue
`boolean`
###### isNewAccount
`boolean`
###### isWarm
`boolean`
###### Returns
`object`
###### base
> **base**: `bigint`
###### dynamic
> **dynamic**: `bigint`
###### forwarded
> **forwarded**: `bigint`
###### stipend
> **stipend**: `bigint`
###### total
> **total**: `bigint`
##### copyCost()
> **copyCost**: (`this`) => `bigint`
Calculate copy operation gas cost (convenience form with this:)
###### Parameters
###### this
`bigint`
###### Returns
`bigint`
##### createCost()
> **createCost**: (`this`) => `object`
Calculate contract creation gas cost (convenience form with this:)
###### Parameters
###### this
###### deployedSize
`bigint`
###### initcodeSize
`bigint`
###### Returns
`object`
###### base
> **base**: `bigint`
###### dynamic
> **dynamic**: `bigint`
###### total
> **total**: `bigint`
##### getColdAccountAccessCost()
> **getColdAccountAccessCost**: (`hardfork`) => `bigint`
Get cold account access cost for hardfork
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`bigint`
Gas cost
##### getColdSloadCost()
> **getColdSloadCost**: (`hardfork`) => `bigint`
Get cold storage cost for hardfork
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`bigint`
Gas cost
##### getSelfdestructRefund()
> **getSelfdestructRefund**: (`hardfork`) => `bigint`
Get selfdestruct refund for hardfork
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`bigint`
Gas refund amount
##### getSstoreRefund()
> **getSstoreRefund**: (`hardfork`) => `bigint`
Get storage refund for hardfork
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`bigint`
Gas refund amount
##### hasEIP1153()
> **hasEIP1153**: (`hardfork`) => `boolean`
Check if a hardfork includes EIP-1153 (transient storage)
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`boolean`
Whether hardfork includes EIP-1153
##### hasEIP2929()
> **hasEIP2929**: (`hardfork`) => `boolean`
Check if a hardfork includes EIP-2929 (cold/warm access costs)
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`boolean`
Whether hardfork includes EIP-2929
##### hasEIP3529()
> **hasEIP3529**: (`hardfork`) => `boolean`
Check if a hardfork includes EIP-3529 (reduced refunds)
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`boolean`
Whether hardfork includes EIP-3529
##### hasEIP3860()
> **hasEIP3860**: (`hardfork`) => `boolean`
Check if a hardfork includes EIP-3860 (initcode size limit)
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`boolean`
Whether hardfork includes EIP-3860
##### hasEIP4844()
> **hasEIP4844**: (`hardfork`) => `boolean`
Check if a hardfork includes EIP-4844 (blob transactions)
###### Parameters
###### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
###### Returns
`boolean`
Whether hardfork includes EIP-4844
##### keccak256Cost()
> **keccak256Cost**: (`this`) => `bigint`
Calculate KECCAK256 gas cost (convenience form with this:)
###### Parameters
###### this
`bigint`
###### Returns
`bigint`
Total gas cost
##### logCost()
> **logCost**: (`this`) => `bigint`
Calculate LOG gas cost (convenience form with this:)
###### Parameters
###### this
###### dataSize
`bigint`
###### topicCount
`bigint`
###### Returns
`bigint`
##### maxRefund()
> **maxRefund**: (`this`) => `bigint`
Calculate maximum gas refund (convenience form with this:)
###### Parameters
###### this
`bigint`
###### Returns
`bigint`
##### memoryExpansionCost()
> **memoryExpansionCost**: (`this`) => `object`
Calculate memory expansion cost (convenience form with this:)
###### Parameters
###### this
###### newSize
`bigint`
###### oldSize
`bigint`
###### Returns
`object`
###### expansionCost
> **expansionCost**: `bigint`
###### newCost
> **newCost**: `bigint`
###### oldCost
> **oldCost**: `bigint`
###### words
> **words**: `bigint`
##### Precompile
> **Precompile**: [`Precompile`](namespaces/Precompile.mdx)
ECRECOVER (address 0x01) - Fixed cost
##### sstoreCost()
> **sstoreCost**: (`this`) => `object`
Calculate SSTORE gas cost (convenience form with this:)
###### Parameters
###### this
###### currentValue
`bigint`
###### isWarm
`boolean`
###### newValue
`bigint`
###### Returns
`object`
###### cost
> **cost**: `bigint`
###### refund
> **refund**: `bigint`
##### txIntrinsicGas()
> **txIntrinsicGas**: (`this`) => `bigint`
Calculate transaction intrinsic gas cost (convenience form with this:)
###### Parameters
###### this
###### data
`Uint8Array`
###### isCreate
`boolean`
###### Returns
`bigint`
***
### Call
> `const` **Call**: `40n` = `40n`
Defined in: [src/primitives/GasConstants/constants.js:177](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L177)
Base CALL cost (40 gas)
***
### CallCode
> `const` **CallCode**: `700n` = `700n`
Defined in: [src/primitives/GasConstants/constants.js:201](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L201)
CALLCODE cost (700 gas) - EIP-150
***
### CallGasRetentionDivisor
> `const` **CallGasRetentionDivisor**: `64n` = `64n`
Defined in: [src/primitives/GasConstants/constants.js:231](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L231)
63/64 rule divisor for gas forwarding
***
### CallNewAccount
> `const` **CallNewAccount**: `25000n` = `25000n`
Defined in: [src/primitives/GasConstants/constants.js:195](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L195)
Additional cost for new account creation (25000 gas)
***
### CallStipend
> `const` **CallStipend**: `2300n` = `2300n`
Defined in: [src/primitives/GasConstants/constants.js:183](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L183)
Gas stipend for value transfer (2300 gas)
***
### CallValueTransfer
> `const` **CallValueTransfer**: `9000n` = `9000n`
Defined in: [src/primitives/GasConstants/constants.js:189](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L189)
Additional cost for value transfer (9000 gas)
***
### ColdAccountAccess
> `const` **ColdAccountAccess**: `2600n` = `2600n`
Defined in: [src/primitives/GasConstants/constants.js:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L93)
Cold account access (2600 gas) - EIP-2929
BALANCE, EXTCODESIZE, EXTCODECOPY, EXTCODEHASH, CALL family
***
### ColdSload
> `const` **ColdSload**: `2100n` = `2100n`
Defined in: [src/primitives/GasConstants/constants.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L86)
Cold SLOAD (2100 gas) - EIP-2929
***
### Copy
> `const` **Copy**: `3n` = `3n`
Defined in: [src/primitives/GasConstants/constants.js:303](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L303)
Per word for copy operations (3 gas)
***
### Create
> `const` **Create**: `32000n` = `32000n`
Defined in: [src/primitives/GasConstants/constants.js:171](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L171)
Base CREATE cost (32000 gas)
***
### CreateData
> `const` **CreateData**: `200n` = `200n`
Defined in: [src/primitives/GasConstants/constants.js:257](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L257)
Per-byte cost for deployed code (200 gas)
***
### DelegateCall
> `const` **DelegateCall**: `700n` = `700n`
Defined in: [src/primitives/GasConstants/constants.js:207](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L207)
DELEGATECALL cost (700 gas) - EIP-150
***
### ExtStep
> `const` **ExtStep**: `20n` = `20n`
Defined in: [src/primitives/GasConstants/constants.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L54)
External account interaction (20 gas)
BALANCE, EXTCODESIZE, BLOCKHASH
***
### FastestStep
> `const` **FastestStep**: `3n` = `3n`
Defined in: [src/primitives/GasConstants/constants.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L26)
Simple arithmetic and logic (3 gas)
ADD, SUB, NOT, LT, GT, SLT, SGT, EQ, ISZERO, AND, OR, XOR,
CALLDATALOAD, MLOAD, MSTORE, MSTORE8, PUSH, DUP, SWAP
***
### FastStep
> `const` **FastStep**: `5n` = `5n`
Defined in: [src/primitives/GasConstants/constants.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L33)
Multiplication and division (5 gas)
MUL, DIV, SDIV, MOD, SMOD
***
### InitcodeWord
> `const` **InitcodeWord**: `2n` = `2n`
Defined in: [src/primitives/GasConstants/constants.js:263](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L263)
Per-word cost for initcode (2 gas) - EIP-3860
***
### Jumpdest
> `const` **Jumpdest**: `1n` = `1n`
Defined in: [src/primitives/GasConstants/constants.js:139](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L139)
JUMPDEST marker (1 gas)
***
### Keccak256Base
> `const` **Keccak256Base**: `30n` = `30n`
Defined in: [src/primitives/GasConstants/constants.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L64)
Base cost for KECCAK256 (30 gas)
***
### Keccak256Word
> `const` **Keccak256Word**: `6n` = `6n`
Defined in: [src/primitives/GasConstants/constants.js:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L70)
Per-word cost for KECCAK256 (6 gas per 32 bytes)
***
### LogBase
> `const` **LogBase**: `375n` = `375n`
Defined in: [src/primitives/GasConstants/constants.js:149](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L149)
Base cost for LOG operations (375 gas)
***
### LogData
> `const` **LogData**: `8n` = `8n`
Defined in: [src/primitives/GasConstants/constants.js:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L155)
Per-byte cost for LOG data (8 gas)
***
### LogTopic
> `const` **LogTopic**: `375n` = `375n`
Defined in: [src/primitives/GasConstants/constants.js:161](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L161)
Per-topic cost for LOG (375 gas)
***
### MaxInitcodeSize
> `const` **MaxInitcodeSize**: `49152n` = `49152n`
Defined in: [src/primitives/GasConstants/constants.js:269](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L269)
Maximum initcode size (49152 bytes) - EIP-3860
***
### MaxRefundQuotient
> `const` **MaxRefundQuotient**: `5n` = `5n`
Defined in: [src/primitives/GasConstants/constants.js:309](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L309)
Maximum refund quotient (1/5) - EIP-3529
***
### Memory
> `const` **Memory**: `3n` = `3n`
Defined in: [src/primitives/GasConstants/constants.js:241](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L241)
Linear coefficient for memory (3 gas)
***
### MidStep
> `const` **MidStep**: `8n` = `8n`
Defined in: [src/primitives/GasConstants/constants.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L40)
Advanced arithmetic (8 gas)
ADDMOD, MULMOD, SIGNEXTEND
***
### QuadCoeffDiv
> `const` **QuadCoeffDiv**: `512n` = `512n`
Defined in: [src/primitives/GasConstants/constants.js:247](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L247)
Quadratic coefficient divisor (512)
***
### QuickStep
> `const` **QuickStep**: `2n` = `2n`
Defined in: [src/primitives/GasConstants/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L18)
Very cheap operations (2 gas)
ADDRESS, ORIGIN, CALLER, CALLVALUE, CALLDATASIZE, CODESIZE,
GASPRICE, RETURNDATASIZE, PC, MSIZE, GAS, CHAINID, SELFBALANCE
***
### Selfdestruct
> `const` **Selfdestruct**: `5000n` = `5000n`
Defined in: [src/primitives/GasConstants/constants.js:219](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L219)
SELFDESTRUCT base cost (5000 gas) - EIP-150
***
### SelfdestructRefund
> `const` **SelfdestructRefund**: `24000n` = `24000n`
Defined in: [src/primitives/GasConstants/constants.js:225](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L225)
SELFDESTRUCT refund (24000 gas) - Removed in EIP-3529
***
### Sload
> `const` **Sload**: `100n` = `100n`
Defined in: [src/primitives/GasConstants/constants.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L80)
SLOAD on warm slot (100 gas)
***
### SlowStep
> `const` **SlowStep**: `10n` = `10n`
Defined in: [src/primitives/GasConstants/constants.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L47)
Moderate computation (10 gas)
JUMPI
***
### SstoreClear
> `const` **SstoreClear**: `5000n` = `5000n`
Defined in: [src/primitives/GasConstants/constants.js:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L123)
SSTORE clear to zero (5000 gas)
***
### SstoreRefund
> `const` **SstoreRefund**: `4800n` = `4800n`
Defined in: [src/primitives/GasConstants/constants.js:129](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L129)
Gas refund for clearing storage (4800 gas) - EIP-3529
***
### SstoreReset
> `const` **SstoreReset**: `5000n` = `5000n`
Defined in: [src/primitives/GasConstants/constants.js:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L117)
SSTORE modify existing non-zero (5000 gas)
***
### SstoreSentry
> `const` **SstoreSentry**: `2300n` = `2300n`
Defined in: [src/primitives/GasConstants/constants.js:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L105)
Minimum gas for SSTORE (2300 gas)
***
### SstoreSet
> `const` **SstoreSet**: `20000n` = `20000n`
Defined in: [src/primitives/GasConstants/constants.js:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L111)
SSTORE zero to non-zero (20000 gas)
***
### StaticCall
> `const` **StaticCall**: `700n` = `700n`
Defined in: [src/primitives/GasConstants/constants.js:213](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L213)
STATICCALL cost (700 gas) - EIP-214
***
### TLoad
> `const` **TLoad**: `100n` = `100n`
Defined in: [src/primitives/GasConstants/constants.js:335](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L335)
TLOAD cost (100 gas)
***
### TStore
> `const` **TStore**: `100n` = `100n`
Defined in: [src/primitives/GasConstants/constants.js:341](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L341)
TSTORE cost (100 gas)
***
### Tx
> `const` **Tx**: `21000n` = `21000n`
Defined in: [src/primitives/GasConstants/constants.js:279](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L279)
Base transaction cost (21000 gas)
***
### TxContractCreation
> `const` **TxContractCreation**: `53000n` = `53000n`
Defined in: [src/primitives/GasConstants/constants.js:285](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L285)
Contract creation transaction base cost (53000 gas)
***
### TxDataNonZero
> `const` **TxDataNonZero**: `16n` = `16n`
Defined in: [src/primitives/GasConstants/constants.js:297](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L297)
Per non-zero byte in calldata (16 gas)
***
### TxDataZero
> `const` **TxDataZero**: `4n` = `4n`
Defined in: [src/primitives/GasConstants/constants.js:291](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L291)
Per zero byte in calldata (4 gas)
***
### WarmStorageRead
> `const` **WarmStorageRead**: `100n` = `100n`
Defined in: [src/primitives/GasConstants/constants.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/constants.js#L99)
Warm storage read (100 gas) - EIP-2929
## Functions
### calculateCallCost()
> **calculateCallCost**(`isWarm`, `hasValue`, `isNewAccount`, `availableGas`): `object`
Defined in: [src/primitives/GasConstants/calculateCallCost.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateCallCost.js#L25)
Calculate CALL operation gas cost
#### Parameters
##### isWarm
`boolean`
Whether target account is warm
##### hasValue
`boolean`
Whether call transfers value
##### isNewAccount
`boolean`
Whether target account doesn't exist
##### availableGas
`bigint`
Gas available for the call
#### Returns
`object`
Gas cost breakdown
##### base
> **base**: `bigint`
##### dynamic
> **dynamic**: `bigint`
##### forwarded
> **forwarded**: `bigint`
##### stipend
> **stipend**: `bigint`
##### total
> **total**: `bigint`
#### Example
```typescript theme={null}
const result = calculateCallCost(true, true, false, 100000n);
// { base, dynamic, stipend, forwarded, total }
```
***
### calculateCopyCost()
> **calculateCopyCost**(`size`): `bigint`
Defined in: [src/primitives/GasConstants/calculateCopyCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateCopyCost.js#L9)
Calculate copy operation gas cost
#### Parameters
##### size
`bigint`
Size of data to copy in bytes
#### Returns
`bigint`
Gas cost
***
### calculateCreateCost()
> **calculateCreateCost**(`initcodeSize`, `deployedSize`): `object`
Defined in: [src/primitives/GasConstants/calculateCreateCost.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateCreateCost.js#L23)
Calculate contract creation gas cost
#### Parameters
##### initcodeSize
`bigint`
Size of initcode in bytes
##### deployedSize
`bigint`
Size of deployed bytecode in bytes
#### Returns
`object`
Gas cost breakdown
##### base
> **base**: `bigint`
##### dynamic
> **dynamic**: `bigint`
##### total
> **total**: `bigint`
#### Throws
If initcode size exceeds maximum
#### Example
```typescript theme={null}
const result = calculateCreateCost(1000n, 500n);
// { base: 32000n, initcode: ..., deployed: ..., total: ... }
```
***
### calculateKeccak256Cost()
> **calculateKeccak256Cost**(`dataSize`): `bigint`
Defined in: [src/primitives/GasConstants/calculateKeccak256Cost.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateKeccak256Cost.js#L14)
Calculate KECCAK256 gas cost
#### Parameters
##### dataSize
`bigint`
Size of data in bytes
#### Returns
`bigint`
Total gas cost
#### Example
```typescript theme={null}
const cost = calculateKeccak256Cost(64n); // 30 + (2 * 6) = 42 gas
```
***
### calculateLogCost()
> **calculateLogCost**(`topicCount`, `dataSize`): `bigint`
Defined in: [src/primitives/GasConstants/calculateLogCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateLogCost.js#L16)
Calculate LOG gas cost
#### Parameters
##### topicCount
`bigint`
Number of topics (0-4)
##### dataSize
`bigint`
Size of log data in bytes
#### Returns
`bigint`
Total gas cost
#### Example
```typescript theme={null}
const cost = calculateLogCost(2n, 64n); // LOG2 with 64 bytes
// 375 + (2 * 375) + (64 * 8) = 1637 gas
```
***
### calculateMaxRefund()
> **calculateMaxRefund**(`gasUsed`): `bigint`
Defined in: [src/primitives/GasConstants/calculateMaxRefund.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateMaxRefund.js#L9)
Calculate maximum gas refund
#### Parameters
##### gasUsed
`bigint`
Total gas used in transaction
#### Returns
`bigint`
Maximum refundable gas
***
### calculateMemoryExpansionCost()
> **calculateMemoryExpansionCost**(`oldSize`, `newSize`): `object`
Defined in: [src/primitives/GasConstants/calculateMemoryExpansionCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateMemoryExpansionCost.js#L16)
Calculate memory expansion cost
#### Parameters
##### oldSize
`bigint`
Previous memory size in bytes
##### newSize
`bigint`
New memory size in bytes
#### Returns
`object`
Memory expansion cost
##### expansionCost
> **expansionCost**: `bigint`
##### newCost
> **newCost**: `bigint`
##### oldCost
> **oldCost**: `bigint`
##### words
> **words**: `bigint`
#### Example
```typescript theme={null}
const expansion = calculateMemoryExpansionCost(64n, 128n);
// { oldCost, newCost, expansionCost, words }
```
***
### calculateSstoreCost()
> **calculateSstoreCost**(`isWarm`, `currentValue`, `newValue`): `object`
Defined in: [src/primitives/GasConstants/calculateSstoreCost.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateSstoreCost.js#L24)
Calculate SSTORE gas cost
#### Parameters
##### isWarm
`boolean`
Whether slot is warm (previously accessed)
##### currentValue
`bigint`
Current storage value (0n if empty)
##### newValue
`bigint`
New storage value
#### Returns
`object`
Gas cost and potential refund
##### cost
> **cost**: `bigint`
##### refund
> **refund**: `bigint`
#### Example
```typescript theme={null}
const result = calculateSstoreCost(false, 0n, 100n);
// { cost: 22100n, refund: 0n } - cold + set
```
***
### calculateTxIntrinsicGas()
> **calculateTxIntrinsicGas**(`data`, `isCreate`): `bigint`
Defined in: [src/primitives/GasConstants/calculateTxIntrinsicGas.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/calculateTxIntrinsicGas.js#L22)
Calculate transaction intrinsic gas cost
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Transaction calldata
##### isCreate
`boolean`
Whether transaction creates a contract
#### Returns
`bigint`
Intrinsic gas cost
#### Example
```typescript theme={null}
const data = new Uint8Array([0, 1, 2, 0, 0]);
const cost = calculateTxIntrinsicGas(data, false);
// 21000 + (3 * 4) + (2 * 16) = 21044 gas
```
***
### callCost()
> **callCost**(`this`): `object`
Defined in: [src/primitives/GasConstants/callCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/callCost.js#L9)
Calculate CALL operation gas cost (convenience form with this:)
#### Parameters
##### this
###### availableGas
`bigint`
###### hasValue
`boolean`
###### isNewAccount
`boolean`
###### isWarm
`boolean`
#### Returns
`object`
##### base
> **base**: `bigint`
##### dynamic
> **dynamic**: `bigint`
##### forwarded
> **forwarded**: `bigint`
##### stipend
> **stipend**: `bigint`
##### total
> **total**: `bigint`
***
### copyCost()
> **copyCost**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/copyCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/copyCost.js#L9)
Calculate copy operation gas cost (convenience form with this:)
#### Parameters
##### this
`bigint`
#### Returns
`bigint`
***
### createCost()
> **createCost**(`this`): `object`
Defined in: [src/primitives/GasConstants/createCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/createCost.js#L9)
Calculate contract creation gas cost (convenience form with this:)
#### Parameters
##### this
###### deployedSize
`bigint`
###### initcodeSize
`bigint`
#### Returns
`object`
##### base
> **base**: `bigint`
##### dynamic
> **dynamic**: `bigint`
##### total
> **total**: `bigint`
***
### getColdAccountAccessCost()
> **getColdAccountAccessCost**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/getColdAccountAccessCost.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/getColdAccountAccessCost.js#L10)
Get cold account access cost for hardfork
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas cost
***
### getColdSloadCost()
> **getColdSloadCost**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/getColdSloadCost.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/getColdSloadCost.js#L10)
Get cold storage cost for hardfork
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas cost
***
### getSelfdestructRefund()
> **getSelfdestructRefund**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/getSelfdestructRefund.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/getSelfdestructRefund.js#L10)
Get selfdestruct refund for hardfork
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas refund amount
***
### getSstoreRefund()
> **getSstoreRefund**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/getSstoreRefund.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/getSstoreRefund.js#L10)
Get storage refund for hardfork
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas refund amount
***
### hasEIP1153()
> **hasEIP1153**(`hardfork`): `boolean`
Defined in: [src/primitives/GasConstants/hasEIP1153.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/hasEIP1153.js#L7)
Check if a hardfork includes EIP-1153 (transient storage)
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`boolean`
Whether hardfork includes EIP-1153
***
### hasEIP2929()
> **hasEIP2929**(`hardfork`): `boolean`
Defined in: [src/primitives/GasConstants/hasEIP2929.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/hasEIP2929.js#L7)
Check if a hardfork includes EIP-2929 (cold/warm access costs)
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`boolean`
Whether hardfork includes EIP-2929
***
### hasEIP3529()
> **hasEIP3529**(`hardfork`): `boolean`
Defined in: [src/primitives/GasConstants/hasEIP3529.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/hasEIP3529.js#L7)
Check if a hardfork includes EIP-3529 (reduced refunds)
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`boolean`
Whether hardfork includes EIP-3529
***
### hasEIP3860()
> **hasEIP3860**(`hardfork`): `boolean`
Defined in: [src/primitives/GasConstants/hasEIP3860.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/hasEIP3860.js#L7)
Check if a hardfork includes EIP-3860 (initcode size limit)
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`boolean`
Whether hardfork includes EIP-3860
***
### hasEIP4844()
> **hasEIP4844**(`hardfork`): `boolean`
Defined in: [src/primitives/GasConstants/hasEIP4844.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/hasEIP4844.js#L7)
Check if a hardfork includes EIP-4844 (blob transactions)
#### Parameters
##### hardfork
[`Hardfork`](#hardfork-1)
EVM hardfork
#### Returns
`boolean`
Whether hardfork includes EIP-4844
***
### keccak256Cost()
> **keccak256Cost**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/keccak256Cost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/keccak256Cost.js#L9)
Calculate KECCAK256 gas cost (convenience form with this:)
#### Parameters
##### this
`bigint`
#### Returns
`bigint`
Total gas cost
***
### logCost()
> **logCost**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/logCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/logCost.js#L9)
Calculate LOG gas cost (convenience form with this:)
#### Parameters
##### this
###### dataSize
`bigint`
###### topicCount
`bigint`
#### Returns
`bigint`
***
### maxRefund()
> **maxRefund**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/maxRefund.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/maxRefund.js#L9)
Calculate maximum gas refund (convenience form with this:)
#### Parameters
##### this
`bigint`
#### Returns
`bigint`
***
### memoryExpansionCost()
> **memoryExpansionCost**(`this`): `object`
Defined in: [src/primitives/GasConstants/memoryExpansionCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/memoryExpansionCost.js#L9)
Calculate memory expansion cost (convenience form with this:)
#### Parameters
##### this
###### newSize
`bigint`
###### oldSize
`bigint`
#### Returns
`object`
##### expansionCost
> **expansionCost**: `bigint`
##### newCost
> **newCost**: `bigint`
##### oldCost
> **oldCost**: `bigint`
##### words
> **words**: `bigint`
***
### sstoreCost()
> **sstoreCost**(`this`): `object`
Defined in: [src/primitives/GasConstants/sstoreCost.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/sstoreCost.js#L9)
Calculate SSTORE gas cost (convenience form with this:)
#### Parameters
##### this
###### currentValue
`bigint`
###### isWarm
`boolean`
###### newValue
`bigint`
#### Returns
`object`
##### cost
> **cost**: `bigint`
##### refund
> **refund**: `bigint`
***
### txIntrinsicGas()
> **txIntrinsicGas**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/txIntrinsicGas.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/txIntrinsicGas.js#L9)
Calculate transaction intrinsic gas cost (convenience form with this:)
#### Parameters
##### this
###### data
`Uint8Array`
###### isCreate
`boolean`
#### Returns
`bigint`
# Precompile
Source: https://voltaire.tevm.sh/generated-api/primitives/GasConstants/namespaces/Precompile
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/GasConstants](../index.mdx) / Precompile
# Precompile
## Variables
### blake2f()
> `const` **blake2f**: (`rounds`) => `bigint` = `calculateBlake2fCost`
Defined in: [src/primitives/GasConstants/Precompile.js:285](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L285)
Convenience alias for BLAKE2F cost calculation
Calculate BLAKE2F precompile cost
#### Parameters
##### rounds
`bigint`
Number of compression rounds
#### Returns
`bigint`
Gas cost
#### Param
Number of compression rounds
#### Returns
Gas cost
***
### Blake2fPerRound
> `const` **Blake2fPerRound**: `1n` = `1n`
Defined in: [src/primitives/GasConstants/Precompile.js:268](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L268)
BLAKE2F (address 0x09) - Cost per round
***
### Bls12G1Add
> `const` **Bls12G1Add**: `500n` = `500n`
Defined in: [src/primitives/GasConstants/Precompile.js:310](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L310)
BLS12\_G1ADD (address 0x0b) - Fixed cost
***
### Bls12G1MsmBase
> `const` **Bls12G1MsmBase**: `12000n` = `12000n`
Defined in: [src/primitives/GasConstants/Precompile.js:322](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L322)
BLS12\_G1MSM (address 0x0d) - Base cost per point
***
### Bls12G1Mul
> `const` **Bls12G1Mul**: `12000n` = `12000n`
Defined in: [src/primitives/GasConstants/Precompile.js:316](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L316)
BLS12\_G1MUL (address 0x0c) - Fixed cost
***
### Bls12G2Add
> `const` **Bls12G2Add**: `800n` = `800n`
Defined in: [src/primitives/GasConstants/Precompile.js:328](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L328)
BLS12\_G2ADD (address 0x0e) - Fixed cost
***
### Bls12G2MsmBase
> `const` **Bls12G2MsmBase**: `45000n` = `45000n`
Defined in: [src/primitives/GasConstants/Precompile.js:340](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L340)
BLS12\_G2MSM (address 0x10) - Base cost per point
***
### Bls12G2Mul
> `const` **Bls12G2Mul**: `45000n` = `45000n`
Defined in: [src/primitives/GasConstants/Precompile.js:334](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L334)
BLS12\_G2MUL (address 0x0f) - Fixed cost
***
### Bls12MapFp2ToG2
> `const` **Bls12MapFp2ToG2**: `75000n` = `75000n`
Defined in: [src/primitives/GasConstants/Precompile.js:364](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L364)
BLS12\_MAP\_FP2\_TO\_G2 (address 0x13) - Fixed cost
***
### Bls12MapFpToG1
> `const` **Bls12MapFpToG1**: `5500n` = `5500n`
Defined in: [src/primitives/GasConstants/Precompile.js:358](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L358)
BLS12\_MAP\_FP\_TO\_G1 (address 0x12) - Fixed cost
***
### Bls12PairingBase
> `const` **Bls12PairingBase**: `65000n` = `65000n`
Defined in: [src/primitives/GasConstants/Precompile.js:346](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L346)
BLS12\_PAIRING (address 0x11) - Base cost
***
### Bls12PairingPerPair
> `const` **Bls12PairingPerPair**: `43000n` = `43000n`
Defined in: [src/primitives/GasConstants/Precompile.js:352](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L352)
BLS12\_PAIRING - Per-pair cost
***
### EcAddByzantium
> `const` **EcAddByzantium**: `500n` = `500n`
Defined in: [src/primitives/GasConstants/Precompile.js:154](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L154)
BN254 ECADD - Byzantium to Berlin
***
### EcAddIstanbul
> `const` **EcAddIstanbul**: `150n` = `150n`
Defined in: [src/primitives/GasConstants/Precompile.js:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L148)
BN254 ECADD (address 0x06) - Istanbul onwards
***
### EcMulByzantium
> `const` **EcMulByzantium**: `40000n` = `40000n`
Defined in: [src/primitives/GasConstants/Precompile.js:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L166)
BN254 ECMUL - Byzantium to Berlin
***
### EcMulIstanbul
> `const` **EcMulIstanbul**: `6000n` = `6000n`
Defined in: [src/primitives/GasConstants/Precompile.js:160](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L160)
BN254 ECMUL (address 0x07) - Istanbul onwards
***
### EcPairingBaseByzantium
> `const` **EcPairingBaseByzantium**: `100000n` = `100000n`
Defined in: [src/primitives/GasConstants/Precompile.js:184](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L184)
BN254 ECPAIRING - Base cost (Byzantium to Berlin)
***
### EcPairingBaseIstanbul
> `const` **EcPairingBaseIstanbul**: `45000n` = `45000n`
Defined in: [src/primitives/GasConstants/Precompile.js:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L172)
BN254 ECPAIRING (address 0x08) - Base cost (Istanbul onwards)
***
### EcPairingPerPairByzantium
> `const` **EcPairingPerPairByzantium**: `80000n` = `80000n`
Defined in: [src/primitives/GasConstants/Precompile.js:190](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L190)
BN254 ECPAIRING - Per-pair cost (Byzantium to Berlin)
***
### EcPairingPerPairIstanbul
> `const` **EcPairingPerPairIstanbul**: `34000n` = `34000n`
Defined in: [src/primitives/GasConstants/Precompile.js:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L178)
BN254 ECPAIRING - Per-pair cost (Istanbul onwards)
***
### EcRecover
> `const` **EcRecover**: `3000n` = `3000n`
Defined in: [src/primitives/GasConstants/Precompile.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L11)
ECRECOVER (address 0x01) - Fixed cost
***
### IdentityBase
> `const` **IdentityBase**: `15n` = `15n`
Defined in: [src/primitives/GasConstants/Precompile.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L63)
IDENTITY (address 0x04) - Base cost
***
### IdentityWord
> `const` **IdentityWord**: `3n` = `3n`
Defined in: [src/primitives/GasConstants/Precompile.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L69)
IDENTITY - Per-word cost
***
### ModExpLinearThreshold
> `const` **ModExpLinearThreshold**: `1024n` = `1024n`
Defined in: [src/primitives/GasConstants/Precompile.js:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L98)
MODEXP - Linear threshold (1024 bytes)
***
### ModExpMin
> `const` **ModExpMin**: `200n` = `200n`
Defined in: [src/primitives/GasConstants/Precompile.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L86)
MODEXP (address 0x05) - Minimum cost (EIP-2565)
***
### ModExpQuadraticThreshold
> `const` **ModExpQuadraticThreshold**: `64n` = `64n`
Defined in: [src/primitives/GasConstants/Precompile.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L92)
MODEXP - Quadratic threshold (64 bytes)
***
### PointEvaluation
> `const` **PointEvaluation**: `50000n` = `50000n`
Defined in: [src/primitives/GasConstants/Precompile.js:291](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L291)
POINT\_EVALUATION (address 0x0a) - Fixed cost (EIP-4844)
***
### Ripemd160Base
> `const` **Ripemd160Base**: `600n` = `600n`
Defined in: [src/primitives/GasConstants/Precompile.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L40)
RIPEMD160 (address 0x03) - Base cost
***
### Ripemd160Word
> `const` **Ripemd160Word**: `120n` = `120n`
Defined in: [src/primitives/GasConstants/Precompile.js:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L46)
RIPEMD160 - Per-word cost
***
### Sha256Base
> `const` **Sha256Base**: `60n` = `60n`
Defined in: [src/primitives/GasConstants/Precompile.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L17)
SHA256 (address 0x02) - Base cost
***
### Sha256Word
> `const` **Sha256Word**: `12n` = `12n`
Defined in: [src/primitives/GasConstants/Precompile.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L23)
SHA256 - Per-word cost
## Functions
### calculateBlake2fCost()
> **calculateBlake2fCost**(`rounds`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:276](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L276)
Calculate BLAKE2F precompile cost
#### Parameters
##### rounds
`bigint`
Number of compression rounds
#### Returns
`bigint`
Gas cost
***
### calculateBls12G1MsmCost()
> **calculateBls12G1MsmCost**(`pairCount`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:403](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L403)
Calculate BLS12\_G1MSM precompile cost
#### Parameters
##### pairCount
`bigint`
Number of point-scalar pairs
#### Returns
`bigint`
Gas cost
***
### calculateBls12G2MsmCost()
> **calculateBls12G2MsmCost**(`pairCount`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:416](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L416)
Calculate BLS12\_G2MSM precompile cost
#### Parameters
##### pairCount
`bigint`
Number of point-scalar pairs
#### Returns
`bigint`
Gas cost
***
### calculateBls12PairingCost()
> **calculateBls12PairingCost**(`pairCount`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:429](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L429)
Calculate BLS12\_PAIRING precompile cost
#### Parameters
##### pairCount
`bigint`
Number of G1-G2 pairs
#### Returns
`bigint`
Gas cost
***
### calculateEcPairingCost()
> **calculateEcPairingCost**(`pairCount`, `hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:205](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L205)
Calculate ECPAIRING precompile cost
#### Parameters
##### pairCount
`bigint`
Number of point pairs
##### hardfork
[`Hardfork`](../index.mdx#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas cost
#### Example
```typescript theme={null}
const cost = calculateEcPairingCost(2n, 'istanbul');
// 45000 + (2 * 34000) = 113000 gas
```
***
### calculateIdentityCost()
> **calculateIdentityCost**(`dataSize`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L77)
Calculate IDENTITY precompile cost
#### Parameters
##### dataSize
`bigint`
Size of data in bytes
#### Returns
`bigint`
Gas cost
***
### calculateModExpCost()
> **calculateModExpCost**(`baseLength`, `expLength`, `modLength`, `expHead`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L126)
Calculate MODEXP precompile cost
#### Parameters
##### baseLength
`bigint`
Length of base in bytes
##### expLength
`bigint`
Length of exponent in bytes
##### modLength
`bigint`
Length of modulus in bytes
##### expHead
`bigint`
First 32 bytes of exponent
#### Returns
`bigint`
Gas cost
***
### calculatePointEvaluationCost()
> **calculatePointEvaluationCost**(): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:298](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L298)
Calculate POINT\_EVALUATION precompile cost
#### Returns
`bigint`
Gas cost (fixed at 50000)
***
### calculateRipemd160Cost()
> **calculateRipemd160Cost**(`dataSize`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L54)
Calculate RIPEMD160 precompile cost
#### Parameters
##### dataSize
`bigint`
Size of data in bytes
#### Returns
`bigint`
Gas cost
***
### calculateSha256Cost()
> **calculateSha256Cost**(`dataSize`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L31)
Calculate SHA256 precompile cost
#### Parameters
##### dataSize
`bigint`
Size of data in bytes
#### Returns
`bigint`
Gas cost
***
### ecPairingCost()
> **ecPairingCost**(`this`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:260](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L260)
Calculate ECPAIRING precompile cost (convenience form with this:)
#### Parameters
##### this
###### hardfork
[`Hardfork`](../index.mdx#hardfork-1)
###### pairCount
`bigint`
#### Returns
`bigint`
***
### getEcAddCost()
> **getEcAddCost**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:226](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L226)
Get ECADD cost for hardfork
#### Parameters
##### hardfork
[`Hardfork`](../index.mdx#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas cost
***
### getEcMulCost()
> **getEcMulCost**(`hardfork`): `bigint`
Defined in: [src/primitives/GasConstants/Precompile.js:243](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasConstants/Precompile.js#L243)
Get ECMUL cost for hardfork
#### Parameters
##### hardfork
[`Hardfork`](../index.mdx#hardfork-1)
EVM hardfork
#### Returns
`bigint`
Gas cost
# primitives/GasEstimate
Source: https://voltaire.tevm.sh/generated-api/primitives/GasEstimate
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/GasEstimate
# primitives/GasEstimate
## Type Aliases
### GasEstimateType
> **GasEstimateType** = `bigint` & `object`
Defined in: [src/primitives/GasEstimate/GasEstimateType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/GasEstimateType.ts#L8)
Branded GasEstimate type - estimated gas for transaction
Returned by eth\_estimateGas RPC method
Should add buffer (20-30%) for actual transaction
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"GasEstimate"`
## Variables
### GasEstimate
> `const` **GasEstimate**: `object`
Defined in: [src/primitives/GasEstimate/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L67)
#### Type Declaration
##### compare()
> **compare**: (`value1`, `value2`) => `number`
###### Parameters
###### value1
`string` | `number` | `bigint`
###### value2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`value1`, `value2`) => `boolean`
###### Parameters
###### value1
`string` | `number` | `bigint`
###### value2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`GasEstimateType`](#gasestimatetype)
Create GasEstimate from number, bigint, or string
###### Parameters
###### value
Gas estimate value
`string` | `number` | `bigint`
###### Returns
[`GasEstimateType`](#gasestimatetype)
Branded gas estimate
###### Throws
If value is negative
###### Example
```typescript theme={null}
const estimate = GasEstimate.from(51234n);
const fromRpc = GasEstimate.from(rpcEstimate);
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGasLimit()
> **toGasLimit**: (`estimate`) => `bigint`
###### Parameters
###### estimate
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toHex()
> **toHex**: (`value`) => `string`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`string`
##### toNumber()
> **toNumber**: (`value`) => `number`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`number`
##### withBuffer()
> **withBuffer**: (`estimate`, `percentageBuffer`) => [`GasEstimateType`](#gasestimatetype)
###### Parameters
###### estimate
`string` | `number` | `bigint`
###### percentageBuffer
`number`
###### Returns
[`GasEstimateType`](#gasestimatetype)
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/GasEstimate/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/compare.js#L15)
Compare two GasEstimate values
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
##### other
[`GasEstimateType`](#gasestimatetype)
Other gas estimate value
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const a = GasEstimate.from(21000n);
const b = GasEstimate.from(51234n);
GasEstimate._compare.call(a, b); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/GasEstimate/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/equals.js#L15)
Check if two GasEstimate values are equal
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
##### other
[`GasEstimateType`](#gasestimatetype)
Other gas estimate value
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const a = GasEstimate.from(51234n);
const b = GasEstimate.from(51234n);
GasEstimate._equals.call(a, b); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/GasEstimate/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/toBigInt.js#L13)
Convert GasEstimate to bigint (identity, for compatibility)
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
#### Returns
`bigint`
Gas estimate as bigint
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(51234n);
GasEstimate.toBigInt(estimate); // 51234n
```
***
### \_toGasLimit()
> **\_toGasLimit**(`this`): `bigint`
Defined in: [src/primitives/GasEstimate/toGasLimit.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/toGasLimit.js#L15)
Convert GasEstimate to GasLimit type
Typically used after adding buffer with withBuffer()
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
#### Returns
`bigint`
Gas limit value (unbranded bigint)
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(100000n);
const withBuffer = GasEstimate._withBuffer.call(estimate, 20);
const gasLimit = GasEstimate._toGasLimit.call(withBuffer); // 120000n
```
***
### \_toHex()
> **\_toHex**(`this`): `string`
Defined in: [src/primitives/GasEstimate/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/toHex.js#L13)
Convert GasEstimate to hex string
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
#### Returns
`string`
Gas estimate as hex string (0x prefixed)
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(51234n);
GasEstimate.toHex(estimate); // "0xc822"
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/GasEstimate/toNumber.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/toNumber.js#L13)
Convert GasEstimate to number
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
#### Returns
`number`
Gas estimate as number
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(51234n);
GasEstimate.toNumber(estimate); // 51234
```
***
### \_withBuffer()
> **\_withBuffer**(`this`, `percentageBuffer`): [`GasEstimateType`](#gasestimatetype)
Defined in: [src/primitives/GasEstimate/withBuffer.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/withBuffer.js#L18)
Add percentage buffer to gas estimate
Recommended: 20-30% to account for variability
#### Parameters
##### this
[`GasEstimateType`](#gasestimatetype)
##### percentageBuffer
`number`
Padding percentage (e.g., 20 for 20%)
#### Returns
[`GasEstimateType`](#gasestimatetype)
Estimate with buffer
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(100000n);
GasEstimate._withBuffer.call(estimate, 20); // 120000n (100000 + 20%)
GasEstimate._withBuffer.call(estimate, 30); // 130000n (100000 + 30%)
```
***
### compare()
> **compare**(`value1`, `value2`): `number`
Defined in: [src/primitives/GasEstimate/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L37)
#### Parameters
##### value1
`string` | `number` | `bigint`
##### value2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`value1`, `value2`): `boolean`
Defined in: [src/primitives/GasEstimate/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L30)
#### Parameters
##### value1
`string` | `number` | `bigint`
##### value2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`GasEstimateType`](#gasestimatetype)
Defined in: [src/primitives/GasEstimate/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/from.js#L16)
Create GasEstimate from number, bigint, or string
#### Parameters
##### value
Gas estimate value
`string` | `number` | `bigint`
#### Returns
[`GasEstimateType`](#gasestimatetype)
Branded gas estimate
#### Throws
If value is negative
#### Example
```typescript theme={null}
const estimate = GasEstimate.from(51234n);
const fromRpc = GasEstimate.from(rpcEstimate);
```
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/GasEstimate/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L22)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toGasLimit()
> **toGasLimit**(`estimate`): `bigint`
Defined in: [src/primitives/GasEstimate/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L51)
#### Parameters
##### estimate
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/GasEstimate/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L26)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`string`
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/GasEstimate/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L18)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`number`
***
### withBuffer()
> **withBuffer**(`estimate`, `percentageBuffer`): [`GasEstimateType`](#gasestimatetype)
Defined in: [src/primitives/GasEstimate/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasEstimate/index.ts#L44)
#### Parameters
##### estimate
`string` | `number` | `bigint`
##### percentageBuffer
`number`
#### Returns
[`GasEstimateType`](#gasestimatetype)
# primitives/GasRefund
Source: https://voltaire.tevm.sh/generated-api/primitives/GasRefund
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/GasRefund
# primitives/GasRefund
## Type Aliases
### GasRefundType
> **GasRefundType** = `bigint` & `object`
Defined in: [src/primitives/GasRefund/GasRefundType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/GasRefundType.ts#L8)
Branded GasRefund type - gas refunded after transaction
Sources: SSTORE refunds, SELFDESTRUCT refunds (pre-London)
Post-London (EIP-3529): Capped at gasUsed / 5
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"GasRefund"`
## Variables
### GasRefund
> `const` **GasRefund**: `object`
Defined in: [src/primitives/GasRefund/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L46)
#### Type Declaration
##### cappedRefund()
> **cappedRefund**: (`refund`, `gasUsed`) => [`GasRefundType`](#gasrefundtype)
###### Parameters
###### refund
`string` | `number` | `bigint`
###### gasUsed
`bigint`
###### Returns
[`GasRefundType`](#gasrefundtype)
##### equals()
> **equals**: (`value1`, `value2`) => `boolean`
###### Parameters
###### value1
`string` | `number` | `bigint`
###### value2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`GasRefundType`](#gasrefundtype)
Create GasRefund from number, bigint, or string
###### Parameters
###### value
Gas refund value
`string` | `number` | `bigint`
###### Returns
[`GasRefundType`](#gasrefundtype)
Branded gas refund
###### Throws
If value is negative
###### Example
```typescript theme={null}
const refund = GasRefund.from(15000n); // SSTORE clear refund
const noRefund = GasRefund.from(0n);
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toHex()
> **toHex**: (`value`) => `string`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`string`
##### toNumber()
> **toNumber**: (`value`) => `number`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`number`
## Functions
### \_cappedRefund()
> **\_cappedRefund**(`this`, `gasUsed`): [`GasRefundType`](#gasrefundtype)
Defined in: [src/primitives/GasRefund/cappedRefund.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/cappedRefund.js#L22)
Apply EIP-3529 refund cap (gasUsed / 5)
Post-London hard fork limitation on gas refunds
#### Parameters
##### this
[`GasRefundType`](#gasrefundtype)
##### gasUsed
`bigint`
Gas used by transaction
#### Returns
[`GasRefundType`](#gasrefundtype)
Capped refund
#### Example
```typescript theme={null}
const refund = GasRefund.from(15000n);
const gasUsed = 50000n;
// Cap = 50000 / 5 = 10000
GasRefund._cappedRefund.call(refund, gasUsed); // 10000n (capped)
const smallRefund = GasRefund.from(5000n);
GasRefund._cappedRefund.call(smallRefund, gasUsed); // 5000n (not capped)
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/GasRefund/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/equals.js#L15)
Check if two GasRefund values are equal
#### Parameters
##### this
[`GasRefundType`](#gasrefundtype)
##### other
[`GasRefundType`](#gasrefundtype)
Other gas refund value
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const a = GasRefund.from(15000n);
const b = GasRefund.from(15000n);
GasRefund._equals.call(a, b); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/GasRefund/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/toBigInt.js#L13)
Convert GasRefund to bigint (identity, for compatibility)
#### Parameters
##### this
[`GasRefundType`](#gasrefundtype)
#### Returns
`bigint`
Gas refund as bigint
#### Example
```typescript theme={null}
const refund = GasRefund.from(15000n);
GasRefund.toBigInt(refund); // 15000n
```
***
### \_toHex()
> **\_toHex**(`this`): `string`
Defined in: [src/primitives/GasRefund/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/toHex.js#L13)
Convert GasRefund to hex string
#### Parameters
##### this
[`GasRefundType`](#gasrefundtype)
#### Returns
`string`
Gas refund as hex string (0x prefixed)
#### Example
```typescript theme={null}
const refund = GasRefund.from(15000n);
GasRefund.toHex(refund); // "0x3a98"
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/GasRefund/toNumber.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/toNumber.js#L13)
Convert GasRefund to number
#### Parameters
##### this
[`GasRefundType`](#gasrefundtype)
#### Returns
`number`
Gas refund as number
#### Example
```typescript theme={null}
const refund = GasRefund.from(15000n);
GasRefund.toNumber(refund); // 15000
```
***
### cappedRefund()
> **cappedRefund**(`refund`, `gasUsed`): [`GasRefundType`](#gasrefundtype)
Defined in: [src/primitives/GasRefund/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L35)
#### Parameters
##### refund
`string` | `number` | `bigint`
##### gasUsed
`bigint`
#### Returns
[`GasRefundType`](#gasrefundtype)
***
### equals()
> **equals**(`value1`, `value2`): `boolean`
Defined in: [src/primitives/GasRefund/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L28)
#### Parameters
##### value1
`string` | `number` | `bigint`
##### value2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`GasRefundType`](#gasrefundtype)
Defined in: [src/primitives/GasRefund/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/from.js#L16)
Create GasRefund from number, bigint, or string
#### Parameters
##### value
Gas refund value
`string` | `number` | `bigint`
#### Returns
[`GasRefundType`](#gasrefundtype)
Branded gas refund
#### Throws
If value is negative
#### Example
```typescript theme={null}
const refund = GasRefund.from(15000n); // SSTORE clear refund
const noRefund = GasRefund.from(0n);
```
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/GasRefund/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L20)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/GasRefund/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L24)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`string`
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/GasRefund/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasRefund/index.ts#L16)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`number`
# primitives/GasUsed
Source: https://voltaire.tevm.sh/generated-api/primitives/GasUsed
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/GasUsed
# primitives/GasUsed
## Type Aliases
### GasUsedType
> **GasUsedType** = `bigint` & `object`
Defined in: [src/primitives/GasUsed/GasUsedType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/GasUsedType.ts#L8)
Branded GasUsed type - actual gas consumed by transaction
Found in transaction receipts (receipt.gasUsed)
Range: 21000 (minimum transfer) to block gas limit (30M typical)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"GasUsed"`
## Variables
### GasUsed
> `const` **GasUsed**: `object`
Defined in: [src/primitives/GasUsed/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L54)
#### Type Declaration
##### calculateCost()
> **calculateCost**: (`gasUsed`, `gasPrice`) => `bigint`
###### Parameters
###### gasUsed
`string` | `number` | `bigint`
###### gasPrice
`bigint`
###### Returns
`bigint`
##### compare()
> **compare**: (`value1`, `value2`) => `number`
###### Parameters
###### value1
`string` | `number` | `bigint`
###### value2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`value1`, `value2`) => `boolean`
###### Parameters
###### value1
`string` | `number` | `bigint`
###### value2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`GasUsedType`](#gasusedtype)
Create GasUsed from number, bigint, or string
###### Parameters
###### value
Gas used value
`string` | `number` | `bigint`
###### Returns
[`GasUsedType`](#gasusedtype)
Branded gas used
###### Throws
If value is negative
###### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
const fromReceipt = GasUsed.from(receipt.gasUsed);
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toHex()
> **toHex**: (`value`) => `string`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`string`
##### toNumber()
> **toNumber**: (`value`) => `number`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`number`
## Functions
### \_calculateCost()
> **\_calculateCost**(`this`, `gasPrice`): `bigint`
Defined in: [src/primitives/GasUsed/calculateCost.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/calculateCost.js#L15)
Calculate transaction cost in Wei (gasUsed \* gasPrice)
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
##### gasPrice
`bigint`
Gas price in Wei
#### Returns
`bigint`
Transaction cost in Wei
#### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
const gasPrice = 20_000_000_000n; // 20 gwei
GasUsed._calculateCost.call(gasUsed, gasPrice); // 1024680000000000n Wei
```
***
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/GasUsed/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/compare.js#L15)
Compare two GasUsed values
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
##### other
[`GasUsedType`](#gasusedtype)
Other gas used value
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const a = GasUsed.from(21000n);
const b = GasUsed.from(51234n);
GasUsed._compare.call(a, b); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/GasUsed/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/equals.js#L15)
Check if two GasUsed values are equal
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
##### other
[`GasUsedType`](#gasusedtype)
Other gas used value
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const a = GasUsed.from(51234n);
const b = GasUsed.from(51234n);
GasUsed._equals.call(a, b); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/GasUsed/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/toBigInt.js#L13)
Convert GasUsed to bigint (identity, for compatibility)
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
#### Returns
`bigint`
Gas used as bigint
#### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
GasUsed.toBigInt(gasUsed); // 51234n
```
***
### \_toHex()
> **\_toHex**(`this`): `string`
Defined in: [src/primitives/GasUsed/toHex.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/toHex.js#L13)
Convert GasUsed to hex string
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
#### Returns
`string`
Gas used as hex string (0x prefixed)
#### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
GasUsed.toHex(gasUsed); // "0xc822"
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/GasUsed/toNumber.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/toNumber.js#L13)
Convert GasUsed to number
#### Parameters
##### this
[`GasUsedType`](#gasusedtype)
#### Returns
`number`
Gas used as number
#### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
GasUsed.toNumber(gasUsed); // 51234
```
***
### calculateCost()
> **calculateCost**(`gasUsed`, `gasPrice`): `bigint`
Defined in: [src/primitives/GasUsed/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L43)
#### Parameters
##### gasUsed
`string` | `number` | `bigint`
##### gasPrice
`bigint`
#### Returns
`bigint`
***
### compare()
> **compare**(`value1`, `value2`): `number`
Defined in: [src/primitives/GasUsed/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L36)
#### Parameters
##### value1
`string` | `number` | `bigint`
##### value2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`value1`, `value2`): `boolean`
Defined in: [src/primitives/GasUsed/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L29)
#### Parameters
##### value1
`string` | `number` | `bigint`
##### value2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`GasUsedType`](#gasusedtype)
Defined in: [src/primitives/GasUsed/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/from.js#L16)
Create GasUsed from number, bigint, or string
#### Parameters
##### value
Gas used value
`string` | `number` | `bigint`
#### Returns
[`GasUsedType`](#gasusedtype)
Branded gas used
#### Throws
If value is negative
#### Example
```typescript theme={null}
const gasUsed = GasUsed.from(51234n);
const fromReceipt = GasUsed.from(receipt.gasUsed);
```
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/GasUsed/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L21)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/GasUsed/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L25)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`string`
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/GasUsed/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/GasUsed/index.ts#L17)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
`number`
# primitives/Hardfork
Source: https://voltaire.tevm.sh/generated-api/primitives/Hardfork
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Hardfork
# primitives/Hardfork
## Type Aliases
### HardforkType
> **HardforkType** = `string` & `object`
Defined in: [src/primitives/Hardfork/HardforkType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/HardforkType.ts#L10)
Branded Hardfork type
Hardfork is a branded string type that represents Ethereum protocol upgrades.
Each hardfork represents a protocol upgrade that changes EVM behavior,
gas costs, or adds new features.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Hardfork"`
## Variables
### allIds()
> `const` **allIds**: () => [`HardforkType`](#hardforktype)\[] = `_allIds`
Defined in: [src/primitives/Hardfork/index.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L68)
#### Returns
[`HardforkType`](#hardforktype)\[]
***
### allNames()
> `const` **allNames**: () => `string`\[] = `_allNames`
Defined in: [src/primitives/Hardfork/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L67)
#### Returns
`string`\[]
***
### ARROW\_GLACIER
> `const` **ARROW\_GLACIER**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L50)
***
### BERLIN
> `const` **BERLIN**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L44)
***
### BYZANTIUM
> `const` **BYZANTIUM**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L29)
***
### CANCUN
> `const` **CANCUN**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L62)
***
### compare()
> `const` **compare**: (`a`, `b`) => `number` = `_compare`
Defined in: [src/primitives/Hardfork/index.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L47)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`number`
***
### CONSTANTINOPLE
> `const` **CONSTANTINOPLE**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L32)
***
### DAO
> `const` **DAO**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L18)
***
### DEFAULT
> `const` **DEFAULT**: [`HardforkType`](#hardforktype) = `PRAGUE`
Defined in: [src/primitives/Hardfork/constants.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L76)
Default hardfork for new chains.
Set to latest stable fork (currently PRAGUE).
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/Hardfork/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L53)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### fromString()
> `const` **fromString**: (`name`) => [`HardforkType`](#hardforktype) | `undefined` = `_fromString`
Defined in: [src/primitives/Hardfork/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L36)
#### Parameters
##### name
`string`
#### Returns
[`HardforkType`](#hardforktype) | `undefined`
***
### FRONTIER
> `const` **FRONTIER**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L12)
***
### GRAY\_GLACIER
> `const` **GRAY\_GLACIER**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L53)
***
### gt()
> `const` **gt**: (`a`, `b`) => `boolean` = `_gt`
Defined in: [src/primitives/Hardfork/index.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L52)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### gte()
> `const` **gte**: (`a`, `b`) => `boolean` = `_gte`
Defined in: [src/primitives/Hardfork/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L50)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### Hardfork
> `const` **Hardfork**: `object`
Defined in: [src/primitives/Hardfork/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L73)
#### Type Declaration
##### allIds()
> **allIds**: () => [`HardforkType`](#hardforktype)\[]
###### Returns
[`HardforkType`](#hardforktype)\[]
##### allNames()
> **allNames**: () => `string`\[]
###### Returns
`string`\[]
##### compare()
> **compare**: (`a`, `b`) => `number`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`number`
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### fromString()
> **fromString**: (`name`) => [`HardforkType`](#hardforktype) | `undefined`
###### Parameters
###### name
`string`
###### Returns
[`HardforkType`](#hardforktype) | `undefined`
##### gt()
> **gt**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### gte()
> **gte**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### hasEIP1153()
> **hasEIP1153**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### hasEIP1559()
> **hasEIP1559**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### hasEIP3855()
> **hasEIP3855**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### hasEIP4844()
> **hasEIP4844**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isAfter()
> **isAfter**: (`fork`, `minFork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### minFork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isAtLeast()
> **isAtLeast**: (`fork`, `minFork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### minFork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isBefore()
> **isBefore**: (`fork`, `maxFork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### maxFork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isPoS()
> **isPoS**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isPostMerge()
> **isPostMerge**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### isValidName()
> **isValidName**: (`name`) => `boolean`
###### Parameters
###### name
`string`
###### Returns
`boolean`
##### lt()
> **lt**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### lte()
> **lte**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`HardforkType`](#hardforktype)
###### b
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### max()
> **max**: (`forks`) => [`HardforkType`](#hardforktype)
###### Parameters
###### forks
[`HardforkType`](#hardforktype)\[]
###### Returns
[`HardforkType`](#hardforktype)
##### min()
> **min**: (`forks`) => [`HardforkType`](#hardforktype)
###### Parameters
###### forks
[`HardforkType`](#hardforktype)\[]
###### Returns
[`HardforkType`](#hardforktype)
##### range()
> **range**: (`start`, `end`) => [`HardforkType`](#hardforktype)\[]
###### Parameters
###### start
[`HardforkType`](#hardforktype)
###### end
[`HardforkType`](#hardforktype)
###### Returns
[`HardforkType`](#hardforktype)\[]
##### supportsBlobs()
> **supportsBlobs**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### supportsEIP1559()
> **supportsEIP1559**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### supportsPUSH0()
> **supportsPUSH0**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### supportsTransientStorage()
> **supportsTransientStorage**: (`fork`) => `boolean`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`boolean`
##### toString()
> **toString**: (`fork`) => `string`
###### Parameters
###### fork
[`HardforkType`](#hardforktype)
###### Returns
`string`
***
### HARDFORK\_ORDER
> `const` **HARDFORK\_ORDER**: [`HardforkType`](#hardforktype)\[]
Defined in: [src/primitives/Hardfork/constants.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L82)
**`Internal`**
Hardfork ordering for version comparison
***
### hasEIP1153()
> `const` **hasEIP1153**: (`fork`) => `boolean` = `_hasEIP1153`
Defined in: [src/primitives/Hardfork/index.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L62)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### hasEIP1559()
> `const` **hasEIP1559**: (`fork`) => `boolean` = `_hasEIP1559`
Defined in: [src/primitives/Hardfork/index.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L55)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### hasEIP3855()
> `const` **hasEIP3855**: (`fork`) => `boolean` = `_hasEIP3855`
Defined in: [src/primitives/Hardfork/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L58)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### hasEIP4844()
> `const` **hasEIP4844**: (`fork`) => `boolean` = `_hasEIP4844`
Defined in: [src/primitives/Hardfork/index.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L60)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### HOMESTEAD
> `const` **HOMESTEAD**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L15)
***
### isAfter()
> `const` **isAfter**: (`fork`, `minFork`) => `boolean` = `_isAfter`
Defined in: [src/primitives/Hardfork/index.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L45)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
##### minFork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### isAtLeast()
> `const` **isAtLeast**: (`fork`, `minFork`) => `boolean` = `_isAtLeast`
Defined in: [src/primitives/Hardfork/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L41)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
##### minFork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### isBefore()
> `const` **isBefore**: (`fork`, `maxFork`) => `boolean` = `_isBefore`
Defined in: [src/primitives/Hardfork/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L43)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
##### maxFork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### isPoS()
> `const` **isPoS**: (`fork`) => `boolean` = `_isPoS`
Defined in: [src/primitives/Hardfork/index.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L66)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### isPostMerge()
> `const` **isPostMerge**: (`fork`) => `boolean` = `_isPostMerge`
Defined in: [src/primitives/Hardfork/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L65)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### ISTANBUL
> `const` **ISTANBUL**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L38)
***
### isValidName()
> `const` **isValidName**: (`name`) => `boolean` = `_isValidName`
Defined in: [src/primitives/Hardfork/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L40)
#### Parameters
##### name
`string`
#### Returns
`boolean`
***
### LONDON
> `const` **LONDON**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L47)
***
### lt()
> `const` **lt**: (`a`, `b`) => `boolean` = `_lt`
Defined in: [src/primitives/Hardfork/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L51)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### lte()
> `const` **lte**: (`a`, `b`) => `boolean` = `_lte`
Defined in: [src/primitives/Hardfork/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L54)
#### Parameters
##### a
[`HardforkType`](#hardforktype)
##### b
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### max()
> `const` **max**: (`forks`) => [`HardforkType`](#hardforktype) = `_max`
Defined in: [src/primitives/Hardfork/index.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L49)
#### Parameters
##### forks
[`HardforkType`](#hardforktype)\[]
#### Returns
[`HardforkType`](#hardforktype)
***
### MERGE
> `const` **MERGE**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L56)
***
### min()
> `const` **min**: (`forks`) => [`HardforkType`](#hardforktype) = `_min`
Defined in: [src/primitives/Hardfork/index.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L48)
#### Parameters
##### forks
[`HardforkType`](#hardforktype)\[]
#### Returns
[`HardforkType`](#hardforktype)
***
### MUIR\_GLACIER
> `const` **MUIR\_GLACIER**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L41)
***
### NAME\_TO\_HARDFORK
> `const` **NAME\_TO\_HARDFORK**: `object`
Defined in: [src/primitives/Hardfork/constants.js:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L108)
**`Internal`**
Hardfork name to hardfork mapping for string parsing
#### Type Declaration
##### arrowglacier
> **arrowglacier**: [`HardforkType`](#hardforktype) = `ARROW_GLACIER`
##### berlin
> **berlin**: [`HardforkType`](#hardforktype) = `BERLIN`
##### byzantium
> **byzantium**: [`HardforkType`](#hardforktype) = `BYZANTIUM`
##### cancun
> **cancun**: [`HardforkType`](#hardforktype) = `CANCUN`
##### constantinople
> **constantinople**: [`HardforkType`](#hardforktype) = `CONSTANTINOPLE`
##### constantinoplefix
> **constantinoplefix**: [`HardforkType`](#hardforktype) = `PETERSBURG`
##### dao
> **dao**: [`HardforkType`](#hardforktype) = `DAO`
##### frontier
> **frontier**: [`HardforkType`](#hardforktype) = `FRONTIER`
##### grayglacier
> **grayglacier**: [`HardforkType`](#hardforktype) = `GRAY_GLACIER`
##### homestead
> **homestead**: [`HardforkType`](#hardforktype) = `HOMESTEAD`
##### istanbul
> **istanbul**: [`HardforkType`](#hardforktype) = `ISTANBUL`
##### london
> **london**: [`HardforkType`](#hardforktype) = `LONDON`
##### merge
> **merge**: [`HardforkType`](#hardforktype) = `MERGE`
##### muirglacier
> **muirglacier**: [`HardforkType`](#hardforktype) = `MUIR_GLACIER`
##### osaka
> **osaka**: [`HardforkType`](#hardforktype) = `OSAKA`
##### paris
> **paris**: [`HardforkType`](#hardforktype) = `MERGE`
##### petersburg
> **petersburg**: [`HardforkType`](#hardforktype) = `PETERSBURG`
##### prague
> **prague**: [`HardforkType`](#hardforktype) = `PRAGUE`
##### shanghai
> **shanghai**: [`HardforkType`](#hardforktype) = `SHANGHAI`
##### spuriousdragon
> **spuriousdragon**: [`HardforkType`](#hardforktype) = `SPURIOUS_DRAGON`
##### tangerinewhistle
> **tangerinewhistle**: [`HardforkType`](#hardforktype) = `TANGERINE_WHISTLE`
***
### OSAKA
> `const` **OSAKA**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L68)
***
### PETERSBURG
> `const` **PETERSBURG**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L35)
***
### PRAGUE
> `const` **PRAGUE**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L65)
***
### range()
> `const` **range**: (`start`, `end`) => [`HardforkType`](#hardforktype)\[] = `_range`
Defined in: [src/primitives/Hardfork/index.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L69)
#### Parameters
##### start
[`HardforkType`](#hardforktype)
##### end
[`HardforkType`](#hardforktype)
#### Returns
[`HardforkType`](#hardforktype)\[]
***
### SHANGHAI
> `const` **SHANGHAI**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L59)
***
### SPURIOUS\_DRAGON
> `const` **SPURIOUS\_DRAGON**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L26)
***
### supportsBlobs()
> `const` **supportsBlobs**: (`fork`) => `boolean` = `_supportsBlobs`
Defined in: [src/primitives/Hardfork/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L61)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### supportsEIP1559()
> `const` **supportsEIP1559**: (`fork`) => `boolean` = `_supportsEIP1559`
Defined in: [src/primitives/Hardfork/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L56)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### supportsPUSH0()
> `const` **supportsPUSH0**: (`fork`) => `boolean` = `_supportsPUSH0`
Defined in: [src/primitives/Hardfork/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L59)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### supportsTransientStorage()
> `const` **supportsTransientStorage**: (`fork`) => `boolean` = `_supportsTransientStorage`
Defined in: [src/primitives/Hardfork/index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L63)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`boolean`
***
### TANGERINE\_WHISTLE
> `const` **TANGERINE\_WHISTLE**: [`HardforkType`](#hardforktype)
Defined in: [src/primitives/Hardfork/constants.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/constants.js#L21)
***
### toString()
> `const` **toString**: (`fork`) => `string` = `_toString`
Defined in: [src/primitives/Hardfork/index.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hardfork/index.ts#L39)
#### Parameters
##### fork
[`HardforkType`](#hardforktype)
#### Returns
`string`
# primitives/Hash
Source: https://voltaire.tevm.sh/generated-api/primitives/Hash
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Hash
# primitives/Hash
## Variables
### concat()
> `const` **concat**: (...`hashes`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/index.ts#L34)
#### Parameters
##### hashes
...[`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### keccak256()
> `const` **keccak256**: (`data`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/index.ts#L23)
#### Parameters
##### data
`Uint8Array`
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### keccak256Hex()
> `const` **keccak256Hex**: (`hex`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/index.ts#L26)
#### Parameters
##### hex
`string`
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### keccak256String()
> `const` **keccak256String**: (`str`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/index.ts#L29)
#### Parameters
##### str
`string`
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### merkleRoot()
> `const` **merkleRoot**: (`leaves`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/index.ts#L31)
#### Parameters
##### leaves
[`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/Hash/constants.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/constants.js#L4)
Hash size in bytes (32 bytes = 256 bits)
***
### ZERO
> `const` **ZERO**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/constants.js#L10)
Zero hash constant (32 zero bytes)
## Functions
### \_ConcatFactory()
> **\_ConcatFactory**(`deps`): (...`hashes`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/concat.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/concat.js#L9)
Factory: Concatenate multiple hashes and hash the result
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that concatenates and hashes
> (...`hashes`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### hashes
...[`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### \_Keccak256Factory()
> **\_Keccak256Factory**(`deps`): (`data`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/keccak256.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/keccak256.js#L7)
Factory: Hash data with Keccak-256
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes data
> (`data`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### data
`Uint8Array`
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### \_Keccak256HexFactory()
> **\_Keccak256HexFactory**(`deps`): (`hex`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/keccak256Hex.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/keccak256Hex.js#L10)
Factory: Hash hex string with Keccak-256
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes hex strings
> (`hex`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### hex
`string`
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### \_Keccak256StringFactory()
> **\_Keccak256StringFactory**(`deps`): (`str`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/keccak256String.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/keccak256String.js#L9)
Factory: Hash string with Keccak-256
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that hashes strings
> (`str`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### str
`string`
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### \_MerkleRootFactory()
> **\_MerkleRootFactory**(`deps`): (`hashes`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/merkleRoot.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/merkleRoot.js#L10)
Factory: Calculate Merkle root of hash array
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that calculates Merkle root
> (`hashes`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### hashes
[`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### assert()
> **assert**(`value`, `message?`): `asserts value is HashType`
Defined in: [src/primitives/Hash/assert.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/assert.js#L19)
Assert value is a Hash, throws if not
#### Parameters
##### value
`unknown`
Value to assert
##### message?
`string`
Optional error message
#### Returns
`asserts value is HashType`
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
If value is not a Hash
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
Hash.assert(value); // throws if not Hash
```
***
### clone()
> **clone**(`hash`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/clone.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/clone.js#L16)
Clone hash
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to clone
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
New hash with same value
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const copy = Hash.clone(hash);
```
***
### equals()
> **equals**(`hash`, `other`): `boolean`
Defined in: [src/primitives/Hash/equals.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/equals.js#L20)
Compare two hashes for equality
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
First hash
##### other
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to compare with
#### Returns
`boolean`
True if hashes are equal
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash1 = Hash.from('0x1234...');
const hash2 = Hash.from('0x1234...');
const same = Hash.equals(hash1, hash2); // true
```
***
### format()
> **format**(`hash`, `prefixLength?`, `suffixLength?`): `string`
Defined in: [src/primitives/Hash/format.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/format.js#L18)
Format hash for display (truncated)
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to format
##### prefixLength?
`number` = `6`
Number of chars to show at start
##### suffixLength?
`number` = `4`
Number of chars to show at end
#### Returns
`string`
Formatted string like "0x1234...5678"
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const display = Hash.format(hash); // "0x1234...5678"
```
***
### from()
> **from**(`value`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/from.js#L19)
Create Hash from string or bytes
#### Parameters
##### value
Hex string with optional 0x prefix or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash bytes
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
If input is invalid or wrong length
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const hash2 = Hash.from(new Uint8Array(32));
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/fromBytes.js#L18)
Create Hash from raw bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 32 bytes)
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash bytes
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
If bytes is wrong length
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.fromBytes(new Uint8Array(32));
```
***
### fromHex()
> **fromHex**(`hex`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/fromHex.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/fromHex.js#L20)
Create Hash from hex string
#### Parameters
##### hex
`string`
Hex string with optional 0x prefix
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash bytes
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
If hex is wrong length
#### Throws
If hex contains invalid characters
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.fromHex('0x1234...');
const hash2 = Hash.fromHex('1234...'); // 0x prefix optional
```
***
### isHash()
> **isHash**(`value`): `value is HashType`
Defined in: [src/primitives/Hash/isHash.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/isHash.js#L19)
Check if value is a valid Hash
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is HashType`
True if value is Hash type
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
if (Hash.isHash(value)) {
// value is Hash
}
```
***
### isValidHex()
> **isValidHex**(`hex`): `boolean`
Defined in: [src/primitives/Hash/isValidHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/isValidHex.js#L19)
Validate hex string is valid hash format
#### Parameters
##### hex
`string`
Hex string to validate
#### Returns
`boolean`
True if valid hash hex format
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
if (Hash.isValidHex('0x1234...')) {
const hash = Hash.fromHex('0x1234...');
}
```
***
### isZero()
> **isZero**(`hash`): `boolean`
Defined in: [src/primitives/Hash/isZero.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/isZero.js#L18)
Check if hash is zero hash
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to check
#### Returns
`boolean`
True if hash is all zeros
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x00...');
const zero = Hash.isZero(hash); // true
```
***
### random()
> **random**(): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Hash/random.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/random.js#L17)
Generate random hash
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Random 32-byte hash
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
If crypto.getRandomValues not available
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.random();
```
***
### slice()
> **slice**(`hash`, `start?`, `end?`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Hash/slice.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/slice.js#L18)
Get slice of hash
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to slice
##### start?
`number`
Start index (inclusive)
##### end?
`number`
End index (exclusive)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Slice of hash bytes
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const selector = Hash.slice(hash, 0, 4);
```
***
### toBytes()
> **toBytes**(`hash`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Hash/toBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/toBytes.js#L16)
Convert Hash to raw bytes
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Copy of hash bytes
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const bytes = Hash.toBytes(hash);
```
***
### toHex()
> **toHex**(`hash`): `string`
Defined in: [src/primitives/Hash/toHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/toHex.js#L16)
Convert Hash to hex string
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const hex = Hash.toHex(hash); // "0x1234..."
```
***
### toString()
> **toString**(`hash`): `string`
Defined in: [src/primitives/Hash/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hash/toString.js#L17)
Convert Hash to string (alias for toHex)
#### Parameters
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/hash](https://voltaire.tevm.sh/primitives/hash) for Hash documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Hash from './primitives/Hash/index.js';
const hash = Hash.from('0x1234...');
const str = Hash.toString(hash);
```
## References
### Hash
Re-exports [Hash](../index/index.mdx#hash)
***
### HashLike
Re-exports [HashLike](../index/namespaces/HashType.mdx#hashlike)
***
### HashType
Re-exports [HashType](../index/namespaces/HashType.mdx#hashtype)
***
### HashTypeInterface
Renames and re-exports [HashType](../index/namespaces/HashType.mdx#hashtype)
# primitives/Hex
Source: https://voltaire.tevm.sh/generated-api/primitives/Hex
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Hex
# primitives/Hex
## Classes
### InvalidCharacterError
Defined in: [src/primitives/Hex/errors.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L15)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidCharacterError**(`message`): [`InvalidCharacterError`](#invalidcharactererror)
Defined in: [src/primitives/Hex/errors.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L16)
###### Parameters
###### message
`string` = `"Invalid hex character"`
###### Returns
[`InvalidCharacterError`](#invalidcharactererror)
###### Overrides
`Error.constructor`
***
### InvalidFormatError
Defined in: [src/primitives/Hex/errors.ts:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidFormatError**(`message`): [`InvalidFormatError`](#invalidformaterror)
Defined in: [src/primitives/Hex/errors.ts:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L2)
###### Parameters
###### message
`string` = `"Invalid hex format: missing 0x prefix"`
###### Returns
[`InvalidFormatError`](#invalidformaterror)
###### Overrides
`Error.constructor`
***
### InvalidLengthError
Defined in: [src/primitives/Hex/errors.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L8)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidLengthError**(`message`): [`InvalidLengthError`](#invalidlengtherror)
Defined in: [src/primitives/Hex/errors.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L9)
###### Parameters
###### message
`string` = `"Invalid hex length"`
###### Returns
[`InvalidLengthError`](#invalidlengtherror)
###### Overrides
`Error.constructor`
***
### OddLengthError
Defined in: [src/primitives/Hex/errors.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L22)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new OddLengthError**(`message`): [`OddLengthError`](#oddlengtherror)
Defined in: [src/primitives/Hex/errors.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L23)
###### Parameters
###### message
`string` = `"Odd length hex string"`
###### Returns
[`OddLengthError`](#oddlengtherror)
###### Overrides
`Error.constructor`
## Type Aliases
### Bytes
> **Bytes**\<`N`> = [`Sized`](#sized)\<`N`>
Defined in: [src/primitives/Hex/HexType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/HexType.ts#L25)
Hex string of exactly N bytes
#### Type Parameters
##### N
`N` *extends* `number`
***
### HexBrand
> **HexBrand** = [`HexType`](#hextype)
Defined in: [src/primitives/Hex/HexType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/HexType.ts#L11)
Alias for HexType
***
### HexType
> **HexType** = `` `0x${string}` `` & `object`
Defined in: [src/primitives/Hex/HexType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/HexType.ts#L6)
Branded Hex type (unsized)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Hex"`
***
### Sized
> **Sized**\<`TSize`> = `` `0x${string}` `` & `object`
Defined in: [src/primitives/Hex/HexType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/HexType.ts#L17)
Sized Hex type with specific byte size
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Hex"`
##### size
> `readonly` **size**: `TSize`
#### Type Parameters
##### TSize
`TSize` *extends* `number` = `number`
#### Example
```ts theme={null}
HexType.Sized<4> = '0x12345678' (4 bytes = 8 hex chars)
```
## Variables
### fromBytes()
> `const` **fromBytes**: (`bytes`) => [`HexType`](#hextype) = `HexFuncs.fromBytes`
Defined in: [src/primitives/Hex/Hex.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/Hex.ts#L8)
Convert bytes to hex
#### Parameters
##### bytes
`Uint8Array`
Byte array to convert
#### Returns
[`HexType`](#hextype)
Hex string
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.fromBytes(new Uint8Array([0x12, 0x34])); // '0x1234'
```
***
### InvalidHexCharacterError
> `const` **InvalidHexCharacterError**: *typeof* [`InvalidCharacterError`](#invalidcharactererror) = `InvalidCharacterError`
Defined in: [src/primitives/Hex/errors.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L31)
***
### InvalidHexFormatError
> `const` **InvalidHexFormatError**: *typeof* [`InvalidFormatError`](#invalidformaterror) = `InvalidFormatError`
Defined in: [src/primitives/Hex/errors.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L30)
***
### InvalidHexLengthError
> `const` **InvalidHexLengthError**: *typeof* [`InvalidLengthError`](#invalidlengtherror) = `InvalidLengthError`
Defined in: [src/primitives/Hex/errors.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L33)
***
### OddLengthHexError
> `const` **OddLengthHexError**: *typeof* [`OddLengthError`](#oddlengtherror) = `OddLengthError`
Defined in: [src/primitives/Hex/errors.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/errors.ts#L32)
***
### toBytes()
> `const` **toBytes**: (`hex`) => `Uint8Array` = `HexFuncs.toBytes`
Defined in: [src/primitives/Hex/Hex.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Hex/Hex.ts#L9)
Convert hex to bytes
#### Parameters
##### hex
Hex string to convert
`string` | [`HexType`](#hextype)
#### Returns
`Uint8Array`
Byte array
#### See
[https://voltaire.tevm.sh/primitives/hex](https://voltaire.tevm.sh/primitives/hex) for Hex documentation
#### Since
0.0.0
#### Throws
If missing 0x prefix or contains invalid hex characters
#### Throws
If hex has odd number of digits
#### Example
```typescript theme={null}
import * as Hex from './primitives/Hex/index.js';
const hex = Hex.from('0x1234');
const bytes = Hex.toBytes(hex); // Uint8Array([0x12, 0x34])
```
## References
### default
Renames and re-exports [Hex](../index/index.mdx#hex)
***
### Hex
Re-exports [Hex](../index/index.mdx#hex)
# primitives/InitCode
Source: https://voltaire.tevm.sh/generated-api/primitives/InitCode
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/InitCode
# primitives/InitCode
## Type Aliases
### InitCodeType
> **InitCodeType** = `Uint8Array` & `object`
Defined in: [src/primitives/InitCode/InitCodeType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/InitCodeType.ts#L8)
Branded InitCode type
Contract creation bytecode (constructor + runtime code)
Deployed during contract creation transaction
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"InitCode"`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/InitCode/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/equals.js#L15)
Check if two InitCode instances are equal
#### Parameters
##### a
[`InitCodeType`](#initcodetype)
First InitCode
##### b
[`InitCodeType`](#initcodetype)
Second InitCode
#### Returns
`boolean`
true if equal
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const code1 = InitCode.from("0x6001");
const code2 = InitCode.from("0x6001");
InitCode._equals(code1, code2); // true
```
***
### \_estimateGas()
> **\_estimateGas**(`code`): `bigint`
Defined in: [src/primitives/InitCode/estimateGas.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/estimateGas.js#L16)
Estimate gas cost for contract creation
Gas cost = 21000 (base) + 200 \* non-zero bytes + 4 \* zero bytes + 32000 (creation)
#### Parameters
##### code
[`InitCodeType`](#initcodetype)
InitCode
#### Returns
`bigint`
Estimated gas cost
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const init = InitCode.from("0x608060405234801561001057600080fd5b50...");
const gas = InitCode._estimateGas(init);
console.log(`Estimated gas: ${gas}`);
```
***
### \_extractRuntime()
> **\_extractRuntime**(`code`, `offset`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/InitCode/extractRuntime.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/extractRuntime.js#L18)
Extract runtime code from init code at specified offset
Init code contains constructor logic followed by runtime code.
This extracts the runtime portion starting at the given offset.
#### Parameters
##### code
[`InitCodeType`](#initcodetype)
InitCode
##### offset
`number`
Byte offset where runtime code starts
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
RuntimeCode
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const init = InitCode.from("0x608060405234801561001057600080fd5b50...");
// Assume constructor is 100 bytes
const runtime = InitCode._extractRuntime(init, 100);
```
***
### \_toHex()
> **\_toHex**(`data`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/InitCode/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/toHex.js#L15)
Convert InitCode to hex string
#### Parameters
##### data
[`InitCodeType`](#initcodetype)
InitCode
#### Returns
[`HexType`](Hex.mdx#hextype)
Hex string
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const code = InitCode.from("0x608060405234801561001057600080fd5b50...");
const hex = InitCode._toHex(code);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/InitCode/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/index.ts#L18)
#### Parameters
##### a
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`InitCodeType`](#initcodetype)
##### b
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`InitCodeType`](#initcodetype)
#### Returns
`boolean`
***
### estimateGas()
> **estimateGas**(`value`): `bigint`
Defined in: [src/primitives/InitCode/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/index.ts#L38)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`InitCodeType`](#initcodetype)
#### Returns
`bigint`
***
### extractRuntime()
> **extractRuntime**(`value`, `offset`): [`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
Defined in: [src/primitives/InitCode/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/index.ts#L31)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`InitCodeType`](#initcodetype)
##### offset
`number`
#### Returns
[`RuntimeCodeType`](RuntimeCode.mdx#runtimecodetype)
***
### from()
> **from**(`value`): [`InitCodeType`](#initcodetype)
Defined in: [src/primitives/InitCode/from.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/from.js#L18)
Create InitCode from various input types
#### Parameters
##### value
Hex string or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`InitCodeType`](#initcodetype)
InitCode
#### See
[https://voltaire.tevm.sh/primitives/init-code](https://voltaire.tevm.sh/primitives/init-code) for InitCode documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const code1 = InitCode.from("0x608060405234801561001057600080fd5b50...");
const code2 = InitCode.from(new Uint8Array([0x60, 0x80, 0x60, 0x40, ...]));
```
***
### fromHex()
> **fromHex**(`hex`): [`InitCodeType`](#initcodetype)
Defined in: [src/primitives/InitCode/fromHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/fromHex.js#L15)
Create InitCode from hex string
#### Parameters
##### hex
`string`
Hex string
#### Returns
[`InitCodeType`](#initcodetype)
InitCode
#### Throws
If hex string is invalid
#### Example
```javascript theme={null}
import * as InitCode from './primitives/InitCode/index.js';
const code = InitCode.fromHex("0x608060405234801561001057600080fd5b50...");
```
***
### toHex()
> **toHex**(`value`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/InitCode/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/InitCode/index.ts#L25)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`InitCodeType`](#initcodetype)
#### Returns
[`HexType`](Hex.mdx#hextype)
# primitives/Int128
Source: https://voltaire.tevm.sh/generated-api/primitives/Int128
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int128
# primitives/Int128
## Type Aliases
### BrandedInt128
> **BrandedInt128** = `bigint` & `object`
Defined in: [src/primitives/Int128/Int128Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/Int128Type.ts#L9)
Branded Int128 type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int128"`
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
## Variables
### BITS
> `const` **BITS**: `number` = `128`
Defined in: [src/primitives/Int128/constants.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L48)
Size in bits
***
### Int128
> `const` **Int128**: `object`
Defined in: [src/primitives/Int128/index.ts:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/index.ts#L103)
#### Type Declaration
##### abs()
> **abs**: (`value`) => [`BrandedInt128`](#brandedint128)
Absolute value of Int128
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
[`BrandedInt128`](#brandedint128)
Absolute value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If value is MIN (abs(MIN) overflows)
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.abs(a); // 42n
```
##### bitLength()
> **bitLength**: (`value`) => `number`
Get bit length of Int128 value
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`number`
Number of bits needed to represent value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(255n);
Int128.bitLength(a); // 8
```
##### BITS
> **BITS**: `number`
Size in bits
##### bitwiseAnd()
> **bitwiseAnd**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Bitwise AND of Int128 values
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
[`BrandedInt128`](#brandedint128)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x07n);
Int128.bitwiseAnd(a, b); // 0x07n
```
##### bitwiseNot()
> **bitwiseNot**: (`value`) => [`BrandedInt128`](#brandedint128)
Bitwise NOT of Int128 value
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
[`BrandedInt128`](#brandedint128)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
Int128.bitwiseNot(a); // -1n
```
##### bitwiseOr()
> **bitwiseOr**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Bitwise OR of Int128 values
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
[`BrandedInt128`](#brandedint128)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x70n);
Int128.bitwiseOr(a, b); // 0x7fn
```
##### bitwiseXor()
> **bitwiseXor**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Bitwise XOR of Int128 values
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
[`BrandedInt128`](#brandedint128)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x07n);
Int128.bitwiseXor(a, b); // 0x08n
```
##### dividedBy()
> **dividedBy**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Divide Int128 values (truncate toward zero)
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
Dividend
###### b
[`BrandedInt128`](#brandedint128)
Divisor
###### Returns
[`BrandedInt128`](#brandedint128)
Quotient (truncated toward zero)
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If divisor is zero or MIN / -1 (overflow)
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-10n);
const b = Int128.from(3n);
const quotient = Int128.dividedBy(a, b); // -3n (not -4n)
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check Int128 equality
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
`boolean`
True if equal
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(-42n);
Int128.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`BrandedInt128`](#brandedint128)
Create Int128 from bigint, number, or string
###### Parameters
###### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
###### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-100n);
const b = Int128.from("-255");
const c = Int128.from("0xff");
const d = Int128.from(-42);
```
##### fromBigInt()
> **fromBigInt**: (`value`) => [`BrandedInt128`](#brandedint128)
Create Int128 from bigint
###### Parameters
###### value
`bigint`
BigInt value
###### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromBigInt(-42n);
const b = Int128.fromBigInt(100n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedInt128`](#brandedint128)
Create Int128 from bytes (two's complement, big-endian)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array (16 bytes)
###### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If bytes length is incorrect
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const bytes = new Uint8Array(16);
bytes[15] = 0xff; // -1
const value = Int128.fromBytes(bytes);
```
##### fromHex()
> **fromHex**: (`hex`) => [`BrandedInt128`](#brandedint128)
Create Int128 from hex string (two's complement)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If hex is invalid or out of range
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromHex("0x7fffffffffffffffffffffffffffffff"); // MAX
const b = Int128.fromHex("0x80000000000000000000000000000000"); // MIN
const c = Int128.fromHex("0xffffffffffffffffffffffffffffffff"); // -1
```
##### fromNumber()
> **fromNumber**: (`value`) => [`BrandedInt128`](#brandedint128)
Create Int128 from number
###### Parameters
###### value
`number`
Integer number
###### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If value is not an integer or out of range
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromNumber(-42);
const b = Int128.fromNumber(100);
```
##### greaterThan()
> **greaterThan**: (`a`, `b`) => `boolean`
Check if Int128 is greater than another
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
`boolean`
True if a > b
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
const b = Int128.from(-1n);
Int128.greaterThan(a, b); // true
```
##### isNegative()
> **isNegative**: (`value`) => `boolean`
Check if Int128 is negative
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`boolean`
True if negative
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.isNegative(a); // true
```
##### isPositive()
> **isPositive**: (`value`) => `boolean`
Check if Int128 is positive
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`boolean`
True if positive
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(42n);
Int128.isPositive(a); // true
```
##### isValid()
> **isValid**: (`value`) => `boolean`
Check if value is valid Int128
###### Parameters
###### value
`bigint`
Value to check
###### Returns
`boolean`
True if valid Int128
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
Int128.isValid(-42n); // true
Int128.isValid(2n ** 127n); // false (exceeds MAX)
```
##### isZero()
> **isZero**: (`value`) => `boolean`
Check if Int128 is zero
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`boolean`
True if zero
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
Int128.isZero(a); // true
```
##### leadingZeros()
> **leadingZeros**: (`value`) => `number`
Count leading zeros in Int128 two's complement representation
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`number`
Number of leading zero bits
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(1n);
Int128.leadingZeros(a); // 127
```
##### lessThan()
> **lessThan**: (`a`, `b`) => `boolean`
Check if Int128 is less than another
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
`boolean`
True if a \< b
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
const b = Int128.from(0n);
Int128.lessThan(a, b); // true
```
##### MAX
> **MAX**: `bigint`
Maximum Int128 value: 2^127 - 1
##### maximum()
> **maximum**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Return maximum of two Int128 values
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
[`BrandedInt128`](#brandedint128)
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(10n);
Int128.maximum(a, b); // 10n
```
##### MIN
> **MIN**: `bigint`
Minimum Int128 value: -2^127
##### minimum()
> **minimum**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Return minimum of two Int128 values
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First value
###### b
[`BrandedInt128`](#brandedint128)
Second value
###### Returns
[`BrandedInt128`](#brandedint128)
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(10n);
Int128.minimum(a, b); // -42n
```
##### minus()
> **minus**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Subtract Int128 values with wrapping
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
Minuend
###### b
[`BrandedInt128`](#brandedint128)
Subtrahend
###### Returns
[`BrandedInt128`](#brandedint128)
Difference with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(100n);
const b = Int128.from(50n);
const diff = Int128.minus(a, b); // 50n
```
##### modulo()
> **modulo**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Modulo Int128 values (sign follows dividend)
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
Dividend
###### b
[`BrandedInt128`](#brandedint128)
Divisor
###### Returns
[`BrandedInt128`](#brandedint128)
Remainder (sign follows dividend)
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-10n);
const b = Int128.from(3n);
const remainder = Int128.modulo(a, b); // -1n (not 2n)
```
##### MODULO
> **MODULO**: `bigint`
Modulo value for wrapping: 2^128
##### NEG\_ONE
> **NEG\_ONE**: `bigint`
Negative one value
##### negate()
> **negate**: (`value`) => [`BrandedInt128`](#brandedint128)
Negate Int128 value with wrapping
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
[`BrandedInt128`](#brandedint128)
Negated value with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(42n);
Int128.negate(a); // -42n
const min = Int128.from(Int128.MIN);
Int128.negate(min); // MIN (wraps around)
```
##### ONE
> **ONE**: `bigint`
One value
##### plus()
> **plus**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Add Int128 values with wrapping
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First operand
###### b
[`BrandedInt128`](#brandedint128)
Second operand
###### Returns
[`BrandedInt128`](#brandedint128)
Sum with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-100n);
const b = Int128.from(50n);
const sum = Int128.plus(a, b); // -50n
```
##### popCount()
> **popCount**: (`value`) => `number`
Count set bits in Int128 two's complement representation
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`number`
Number of set bits
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
Int128.popCount(a); // 4
```
##### shiftLeft()
> **shiftLeft**: (`value`, `shift`) => [`BrandedInt128`](#brandedint128)
Shift Int128 left with wrapping
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Value to shift
###### shift
Shift amount
`number` | `bigint`
###### Returns
[`BrandedInt128`](#brandedint128)
Shifted value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(1n);
Int128.shiftLeft(a, 8); // 256n
```
##### shiftRight()
> **shiftRight**: (`value`, `shift`) => [`BrandedInt128`](#brandedint128)
Arithmetic right shift of Int128 (sign-preserving)
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Value to shift
###### shift
Shift amount
`number` | `bigint`
###### Returns
[`BrandedInt128`](#brandedint128)
Shifted value (sign-extended)
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-256n);
Int128.shiftRight(a, 1); // -128n (sign preserved)
```
##### sign()
> **sign**: (`value`) => `-1` | `0` | `1`
Get sign of Int128 value
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Input value
###### Returns
`-1` | `0` | `1`
-1 for negative, 0 for zero, 1 for positive
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.sign(a); // -1
const b = Int128.from(0n);
Int128.sign(b); // 0
const c = Int128.from(42n);
Int128.sign(c); // 1
```
##### SIZE
> **SIZE**: `number`
Size in bytes
##### times()
> **times**: (`a`, `b`) => [`BrandedInt128`](#brandedint128)
Multiply Int128 values with wrapping
###### Parameters
###### a
[`BrandedInt128`](#brandedint128)
First operand
###### b
[`BrandedInt128`](#brandedint128)
Second operand
###### Returns
[`BrandedInt128`](#brandedint128)
Product with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(10n);
const b = Int128.from(-5n);
const product = Int128.times(a, b); // -50n
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint`
Convert Int128 to bigint
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Int128 value
###### Returns
`bigint`
BigInt value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toBigInt(a); // -42n
```
##### toBytes()
> **toBytes**: (`value`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Int128 to bytes (two's complement, big-endian)
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Int128 value
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Byte array (16 bytes)
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
const bytes = Int128.toBytes(a); // [0xff, 0xff, ..., 0xff]
```
##### toHex()
> **toHex**: (`value`) => `string`
Convert Int128 to hex string (two's complement)
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Int128 value
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
Int128.toHex(a); // "0xffffffffffffffffffffffffffffffff"
const b = Int128.from(255n);
Int128.toHex(b); // "0x000000000000000000000000000000ff"
```
##### toNumber()
> **toNumber**: (`value`) => `number`
Convert Int128 to number (warns on overflow)
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Int128 value
###### Returns
`number`
Number value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or Number.MIN\_SAFE\_INTEGER
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toNumber(a); // -42
```
##### toString()
> **toString**: (`value`) => `string`
Convert Int128 to decimal string
###### Parameters
###### value
[`BrandedInt128`](#brandedint128)
Int128 value
###### Returns
`string`
Decimal string
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toString(a); // "-42"
```
##### ZERO
> **ZERO**: `bigint`
Zero value
***
### MAX
> `const` **MAX**: `bigint`
Defined in: [src/primitives/Int128/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L18)
Maximum Int128 value: 2^127 - 1
***
### MIN
> `const` **MIN**: `bigint`
Defined in: [src/primitives/Int128/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L12)
Minimum Int128 value: -2^127
***
### MODULO
> `const` **MODULO**: `bigint`
Defined in: [src/primitives/Int128/constants.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L54)
Modulo value for wrapping: 2^128
***
### NEG\_ONE
> `const` **NEG\_ONE**: `bigint` = `-1n`
Defined in: [src/primitives/Int128/constants.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L36)
Negative one value
***
### ONE
> `const` **ONE**: `bigint` = `1n`
Defined in: [src/primitives/Int128/constants.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L30)
One value
***
### SIZE
> `const` **SIZE**: `number` = `16`
Defined in: [src/primitives/Int128/constants.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L42)
Size in bytes
***
### ZERO
> `const` **ZERO**: `bigint` = `0n`
Defined in: [src/primitives/Int128/constants.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/constants.js#L24)
Zero value
## Functions
### abs()
> **abs**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/abs.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/abs.js#L18)
Absolute value of Int128
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
[`BrandedInt128`](#brandedint128)
Absolute value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If value is MIN (abs(MIN) overflows)
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.abs(a); // 42n
```
***
### bitLength()
> **bitLength**(`value`): `number`
Defined in: [src/primitives/Int128/bitLength.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/bitLength.js#L17)
Get bit length of Int128 value
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`number`
Number of bits needed to represent value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(255n);
Int128.bitLength(a); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/bitwiseAnd.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/bitwiseAnd.js#L19)
Bitwise AND of Int128 values
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
[`BrandedInt128`](#brandedint128)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x07n);
Int128.bitwiseAnd(a, b); // 0x07n
```
***
### bitwiseNot()
> **bitwiseNot**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/bitwiseNot.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/bitwiseNot.js#L17)
Bitwise NOT of Int128 value
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
[`BrandedInt128`](#brandedint128)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
Int128.bitwiseNot(a); // -1n
```
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/bitwiseOr.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/bitwiseOr.js#L19)
Bitwise OR of Int128 values
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
[`BrandedInt128`](#brandedint128)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x70n);
Int128.bitwiseOr(a, b); // 0x7fn
```
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/bitwiseXor.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/bitwiseXor.js#L19)
Bitwise XOR of Int128 values
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
[`BrandedInt128`](#brandedint128)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
const b = Int128.from(0x07n);
Int128.bitwiseXor(a, b); // 0x08n
```
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/dividedBy.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/dividedBy.js#L20)
Divide Int128 values (truncate toward zero)
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
Dividend
##### b
[`BrandedInt128`](#brandedint128)
Divisor
#### Returns
[`BrandedInt128`](#brandedint128)
Quotient (truncated toward zero)
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If divisor is zero or MIN / -1 (overflow)
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-10n);
const b = Int128.from(3n);
const quotient = Int128.dividedBy(a, b); // -3n (not -4n)
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int128/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/equals.js#L17)
Check Int128 equality
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(-42n);
Int128.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/from.js#L20)
Create Int128 from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-100n);
const b = Int128.from("-255");
const c = Int128.from("0xff");
const d = Int128.from(-42);
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/fromBigInt.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/fromBigInt.js#L18)
Create Int128 from bigint
#### Parameters
##### value
`bigint`
BigInt value
#### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromBigInt(-42n);
const b = Int128.fromBigInt(100n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/fromBytes.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/fromBytes.js#L19)
Create Int128 from bytes (two's complement, big-endian)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array (16 bytes)
#### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If bytes length is incorrect
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const bytes = new Uint8Array(16);
bytes[15] = 0xff; // -1
const value = Int128.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/fromHex.js#L19)
Create Int128 from hex string (two's complement)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If hex is invalid or out of range
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromHex("0x7fffffffffffffffffffffffffffffff"); // MAX
const b = Int128.fromHex("0x80000000000000000000000000000000"); // MIN
const c = Int128.fromHex("0xffffffffffffffffffffffffffffffff"); // -1
```
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/fromNumber.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/fromNumber.js#L18)
Create Int128 from number
#### Parameters
##### value
`number`
Integer number
#### Returns
[`BrandedInt128`](#brandedint128)
Int128 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If value is not an integer or out of range
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.fromNumber(-42);
const b = Int128.fromNumber(100);
```
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int128/greaterThan.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/greaterThan.js#L17)
Check if Int128 is greater than another
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
`boolean`
True if a > b
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
const b = Int128.from(-1n);
Int128.greaterThan(a, b); // true
```
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int128/isNegative.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/isNegative.js#L15)
Check if Int128 is negative
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`boolean`
True if negative
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.isNegative(a); // true
```
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int128/isPositive.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/isPositive.js#L15)
Check if Int128 is positive
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`boolean`
True if positive
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(42n);
Int128.isPositive(a); // true
```
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int128/isValid.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/isValid.js#L17)
Check if value is valid Int128
#### Parameters
##### value
`bigint`
Value to check
#### Returns
`boolean`
True if valid Int128
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
Int128.isValid(-42n); // true
Int128.isValid(2n ** 127n); // false (exceeds MAX)
```
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int128/isZero.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/isZero.js#L15)
Check if Int128 is zero
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`boolean`
True if zero
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0n);
Int128.isZero(a); // true
```
***
### leadingZeros()
> **leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int128/leadingZeros.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/leadingZeros.js#L17)
Count leading zeros in Int128 two's complement representation
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`number`
Number of leading zero bits
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(1n);
Int128.leadingZeros(a); // 127
```
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int128/lessThan.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/lessThan.js#L17)
Check if Int128 is less than another
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
`boolean`
True if a \< b
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
const b = Int128.from(0n);
Int128.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/maximum.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/maximum.js#L17)
Return maximum of two Int128 values
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
[`BrandedInt128`](#brandedint128)
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(10n);
Int128.maximum(a, b); // 10n
```
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/minimum.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/minimum.js#L17)
Return minimum of two Int128 values
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First value
##### b
[`BrandedInt128`](#brandedint128)
Second value
#### Returns
[`BrandedInt128`](#brandedint128)
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
const b = Int128.from(10n);
Int128.minimum(a, b); // -42n
```
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/minus.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/minus.js#L19)
Subtract Int128 values with wrapping
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
Minuend
##### b
[`BrandedInt128`](#brandedint128)
Subtrahend
#### Returns
[`BrandedInt128`](#brandedint128)
Difference with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(100n);
const b = Int128.from(50n);
const diff = Int128.minus(a, b); // 50n
```
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/modulo.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/modulo.js#L18)
Modulo Int128 values (sign follows dividend)
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
Dividend
##### b
[`BrandedInt128`](#brandedint128)
Divisor
#### Returns
[`BrandedInt128`](#brandedint128)
Remainder (sign follows dividend)
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-10n);
const b = Int128.from(3n);
const remainder = Int128.modulo(a, b); // -1n (not 2n)
```
***
### negate()
> **negate**(`value`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/negate.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/negate.js#L19)
Negate Int128 value with wrapping
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
[`BrandedInt128`](#brandedint128)
Negated value with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(42n);
Int128.negate(a); // -42n
const min = Int128.from(Int128.MIN);
Int128.negate(min); // MIN (wraps around)
```
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/plus.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/plus.js#L19)
Add Int128 values with wrapping
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First operand
##### b
[`BrandedInt128`](#brandedint128)
Second operand
#### Returns
[`BrandedInt128`](#brandedint128)
Sum with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-100n);
const b = Int128.from(50n);
const sum = Int128.plus(a, b); // -50n
```
***
### popCount()
> **popCount**(`value`): `number`
Defined in: [src/primitives/Int128/popCount.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/popCount.js#L17)
Count set bits in Int128 two's complement representation
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`number`
Number of set bits
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(0x0fn);
Int128.popCount(a); // 4
```
***
### shiftLeft()
> **shiftLeft**(`value`, `shift`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/shiftLeft.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/shiftLeft.js#L18)
Shift Int128 left with wrapping
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Value to shift
##### shift
Shift amount
`number` | `bigint`
#### Returns
[`BrandedInt128`](#brandedint128)
Shifted value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(1n);
Int128.shiftLeft(a, 8); // 256n
```
***
### shiftRight()
> **shiftRight**(`value`, `shift`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/shiftRight.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/shiftRight.js#L18)
Arithmetic right shift of Int128 (sign-preserving)
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Value to shift
##### shift
Shift amount
`number` | `bigint`
#### Returns
[`BrandedInt128`](#brandedint128)
Shifted value (sign-extended)
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-256n);
Int128.shiftRight(a, 1); // -128n (sign preserved)
```
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int128/sign.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/sign.js#L19)
Get sign of Int128 value
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Input value
#### Returns
`-1` | `0` | `1`
-1 for negative, 0 for zero, 1 for positive
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.sign(a); // -1
const b = Int128.from(0n);
Int128.sign(b); // 0
const c = Int128.from(42n);
Int128.sign(c); // 1
```
***
### times()
> **times**(`a`, `b`): [`BrandedInt128`](#brandedint128)
Defined in: [src/primitives/Int128/times.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/times.js#L19)
Multiply Int128 values with wrapping
#### Parameters
##### a
[`BrandedInt128`](#brandedint128)
First operand
##### b
[`BrandedInt128`](#brandedint128)
Second operand
#### Returns
[`BrandedInt128`](#brandedint128)
Product with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(10n);
const b = Int128.from(-5n);
const product = Int128.times(a, b); // -50n
```
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/Int128/toBigInt.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/toBigInt.js#L15)
Convert Int128 to bigint
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Int128 value
#### Returns
`bigint`
BigInt value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toBigInt(a); // -42n
```
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int128/toBytes.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/toBytes.js#L17)
Convert Int128 to bytes (two's complement, big-endian)
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Int128 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Byte array (16 bytes)
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
const bytes = Int128.toBytes(a); // [0xff, 0xff, ..., 0xff]
```
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int128/toHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/toHex.js#L19)
Convert Int128 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Int128 value
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-1n);
Int128.toHex(a); // "0xffffffffffffffffffffffffffffffff"
const b = Int128.from(255n);
Int128.toHex(b); // "0x000000000000000000000000000000ff"
```
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int128/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/toNumber.js#L16)
Convert Int128 to number (warns on overflow)
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Int128 value
#### Returns
`number`
Number value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or Number.MIN\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toNumber(a); // -42
```
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int128/toString.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int128/toString.js#L16)
Convert Int128 to decimal string
#### Parameters
##### value
[`BrandedInt128`](#brandedint128)
Int128 value
#### Returns
`string`
Decimal string
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int128 from './primitives/Int128/index.js';
const a = Int128.from(-42n);
Int128.toString(a); // "-42"
```
# primitives/Int16
Source: https://voltaire.tevm.sh/generated-api/primitives/Int16
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int16
# primitives/Int16
## Type Aliases
### BrandedInt16
> **BrandedInt16** = `number` & `object`
Defined in: [src/primitives/Int16/Int16Type.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/Int16Type.ts#L24)
A signed 16-bit integer branded type.
Internally a JavaScript number constrained to \[-32768, 32767].
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int16"`
***
### Int16Input
> **Int16Input** = `number` | `bigint` | `string` | [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L63)
## Variables
### INT16\_MAX
> `const` **INT16\_MAX**: `32767` = `32767`
Defined in: [src/primitives/Int16/Int16Type.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/Int16Type.ts#L29)
***
### INT16\_MIN
> `const` **INT16\_MIN**: `-32768` = `-32768`
Defined in: [src/primitives/Int16/Int16Type.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/Int16Type.ts#L28)
## Functions
### \_abs()
> **\_abs**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L88)
Absolute value
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_and()
> **\_and**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L7)
Bitwise AND
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_bitLength()
> **\_bitLength**(`value`): `number`
Defined in: [src/primitives/Int16/utilities.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/utilities.js#L8)
Get bit length (number of bits needed to represent value)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`number`
***
### \_dividedBy()
> **\_dividedBy**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L53)
Divide two BrandedInt16 values (EVM SDIV semantics - truncate toward zero)
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L7)
Check if two BrandedInt16 values are equal
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_greaterThan()
> **\_greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L27)
Check if a > b
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_isNegative()
> **\_isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L45)
Check if value is negative
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_isPositive()
> **\_isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L54)
Check if value is positive (> 0)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_isZero()
> **\_isZero**(`value`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L36)
Check if value is zero
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_leadingZeros()
> **\_leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int16/utilities.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/utilities.js#L20)
Count leading zeros in binary representation
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`number`
***
### \_lessThan()
> **\_lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/comparison.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L17)
Check if a \< b
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
`boolean`
***
### \_maximum()
> **\_maximum**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/comparison.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L74)
Get maximum of two values
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_minimum()
> **\_minimum**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/comparison.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L64)
Get minimum of two values
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_minus()
> **\_minus**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L23)
Subtract two BrandedInt16 values
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_modulo()
> **\_modulo**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L74)
Modulo operation (EVM SMOD semantics - sign follows dividend)
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_negate()
> **\_negate**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L102)
Negate value
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_not()
> **\_not**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L50)
Bitwise NOT
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_or()
> **\_or**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L23)
Bitwise OR
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_plus()
> **\_plus**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L9)
Add two BrandedInt16 values
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_popCount()
> **\_popCount**(`value`): `number`
Defined in: [src/primitives/Int16/utilities.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/utilities.js#L37)
Count set bits (population count)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`number`
***
### \_shiftLeft()
> **\_shiftLeft**(`value`, `shift`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L63)
Left shift
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
##### shift
`number`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_shiftRight()
> **\_shiftRight**(`value`, `shift`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L79)
Arithmetic right shift (preserves sign bit)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
##### shift
`number`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_sign()
> **\_sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int16/comparison.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/comparison.js#L83)
Get sign of value (-1, 0, or 1)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`-1` | `0` | `1`
***
### \_times()
> **\_times**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/arithmetic.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/arithmetic.js#L37)
Multiply two BrandedInt16 values
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### \_toBigint()
> **\_toBigint**(`value`): `bigint`
Defined in: [src/primitives/Int16/conversions.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/conversions.js#L15)
Convert BrandedInt16 to bigint
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`bigint`
***
### \_toBytes()
> **\_toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int16/conversions.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/conversions.js#L35)
Convert BrandedInt16 to bytes (two's complement, big-endian)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
***
### \_toHex()
> **\_toHex**(`value`): `string`
Defined in: [src/primitives/Int16/conversions.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/conversions.js#L24)
Convert BrandedInt16 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`string`
***
### \_toNumber()
> **\_toNumber**(`value`): `number`
Defined in: [src/primitives/Int16/conversions.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/conversions.js#L6)
Convert BrandedInt16 to number
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`number`
***
### \_toString()
> **\_toString**(`value`): `string`
Defined in: [src/primitives/Int16/conversions.js:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/conversions.js#L46)
Convert BrandedInt16 to string
#### Parameters
##### value
[`BrandedInt16`](#brandedint16)
#### Returns
`string`
***
### \_xor()
> **\_xor**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/bitwise.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/bitwise.js#L37)
Bitwise XOR
#### Parameters
##### a
[`BrandedInt16`](#brandedint16)
##### b
[`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### abs()
> **abs**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L106)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### and()
> **and**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L150)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### bitLength()
> **bitLength**(`value`): `number`
Defined in: [src/primitives/Int16/index.ts:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L174)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`number`
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L98)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/index.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L114)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/from.js#L8)
Create a BrandedInt16 from a number, bigint, hex string, or another BrandedInt16
#### Parameters
##### value
`string` | `number` | `bigint` | [`BrandedInt16`](#brandedint16)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### fromBigint()
> **fromBigint**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/from.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/from.js#L44)
Create a BrandedInt16 from a bigint
#### Parameters
##### value
`bigint`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/from.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/from.js#L74)
Create a BrandedInt16 from bytes (two's complement, big-endian)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
2 bytes
#### Returns
[`BrandedInt16`](#brandedint16)
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/from.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/from.js#L58)
Create a BrandedInt16 from a hex string (two's complement)
#### Parameters
##### hex
`string`
"0xFFFF" for -1, "0x8000" for -32768, "0x7FFF" for 32767
#### Returns
[`BrandedInt16`](#brandedint16)
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/from.js#L27)
Create a BrandedInt16 from a number
#### Parameters
##### value
`number`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/index.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L122)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int16/index.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L130)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int16/index.ts:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L134)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int16/utilities.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/utilities.js#L53)
Validate if number is valid Int16
#### Parameters
##### value
`number`
#### Returns
`boolean`
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int16/index.ts:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L126)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### leadingZeros()
> **leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int16/index.ts:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L178)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`number`
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int16/index.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L118)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
`boolean`
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L142)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L138)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L90)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L102)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### negate()
> **negate**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L110)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### not()
> **not**(`value`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L162)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### or()
> **or**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:154](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L154)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L86)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### popCount()
> **popCount**(`value`): `number`
Defined in: [src/primitives/Int16/index.ts:182](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L182)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`number`
***
### shiftLeft()
> **shiftLeft**(`value`, `shift`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L166)
#### Parameters
##### value
[`Int16Input`](#int16input)
##### shift
`number`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### shiftRight()
> **shiftRight**(`value`, `shift`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L170)
#### Parameters
##### value
[`Int16Input`](#int16input)
##### shift
`number`
#### Returns
[`BrandedInt16`](#brandedint16)
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int16/index.ts:146](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L146)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`-1` | `0` | `1`
***
### times()
> **times**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L94)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
***
### toBigint()
> **toBigint**(`value`): `bigint`
Defined in: [src/primitives/Int16/index.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L69)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`bigint`
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`
Defined in: [src/primitives/Int16/index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L77)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`Uint8Array`
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int16/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L73)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`string`
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int16/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L65)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`number`
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int16/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L82)
#### Parameters
##### value
[`Int16Input`](#int16input)
#### Returns
`string`
***
### xor()
> **xor**(`a`, `b`): [`BrandedInt16`](#brandedint16)
Defined in: [src/primitives/Int16/index.ts:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int16/index.ts#L158)
#### Parameters
##### a
[`Int16Input`](#int16input)
##### b
[`Int16Input`](#int16input)
#### Returns
[`BrandedInt16`](#brandedint16)
# primitives/Int256
Source: https://voltaire.tevm.sh/generated-api/primitives/Int256
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int256
# primitives/Int256
## Type Aliases
### BrandedInt256
> **BrandedInt256** = `bigint` & `object`
Defined in: [src/primitives/Int256/Int256Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/Int256Type.ts#L9)
Branded Int256 type (critical for EVM signed operations)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int256"`
#### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
#### Since
0.0.0
## Variables
### BITS
> `const` **BITS**: `number` = `256`
Defined in: [src/primitives/Int256/constants.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L51)
Size in bits
***
### Int256
> `const` **Int256**: `object`
Defined in: [src/primitives/Int256/index.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/index.ts#L98)
#### Type Declaration
##### abs()
> **abs**: (`value`) => [`BrandedInt256`](#brandedint256)
Absolute value of Int256
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
[`BrandedInt256`](#brandedint256)
Absolute value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If value is MIN (abs(MIN) overflows)
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.abs(a); // 42n
```
##### bitLength()
> **bitLength**: (`value`) => `number`
Get bit length of Int256 value
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`number`
Number of bits needed to represent value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(255n);
Int256.bitLength(a); // 8
```
##### BITS
> **BITS**: `number`
Size in bits
##### bitwiseAnd()
> **bitwiseAnd**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Bitwise AND of Int256 values
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
[`BrandedInt256`](#brandedint256)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x07n);
Int256.bitwiseAnd(a, b); // 0x07n
```
##### bitwiseNot()
> **bitwiseNot**: (`value`) => [`BrandedInt256`](#brandedint256)
Bitwise NOT of Int256 value
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
[`BrandedInt256`](#brandedint256)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
Int256.bitwiseNot(a); // -1n
```
##### bitwiseOr()
> **bitwiseOr**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Bitwise OR of Int256 values
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
[`BrandedInt256`](#brandedint256)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x70n);
Int256.bitwiseOr(a, b); // 0x7fn
```
##### bitwiseXor()
> **bitwiseXor**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Bitwise XOR of Int256 values
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
[`BrandedInt256`](#brandedint256)
Result
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x07n);
Int256.bitwiseXor(a, b); // 0x08n
```
##### dividedBy()
> **dividedBy**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Divide Int256 values (EVM SDIV - signed division, truncate toward zero)
EVM SDIV semantics:
* Truncates toward zero (not floor division)
* -10 / 3 = -3 (not -4)
* MIN / -1 overflows (throws error)
* 0 / 0 throws error
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
Dividend
###### b
[`BrandedInt256`](#brandedint256)
Divisor
###### Returns
[`BrandedInt256`](#brandedint256)
Quotient (truncated toward zero)
###### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SDIV specification
###### Since
0.0.0
###### Throws
If divisor is zero or MIN / -1 (overflow)
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SDIV examples
const a = Int256.from(-10n);
const b = Int256.from(3n);
Int256.dividedBy(a, b); // -3n (truncate toward zero, not -4n)
const c = Int256.from(10n);
const d = Int256.from(-3n);
Int256.dividedBy(c, d); // -3n (truncate toward zero)
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check Int256 equality
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
`boolean`
True if equal
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(-42n);
Int256.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`BrandedInt256`](#brandedint256)
Create Int256 from bigint, number, or string
###### Parameters
###### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
###### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-100n);
const b = Int256.from("-255");
const c = Int256.from("0xff");
const d = Int256.from(-42);
```
##### fromBigInt()
> **fromBigInt**: (`value`) => [`BrandedInt256`](#brandedint256)
Create Int256 from bigint
###### Parameters
###### value
`bigint`
BigInt value
###### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromBigInt(-42n);
const b = Int256.fromBigInt(100n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`BrandedInt256`](#brandedint256)
Create Int256 from bytes (two's complement, big-endian)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array (32 bytes)
###### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If bytes length is incorrect
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const bytes = new Uint8Array(16);
bytes[15] = 0xff; // -1
const value = Int256.fromBytes(bytes);
```
##### fromHex()
> **fromHex**: (`hex`) => [`BrandedInt256`](#brandedint256)
Create Int256 from hex string (two's complement)
###### Parameters
###### hex
`string`
Hex string (with or without 0x prefix)
###### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If hex is invalid or out of range
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromHex("0x7fffffffffffffffffffffffffffffff"); // MAX
const b = Int256.fromHex("0x80000000000000000000000000000000"); // MIN
const c = Int256.fromHex("0xffffffffffffffffffffffffffffffff"); // -1
```
##### fromNumber()
> **fromNumber**: (`value`) => [`BrandedInt256`](#brandedint256)
Create Int256 from number
###### Parameters
###### value
`number`
Integer number
###### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If value is not an integer or out of range
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromNumber(-42);
const b = Int256.fromNumber(100);
```
##### greaterThan()
> **greaterThan**: (`a`, `b`) => `boolean`
Check if Int256 is greater than another
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
`boolean`
True if a > b
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
const b = Int256.from(-1n);
Int256.greaterThan(a, b); // true
```
##### isNegative()
> **isNegative**: (`value`) => `boolean`
Check if Int256 is negative
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`boolean`
True if negative
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.isNegative(a); // true
```
##### isPositive()
> **isPositive**: (`value`) => `boolean`
Check if Int256 is positive
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`boolean`
True if positive
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(42n);
Int256.isPositive(a); // true
```
##### isValid()
> **isValid**: (`value`) => `boolean`
Check if value is valid Int256
###### Parameters
###### value
`bigint`
Value to check
###### Returns
`boolean`
True if valid Int256
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
Int256.isValid(-42n); // true
Int256.isValid(2n ** 127n); // false (exceeds MAX)
```
##### isZero()
> **isZero**: (`value`) => `boolean`
Check if Int256 is zero
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`boolean`
True if zero
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
Int256.isZero(a); // true
```
##### leadingZeros()
> **leadingZeros**: (`value`) => `number`
Count leading zeros in Int256 two's complement representation
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`number`
Number of leading zero bits
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(1n);
Int256.leadingZeros(a); // 127
```
##### lessThan()
> **lessThan**: (`a`, `b`) => `boolean`
Check if Int256 is less than another
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
`boolean`
True if a \< b
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
const b = Int256.from(0n);
Int256.lessThan(a, b); // true
```
##### MAX
> **MAX**: `bigint`
Maximum Int256 value: 2^255 - 1
EVM: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
##### maximum()
> **maximum**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Return maximum of two Int256 values
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
[`BrandedInt256`](#brandedint256)
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(10n);
Int256.maximum(a, b); // 10n
```
##### MIN
> **MIN**: `bigint`
Minimum Int256 value: -2^255
EVM: 0x8000000000000000000000000000000000000000000000000000000000000000
##### minimum()
> **minimum**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Return minimum of two Int256 values
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First value
###### b
[`BrandedInt256`](#brandedint256)
Second value
###### Returns
[`BrandedInt256`](#brandedint256)
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(10n);
Int256.minimum(a, b); // -42n
```
##### minus()
> **minus**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Subtract Int256 values with wrapping (EVM SUB with signed interpretation)
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
Minuend
###### b
[`BrandedInt256`](#brandedint256)
Subtrahend
###### Returns
[`BrandedInt256`](#brandedint256)
Difference with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(100n);
const b = Int256.from(50n);
const diff = Int256.minus(a, b); // 50n
```
##### modulo()
> **modulo**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Modulo Int256 values (EVM SMOD - signed modulo, sign follows dividend)
EVM SMOD semantics:
* Sign of result follows dividend (first operand)
* -10 % 3 = -1 (not 2)
* 10 % -3 = 1 (not -2)
* Property: a = (a/b)\*b + (a%b)
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
Dividend
###### b
[`BrandedInt256`](#brandedint256)
Divisor
###### Returns
[`BrandedInt256`](#brandedint256)
Remainder (sign follows dividend)
###### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SMOD specification
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SMOD examples
const a = Int256.from(-10n);
const b = Int256.from(3n);
Int256.modulo(a, b); // -1n (sign follows dividend -10)
const c = Int256.from(10n);
const d = Int256.from(-3n);
Int256.modulo(c, d); // 1n (sign follows dividend 10)
```
##### MODULO
> **MODULO**: `bigint`
Modulo value for wrapping: 2^256
##### NEG\_ONE
> **NEG\_ONE**: `bigint`
Negative one value (-1 in two's complement)
EVM: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
##### negate()
> **negate**: (`value`) => [`BrandedInt256`](#brandedint256)
Negate Int256 value with wrapping
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
[`BrandedInt256`](#brandedint256)
Negated value with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(42n);
Int256.negate(a); // -42n
const min = Int256.from(Int256.MIN);
Int256.negate(min); // MIN (wraps around)
```
##### ONE
> **ONE**: `bigint`
One value
##### plus()
> **plus**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Add Int256 values with wrapping (EVM ADD with signed interpretation)
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First operand
###### b
[`BrandedInt256`](#brandedint256)
Second operand
###### Returns
[`BrandedInt256`](#brandedint256)
Sum with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-100n);
const b = Int256.from(50n);
const sum = Int256.plus(a, b); // -50n
```
##### popCount()
> **popCount**: (`value`) => `number`
Count set bits in Int256 two's complement representation
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`number`
Number of set bits
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
Int256.popCount(a); // 4
```
##### shiftLeft()
> **shiftLeft**: (`value`, `shift`) => [`BrandedInt256`](#brandedint256)
Shift Int256 left with wrapping
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Value to shift
###### shift
Shift amount
`number` | `bigint`
###### Returns
[`BrandedInt256`](#brandedint256)
Shifted value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(1n);
Int256.shiftLeft(a, 8); // 256n
```
##### shiftRight()
> **shiftRight**: (`value`, `shift`) => [`BrandedInt256`](#brandedint256)
Arithmetic right shift of Int256 (EVM SAR - sign-preserving)
EVM SAR semantics:
* Preserves sign bit during shift
* Negative values remain negative
* -256 >> 1 = -128 (not 128)
* Equivalent to division by 2^shift with floor toward negative infinity
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Value to shift
###### shift
Shift amount
`number` | `bigint`
###### Returns
[`BrandedInt256`](#brandedint256)
Shifted value (sign-extended)
###### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SAR specification
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SAR examples
const a = Int256.from(-256n);
Int256.shiftRight(a, 1); // -128n (sign preserved)
const b = Int256.from(-1n);
Int256.shiftRight(b, 8); // -1n (all bits remain 1)
```
##### sign()
> **sign**: (`value`) => `-1` | `0` | `1`
Get sign of Int256 value
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Input value
###### Returns
`-1` | `0` | `1`
-1 for negative, 0 for zero, 1 for positive
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.sign(a); // -1
const b = Int256.from(0n);
Int256.sign(b); // 0
const c = Int256.from(42n);
Int256.sign(c); // 1
```
##### SIZE
> **SIZE**: `number`
Size in bytes
##### times()
> **times**: (`a`, `b`) => [`BrandedInt256`](#brandedint256)
Multiply Int256 values with wrapping (EVM MUL with signed interpretation)
###### Parameters
###### a
[`BrandedInt256`](#brandedint256)
First operand
###### b
[`BrandedInt256`](#brandedint256)
Second operand
###### Returns
[`BrandedInt256`](#brandedint256)
Product with wrapping
###### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(10n);
const b = Int256.from(-5n);
const product = Int256.times(a, b); // -50n
```
##### toBigInt()
> **toBigInt**: (`value`) => `bigint`
Convert Int256 to bigint
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Int256 value
###### Returns
`bigint`
BigInt value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toBigInt(a); // -42n
```
##### toBytes()
> **toBytes**: (`value`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Int256 to bytes (two's complement, big-endian)
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Int256 value
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Byte array (32 bytes)
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
const bytes = Int256.toBytes(a); // [0xff, 0xff, ..., 0xff]
```
##### toHex()
> **toHex**: (`value`) => `string`
Convert Int256 to hex string (two's complement)
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Int256 value
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
Int256.toHex(a); // "0xffffffffffffffffffffffffffffffff"
const b = Int256.from(255n);
Int256.toHex(b); // "0x000000000000000000000000000000ff"
```
##### toNumber()
> **toNumber**: (`value`) => `number`
Convert Int256 to number (warns on overflow)
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Int256 value
###### Returns
`number`
Number value
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or Number.MIN\_SAFE\_INTEGER
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toNumber(a); // -42
```
##### toString()
> **toString**: (`value`) => `string`
Convert Int256 to decimal string
###### Parameters
###### value
[`BrandedInt256`](#brandedint256)
Int256 value
###### Returns
`string`
Decimal string
###### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toString(a); // "-42"
```
##### ZERO
> **ZERO**: `bigint`
Zero value
***
### MAX
> `const` **MAX**: `bigint`
Defined in: [src/primitives/Int256/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L20)
Maximum Int256 value: 2^255 - 1
EVM: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
***
### MIN
> `const` **MIN**: `bigint`
Defined in: [src/primitives/Int256/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L13)
Minimum Int256 value: -2^255
EVM: 0x8000000000000000000000000000000000000000000000000000000000000000
***
### MODULO
> `const` **MODULO**: `bigint`
Defined in: [src/primitives/Int256/constants.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L57)
Modulo value for wrapping: 2^256
***
### NEG\_ONE
> `const` **NEG\_ONE**: `bigint` = `-1n`
Defined in: [src/primitives/Int256/constants.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L39)
Negative one value (-1 in two's complement)
EVM: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
***
### ONE
> `const` **ONE**: `bigint` = `1n`
Defined in: [src/primitives/Int256/constants.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L32)
One value
***
### SIZE
> `const` **SIZE**: `number` = `32`
Defined in: [src/primitives/Int256/constants.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L45)
Size in bytes
***
### ZERO
> `const` **ZERO**: `bigint` = `0n`
Defined in: [src/primitives/Int256/constants.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/constants.js#L26)
Zero value
## Functions
### abs()
> **abs**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/abs.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/abs.js#L18)
Absolute value of Int256
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
[`BrandedInt256`](#brandedint256)
Absolute value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If value is MIN (abs(MIN) overflows)
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.abs(a); // 42n
```
***
### bitLength()
> **bitLength**(`value`): `number`
Defined in: [src/primitives/Int256/bitLength.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/bitLength.js#L17)
Get bit length of Int256 value
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`number`
Number of bits needed to represent value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(255n);
Int256.bitLength(a); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/bitwiseAnd.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/bitwiseAnd.js#L19)
Bitwise AND of Int256 values
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
[`BrandedInt256`](#brandedint256)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x07n);
Int256.bitwiseAnd(a, b); // 0x07n
```
***
### bitwiseNot()
> **bitwiseNot**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/bitwiseNot.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/bitwiseNot.js#L17)
Bitwise NOT of Int256 value
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
[`BrandedInt256`](#brandedint256)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
Int256.bitwiseNot(a); // -1n
```
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/bitwiseOr.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/bitwiseOr.js#L19)
Bitwise OR of Int256 values
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
[`BrandedInt256`](#brandedint256)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x70n);
Int256.bitwiseOr(a, b); // 0x7fn
```
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/bitwiseXor.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/bitwiseXor.js#L19)
Bitwise XOR of Int256 values
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
[`BrandedInt256`](#brandedint256)
Result
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
const b = Int256.from(0x07n);
Int256.bitwiseXor(a, b); // 0x08n
```
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/dividedBy.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/dividedBy.js#L32)
Divide Int256 values (EVM SDIV - signed division, truncate toward zero)
EVM SDIV semantics:
* Truncates toward zero (not floor division)
* -10 / 3 = -3 (not -4)
* MIN / -1 overflows (throws error)
* 0 / 0 throws error
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
Dividend
##### b
[`BrandedInt256`](#brandedint256)
Divisor
#### Returns
[`BrandedInt256`](#brandedint256)
Quotient (truncated toward zero)
#### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SDIV specification
#### Since
0.0.0
#### Throws
If divisor is zero or MIN / -1 (overflow)
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SDIV examples
const a = Int256.from(-10n);
const b = Int256.from(3n);
Int256.dividedBy(a, b); // -3n (truncate toward zero, not -4n)
const c = Int256.from(10n);
const d = Int256.from(-3n);
Int256.dividedBy(c, d); // -3n (truncate toward zero)
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int256/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/equals.js#L17)
Check Int256 equality
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
`boolean`
True if equal
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(-42n);
Int256.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/from.js#L20)
Create Int256 from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-100n);
const b = Int256.from("-255");
const c = Int256.from("0xff");
const d = Int256.from(-42);
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/fromBigInt.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/fromBigInt.js#L18)
Create Int256 from bigint
#### Parameters
##### value
`bigint`
BigInt value
#### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromBigInt(-42n);
const b = Int256.fromBigInt(100n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/fromBytes.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/fromBytes.js#L19)
Create Int256 from bytes (two's complement, big-endian)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array (32 bytes)
#### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If bytes length is incorrect
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const bytes = new Uint8Array(16);
bytes[15] = 0xff; // -1
const value = Int256.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/fromHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/fromHex.js#L19)
Create Int256 from hex string (two's complement)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If hex is invalid or out of range
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromHex("0x7fffffffffffffffffffffffffffffff"); // MAX
const b = Int256.fromHex("0x80000000000000000000000000000000"); // MIN
const c = Int256.fromHex("0xffffffffffffffffffffffffffffffff"); // -1
```
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/fromNumber.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/fromNumber.js#L18)
Create Int256 from number
#### Parameters
##### value
`number`
Integer number
#### Returns
[`BrandedInt256`](#brandedint256)
Int256 value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If value is not an integer or out of range
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.fromNumber(-42);
const b = Int256.fromNumber(100);
```
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int256/greaterThan.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/greaterThan.js#L17)
Check if Int256 is greater than another
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
`boolean`
True if a > b
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
const b = Int256.from(-1n);
Int256.greaterThan(a, b); // true
```
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int256/isNegative.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/isNegative.js#L15)
Check if Int256 is negative
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`boolean`
True if negative
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.isNegative(a); // true
```
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int256/isPositive.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/isPositive.js#L15)
Check if Int256 is positive
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`boolean`
True if positive
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(42n);
Int256.isPositive(a); // true
```
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int256/isValid.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/isValid.js#L17)
Check if value is valid Int256
#### Parameters
##### value
`bigint`
Value to check
#### Returns
`boolean`
True if valid Int256
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
Int256.isValid(-42n); // true
Int256.isValid(2n ** 127n); // false (exceeds MAX)
```
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int256/isZero.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/isZero.js#L15)
Check if Int256 is zero
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`boolean`
True if zero
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0n);
Int256.isZero(a); // true
```
***
### leadingZeros()
> **leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int256/leadingZeros.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/leadingZeros.js#L17)
Count leading zeros in Int256 two's complement representation
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`number`
Number of leading zero bits
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(1n);
Int256.leadingZeros(a); // 127
```
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int256/lessThan.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/lessThan.js#L17)
Check if Int256 is less than another
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
`boolean`
True if a \< b
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
const b = Int256.from(0n);
Int256.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/maximum.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/maximum.js#L17)
Return maximum of two Int256 values
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
[`BrandedInt256`](#brandedint256)
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(10n);
Int256.maximum(a, b); // 10n
```
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/minimum.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/minimum.js#L17)
Return minimum of two Int256 values
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First value
##### b
[`BrandedInt256`](#brandedint256)
Second value
#### Returns
[`BrandedInt256`](#brandedint256)
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
const b = Int256.from(10n);
Int256.minimum(a, b); // -42n
```
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/minus.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/minus.js#L19)
Subtract Int256 values with wrapping (EVM SUB with signed interpretation)
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
Minuend
##### b
[`BrandedInt256`](#brandedint256)
Subtrahend
#### Returns
[`BrandedInt256`](#brandedint256)
Difference with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(100n);
const b = Int256.from(50n);
const diff = Int256.minus(a, b); // 50n
```
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/modulo.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/modulo.js#L30)
Modulo Int256 values (EVM SMOD - signed modulo, sign follows dividend)
EVM SMOD semantics:
* Sign of result follows dividend (first operand)
* -10 % 3 = -1 (not 2)
* 10 % -3 = 1 (not -2)
* Property: a = (a/b)\*b + (a%b)
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
Dividend
##### b
[`BrandedInt256`](#brandedint256)
Divisor
#### Returns
[`BrandedInt256`](#brandedint256)
Remainder (sign follows dividend)
#### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SMOD specification
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SMOD examples
const a = Int256.from(-10n);
const b = Int256.from(3n);
Int256.modulo(a, b); // -1n (sign follows dividend -10)
const c = Int256.from(10n);
const d = Int256.from(-3n);
Int256.modulo(c, d); // 1n (sign follows dividend 10)
```
***
### negate()
> **negate**(`value`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/negate.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/negate.js#L19)
Negate Int256 value with wrapping
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
[`BrandedInt256`](#brandedint256)
Negated value with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(42n);
Int256.negate(a); // -42n
const min = Int256.from(Int256.MIN);
Int256.negate(min); // MIN (wraps around)
```
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/plus.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/plus.js#L19)
Add Int256 values with wrapping (EVM ADD with signed interpretation)
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First operand
##### b
[`BrandedInt256`](#brandedint256)
Second operand
#### Returns
[`BrandedInt256`](#brandedint256)
Sum with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-100n);
const b = Int256.from(50n);
const sum = Int256.plus(a, b); // -50n
```
***
### popCount()
> **popCount**(`value`): `number`
Defined in: [src/primitives/Int256/popCount.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/popCount.js#L17)
Count set bits in Int256 two's complement representation
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`number`
Number of set bits
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(0x0fn);
Int256.popCount(a); // 4
```
***
### shiftLeft()
> **shiftLeft**(`value`, `shift`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/shiftLeft.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/shiftLeft.js#L18)
Shift Int256 left with wrapping
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Value to shift
##### shift
Shift amount
`number` | `bigint`
#### Returns
[`BrandedInt256`](#brandedint256)
Shifted value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(1n);
Int256.shiftLeft(a, 8); // 256n
```
***
### shiftRight()
> **shiftRight**(`value`, `shift`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/shiftRight.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/shiftRight.js#L29)
Arithmetic right shift of Int256 (EVM SAR - sign-preserving)
EVM SAR semantics:
* Preserves sign bit during shift
* Negative values remain negative
* -256 >> 1 = -128 (not 128)
* Equivalent to division by 2^shift with floor toward negative infinity
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Value to shift
##### shift
Shift amount
`number` | `bigint`
#### Returns
[`BrandedInt256`](#brandedint256)
Shifted value (sign-extended)
#### See
* [https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
* [https://eips.ethereum.org/EIPS/eip-145](https://eips.ethereum.org/EIPS/eip-145) for EVM SAR specification
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
// EVM SAR examples
const a = Int256.from(-256n);
Int256.shiftRight(a, 1); // -128n (sign preserved)
const b = Int256.from(-1n);
Int256.shiftRight(b, 8); // -1n (all bits remain 1)
```
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int256/sign.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/sign.js#L19)
Get sign of Int256 value
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Input value
#### Returns
`-1` | `0` | `1`
-1 for negative, 0 for zero, 1 for positive
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.sign(a); // -1
const b = Int256.from(0n);
Int256.sign(b); // 0
const c = Int256.from(42n);
Int256.sign(c); // 1
```
***
### times()
> **times**(`a`, `b`): [`BrandedInt256`](#brandedint256)
Defined in: [src/primitives/Int256/times.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/times.js#L19)
Multiply Int256 values with wrapping (EVM MUL with signed interpretation)
#### Parameters
##### a
[`BrandedInt256`](#brandedint256)
First operand
##### b
[`BrandedInt256`](#brandedint256)
Second operand
#### Returns
[`BrandedInt256`](#brandedint256)
Product with wrapping
#### See
[https://voltaire.tevm.sh/primitives/int256](https://voltaire.tevm.sh/primitives/int256) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(10n);
const b = Int256.from(-5n);
const product = Int256.times(a, b); // -50n
```
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/Int256/toBigInt.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/toBigInt.js#L15)
Convert Int256 to bigint
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Int256 value
#### Returns
`bigint`
BigInt value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toBigInt(a); // -42n
```
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int256/toBytes.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/toBytes.js#L17)
Convert Int256 to bytes (two's complement, big-endian)
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Int256 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Byte array (32 bytes)
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
const bytes = Int256.toBytes(a); // [0xff, 0xff, ..., 0xff]
```
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int256/toHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/toHex.js#L19)
Convert Int256 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Int256 value
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-1n);
Int256.toHex(a); // "0xffffffffffffffffffffffffffffffff"
const b = Int256.from(255n);
Int256.toHex(b); // "0x000000000000000000000000000000ff"
```
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int256/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/toNumber.js#L16)
Convert Int256 to number (warns on overflow)
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Int256 value
#### Returns
`number`
Number value
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER or Number.MIN\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toNumber(a); // -42
```
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int256/toString.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int256/toString.js#L16)
Convert Int256 to decimal string
#### Parameters
##### value
[`BrandedInt256`](#brandedint256)
Int256 value
#### Returns
`string`
Decimal string
#### See
[https://voltaire.tevm.sh/primitives/int128](https://voltaire.tevm.sh/primitives/int128) for Int256 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Int256 from './primitives/Int256/index.js';
const a = Int256.from(-42n);
Int256.toString(a); // "-42"
```
# primitives/Int32
Source: https://voltaire.tevm.sh/generated-api/primitives/Int32
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int32
# primitives/Int32
## Type Aliases
### BrandedInt32
> **BrandedInt32** = `number` & `object`
Defined in: [src/primitives/Int32/Int32Type.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/Int32Type.ts#L25)
A signed 32-bit integer branded type.
Internally a JavaScript number constrained to \[-2147483648, 2147483647].
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int32"`
## Variables
### INT32\_MAX
> `const` **INT32\_MAX**: `2147483647` = `2147483647`
Defined in: [src/primitives/Int32/Int32Type.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/Int32Type.ts#L30)
***
### INT32\_MIN
> `const` **INT32\_MIN**: `-2147483648` = `-2147483648`
Defined in: [src/primitives/Int32/Int32Type.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/Int32Type.ts#L29)
***
### MAX
> `const` **MAX**: `2147483647`
Defined in: [src/primitives/Int32/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L11)
***
### MIN
> `const` **MIN**: `-2147483648`
Defined in: [src/primitives/Int32/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L8)
***
### MINUS\_ONE
> `const` **MINUS\_ONE**: `-1`
Defined in: [src/primitives/Int32/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L20)
***
### ONE
> `const` **ONE**: `1`
Defined in: [src/primitives/Int32/constants.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L17)
***
### SIZE
> `const` **SIZE**: `4` = `4`
Defined in: [src/primitives/Int32/constants.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L23)
***
### ZERO
> `const` **ZERO**: `0`
Defined in: [src/primitives/Int32/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/constants.js#L14)
## Functions
### abs()
> **abs**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/abs.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/abs.js#L8)
Get absolute value of Int32
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
[`BrandedInt32`](#brandedint32)
Absolute value
#### Throws
If value is MIN (abs would overflow)
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/bitwiseAnd.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/bitwiseAnd.js#L8)
Bitwise AND of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### bitwiseNot()
> **bitwiseNot**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/bitwiseNot.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/bitwiseNot.js#L7)
Bitwise NOT of Int32 value
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/bitwiseOr.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/bitwiseOr.js#L8)
Bitwise OR of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/bitwiseXor.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/bitwiseXor.js#L8)
Bitwise XOR of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### clone()
> **clone**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/clone.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/clone.js#L7)
Clone Int32 value
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value to clone
#### Returns
[`BrandedInt32`](#brandedint32)
Cloned value
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/dividedBy.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/dividedBy.js#L9)
Divide two Int32 values (truncates toward zero)
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
Dividend
##### b
[`BrandedInt32`](#brandedint32)
Divisor
#### Returns
[`BrandedInt32`](#brandedint32)
Quotient
#### Throws
If divisor is zero or overflow occurs
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int32/equals.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/equals.js#L8)
Check if two Int32 values are equal
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
`boolean`
True if equal
***
### from()
> **from**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/from.js#L15)
Create Int32 from various input types
#### Parameters
##### value
Value to convert
`string` | `number` | `bigint`
#### Returns
[`BrandedInt32`](#brandedint32)
Int32 value
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Int32 from './primitives/Int32/index.js';
const a = Int32.from(-42);
const b = Int32.from("123");
const c = Int32.from(-2147483648n);
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/fromBigInt.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/fromBigInt.js#L8)
Create Int32 from bigint
#### Parameters
##### value
`bigint`
BigInt to convert
#### Returns
[`BrandedInt32`](#brandedint32)
Int32 value
#### Throws
If value is out of range
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/fromBytes.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/fromBytes.js#L8)
Create Int32 from bytes (big-endian, two's complement)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Bytes to convert (up to 4 bytes)
#### Returns
[`BrandedInt32`](#brandedint32)
Int32 value
#### Throws
If bytes length exceeds 4
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/fromHex.js#L8)
Create Int32 from hex string (two's complement)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`BrandedInt32`](#brandedint32)
Int32 value
#### Throws
If hex is invalid or exceeds 4 bytes
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/fromNumber.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/fromNumber.js#L8)
Create Int32 from number
#### Parameters
##### value
`number`
Number to convert
#### Returns
[`BrandedInt32`](#brandedint32)
Int32 value
#### Throws
If value is out of range or NaN
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int32/greaterThan.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/greaterThan.js#L8)
Check if first Int32 is greater than second
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
`boolean`
True if a > b
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int32/isNegative.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/isNegative.js#L7)
Check if Int32 value is negative
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
`boolean`
True if negative
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int32/isPositive.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/isPositive.js#L7)
Check if Int32 value is positive
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
`boolean`
True if positive
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int32/isValid.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/isValid.js#L7)
Check if value is a valid Int32
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if valid Int32
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int32/isZero.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/isZero.js#L7)
Check if Int32 value is zero
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
`boolean`
True if zero
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int32/lessThan.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/lessThan.js#L8)
Check if first Int32 is less than second
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
`boolean`
True if a \< b
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/maximum.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/maximum.js#L8)
Get maximum of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Maximum value
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/minimum.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/minimum.js#L8)
Get minimum of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Minimum value
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/minus.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/minus.js#L9)
Subtract two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
#### Throws
If result overflows
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/modulo.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/modulo.js#L9)
Compute modulo of two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
Dividend
##### b
[`BrandedInt32`](#brandedint32)
Divisor
#### Returns
[`BrandedInt32`](#brandedint32)
Remainder
#### Throws
If divisor is zero
***
### negate()
> **negate**(`value`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/negate.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/negate.js#L8)
Negate Int32 value
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
[`BrandedInt32`](#brandedint32)
Negated value
#### Throws
If value is MIN (negation would overflow)
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/plus.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/plus.js#L9)
Add two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
#### Throws
If result overflows
***
### shiftLeft()
> **shiftLeft**(`value`, `n`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/shiftLeft.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/shiftLeft.js#L8)
Shift Int32 left by n bits
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value to shift
##### n
`number`
Number of bits to shift (0-31)
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### shiftRight()
> **shiftRight**(`value`, `n`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/shiftRight.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/shiftRight.js#L8)
Arithmetic shift Int32 right by n bits (preserves sign)
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value to shift
##### n
`number`
Number of bits to shift (0-31)
#### Returns
[`BrandedInt32`](#brandedint32)
Result
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int32/sign.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/sign.js#L7)
Get sign of Int32 value
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Value
#### Returns
`-1` | `0` | `1`
-1 if negative, 0 if zero, 1 if positive
***
### times()
> **times**(`a`, `b`): [`BrandedInt32`](#brandedint32)
Defined in: [src/primitives/Int32/times.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/times.js#L9)
Multiply two Int32 values
#### Parameters
##### a
[`BrandedInt32`](#brandedint32)
First value
##### b
[`BrandedInt32`](#brandedint32)
Second value
#### Returns
[`BrandedInt32`](#brandedint32)
Result
#### Throws
If result overflows
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/Int32/toBigInt.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/toBigInt.js#L7)
Convert Int32 to bigint
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Int32 value
#### Returns
`bigint`
BigInt value
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int32/toBytes.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/toBytes.js#L7)
Convert Int32 to bytes (big-endian, two's complement, 4 bytes)
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Int32 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte Uint8Array
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int32/toHex.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/toHex.js#L7)
Convert Int32 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Int32 value
#### Returns
`string`
Hex string with 0x prefix
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int32/toNumber.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/toNumber.js#L7)
Convert Int32 to number
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Int32 value
#### Returns
`number`
Number value
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int32/toString.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int32/toString.js#L8)
Convert Int32 to string
#### Parameters
##### value
[`BrandedInt32`](#brandedint32)
Int32 value
#### Returns
`string`
String representation
# primitives/Int64
Source: https://voltaire.tevm.sh/generated-api/primitives/Int64
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int64
# primitives/Int64
## Type Aliases
### BrandedInt64
> **BrandedInt64** = `bigint` & `object`
Defined in: [src/primitives/Int64/Int64Type.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/Int64Type.ts#L25)
A signed 64-bit integer branded type.
Internally a JavaScript bigint constrained to \[-2^63, 2^63-1].
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int64"`
## Variables
### INT64\_MAX
> `const` **INT64\_MAX**: `9223372036854775807n` = `9223372036854775807n`
Defined in: [src/primitives/Int64/Int64Type.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/Int64Type.ts#L30)
***
### INT64\_MIN
> `const` **INT64\_MIN**: `-9223372036854775808n` = `-9223372036854775808n`
Defined in: [src/primitives/Int64/Int64Type.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/Int64Type.ts#L29)
***
### MAX
> `const` **MAX**: `9223372036854775807n`
Defined in: [src/primitives/Int64/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L11)
***
### MIN
> `const` **MIN**: `-9223372036854775808n`
Defined in: [src/primitives/Int64/constants.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L8)
***
### MINUS\_ONE
> `const` **MINUS\_ONE**: `-1n`
Defined in: [src/primitives/Int64/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L20)
***
### ONE
> `const` **ONE**: `1n`
Defined in: [src/primitives/Int64/constants.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L17)
***
### SIZE
> `const` **SIZE**: `8` = `8`
Defined in: [src/primitives/Int64/constants.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L23)
***
### ZERO
> `const` **ZERO**: `0n`
Defined in: [src/primitives/Int64/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/constants.js#L14)
## Functions
### abs()
> **abs**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/abs.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/abs.js#L8)
Get absolute value of Int64
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
[`BrandedInt64`](#brandedint64)
Absolute value
#### Throws
If value is MIN (abs would overflow)
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/bitwiseAnd.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/bitwiseAnd.js#L8)
Bitwise AND of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### bitwiseNot()
> **bitwiseNot**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/bitwiseNot.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/bitwiseNot.js#L7)
Bitwise NOT of Int64 value
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/bitwiseOr.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/bitwiseOr.js#L8)
Bitwise OR of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/bitwiseXor.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/bitwiseXor.js#L8)
Bitwise XOR of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### clone()
> **clone**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/clone.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/clone.js#L7)
Clone Int64 value
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value to clone
#### Returns
[`BrandedInt64`](#brandedint64)
Cloned value
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/dividedBy.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/dividedBy.js#L9)
Divide two Int64 values (truncates toward zero)
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
Dividend
##### b
[`BrandedInt64`](#brandedint64)
Divisor
#### Returns
[`BrandedInt64`](#brandedint64)
Quotient
#### Throws
If divisor is zero or overflow occurs
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int64/equals.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/equals.js#L8)
Check if two Int64 values are equal
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
`boolean`
True if equal
***
### from()
> **from**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/from.js#L15)
Create Int64 from various input types
#### Parameters
##### value
Value to convert
`string` | `number` | `bigint`
#### Returns
[`BrandedInt64`](#brandedint64)
Int64 value
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Int64 from './primitives/Int64/index.js';
const a = Int64.from(-42n);
const b = Int64.from("123");
const c = Int64.from(42);
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/fromBigInt.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/fromBigInt.js#L8)
Create Int64 from bigint
#### Parameters
##### value
`bigint`
BigInt to convert
#### Returns
[`BrandedInt64`](#brandedint64)
Int64 value
#### Throws
If value is out of range
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/fromBytes.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/fromBytes.js#L8)
Create Int64 from bytes (big-endian, two's complement)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Bytes to convert (up to 8 bytes)
#### Returns
[`BrandedInt64`](#brandedint64)
Int64 value
#### Throws
If bytes length exceeds 8
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/fromHex.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/fromHex.js#L8)
Create Int64 from hex string (two's complement)
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`BrandedInt64`](#brandedint64)
Int64 value
#### Throws
If hex is invalid or exceeds 8 bytes
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/fromNumber.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/fromNumber.js#L8)
Create Int64 from number
#### Parameters
##### value
`number`
Number to convert
#### Returns
[`BrandedInt64`](#brandedint64)
Int64 value
#### Throws
If value is out of range or NaN
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int64/greaterThan.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/greaterThan.js#L8)
Check if first Int64 is greater than second
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
`boolean`
True if a > b
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int64/isNegative.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/isNegative.js#L7)
Check if Int64 value is negative
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
`boolean`
True if negative
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int64/isPositive.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/isPositive.js#L7)
Check if Int64 value is positive
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
`boolean`
True if positive
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int64/isValid.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/isValid.js#L7)
Check if value is a valid Int64
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if valid Int64
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int64/isZero.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/isZero.js#L7)
Check if Int64 value is zero
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
`boolean`
True if zero
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int64/lessThan.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/lessThan.js#L8)
Check if first Int64 is less than second
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
`boolean`
True if a \< b
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/maximum.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/maximum.js#L8)
Get maximum of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Maximum value
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/minimum.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/minimum.js#L8)
Get minimum of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Minimum value
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/minus.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/minus.js#L9)
Subtract two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
#### Throws
If result overflows
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/modulo.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/modulo.js#L9)
Compute modulo of two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
Dividend
##### b
[`BrandedInt64`](#brandedint64)
Divisor
#### Returns
[`BrandedInt64`](#brandedint64)
Remainder
#### Throws
If divisor is zero
***
### negate()
> **negate**(`value`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/negate.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/negate.js#L8)
Negate Int64 value
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
[`BrandedInt64`](#brandedint64)
Negated value
#### Throws
If value is MIN (negation would overflow)
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/plus.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/plus.js#L9)
Add two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
#### Throws
If result overflows
***
### shiftLeft()
> **shiftLeft**(`value`, `n`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/shiftLeft.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/shiftLeft.js#L8)
Shift Int64 left by n bits
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value to shift
##### n
`bigint`
Number of bits to shift
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### shiftRight()
> **shiftRight**(`value`, `n`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/shiftRight.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/shiftRight.js#L8)
Arithmetic shift Int64 right by n bits (preserves sign)
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value to shift
##### n
`bigint`
Number of bits to shift
#### Returns
[`BrandedInt64`](#brandedint64)
Result
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int64/sign.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/sign.js#L7)
Get sign of Int64 value
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Value
#### Returns
`-1` | `0` | `1`
-1 if negative, 0 if zero, 1 if positive
***
### times()
> **times**(`a`, `b`): [`BrandedInt64`](#brandedint64)
Defined in: [src/primitives/Int64/times.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/times.js#L9)
Multiply two Int64 values
#### Parameters
##### a
[`BrandedInt64`](#brandedint64)
First value
##### b
[`BrandedInt64`](#brandedint64)
Second value
#### Returns
[`BrandedInt64`](#brandedint64)
Result
#### Throws
If result overflows
***
### toBigInt()
> **toBigInt**(`value`): `bigint`
Defined in: [src/primitives/Int64/toBigInt.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/toBigInt.js#L7)
Convert Int64 to bigint
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Int64 value
#### Returns
`bigint`
BigInt value
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int64/toBytes.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/toBytes.js#L7)
Convert Int64 to bytes (big-endian, two's complement, 8 bytes)
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Int64 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
8-byte Uint8Array
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int64/toHex.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/toHex.js#L7)
Convert Int64 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Int64 value
#### Returns
`string`
Hex string with 0x prefix
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int64/toNumber.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/toNumber.js#L8)
Convert Int64 to number
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Int64 value
#### Returns
`number`
Number value
#### Throws
If value exceeds safe integer range
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int64/toString.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int64/toString.js#L8)
Convert Int64 to string
#### Parameters
##### value
[`BrandedInt64`](#brandedint64)
Int64 value
#### Returns
`string`
String representation
# primitives/Int8
Source: https://voltaire.tevm.sh/generated-api/primitives/Int8
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Int8
# primitives/Int8
## Type Aliases
### BrandedInt8
> **BrandedInt8** = `number` & `object`
Defined in: [src/primitives/Int8/Int8Type.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/Int8Type.ts#L24)
A signed 8-bit integer branded type.
Internally a JavaScript number constrained to \[-128, 127].
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Int8"`
***
### Int8Input
> **Int8Input** = `number` | `bigint` | `string` | [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L63)
## Variables
### INT8\_MAX
> `const` **INT8\_MAX**: `127` = `127`
Defined in: [src/primitives/Int8/Int8Type.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/Int8Type.ts#L29)
***
### INT8\_MIN
> `const` **INT8\_MIN**: `-128` = `-128`
Defined in: [src/primitives/Int8/Int8Type.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/Int8Type.ts#L28)
## Functions
### \_abs()
> **\_abs**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L86)
Absolute value
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_and()
> **\_and**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L7)
Bitwise AND
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_bitLength()
> **\_bitLength**(`value`): `number`
Defined in: [src/primitives/Int8/utilities.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/utilities.js#L8)
Get bit length (number of bits needed to represent value)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`number`
***
### \_dividedBy()
> **\_dividedBy**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L51)
Divide two BrandedInt8 values (EVM SDIV semantics - truncate toward zero)
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L7)
Check if two BrandedInt8 values are equal
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_greaterThan()
> **\_greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L27)
Check if a > b
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_isNegative()
> **\_isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L45)
Check if value is negative
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_isPositive()
> **\_isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L54)
Check if value is positive (> 0)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_isZero()
> **\_isZero**(`value`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L36)
Check if value is zero
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_leadingZeros()
> **\_leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int8/utilities.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/utilities.js#L20)
Count leading zeros in binary representation
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`number`
***
### \_lessThan()
> **\_lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/comparison.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L17)
Check if a \< b
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
`boolean`
***
### \_maximum()
> **\_maximum**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/comparison.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L74)
Get maximum of two values
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_minimum()
> **\_minimum**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/comparison.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L64)
Get minimum of two values
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_minus()
> **\_minus**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L23)
Subtract two BrandedInt8 values
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_modulo()
> **\_modulo**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L72)
Modulo operation (EVM SMOD semantics - sign follows dividend)
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_negate()
> **\_negate**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L100)
Negate value
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_not()
> **\_not**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L50)
Bitwise NOT
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_or()
> **\_or**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L23)
Bitwise OR
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_plus()
> **\_plus**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L9)
Add two BrandedInt8 values
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_popCount()
> **\_popCount**(`value`): `number`
Defined in: [src/primitives/Int8/utilities.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/utilities.js#L37)
Count set bits (population count)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`number`
***
### \_shiftLeft()
> **\_shiftLeft**(`value`, `shift`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L63)
Left shift
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
##### shift
`number`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_shiftRight()
> **\_shiftRight**(`value`, `shift`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L79)
Arithmetic right shift (preserves sign bit)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
##### shift
`number`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_sign()
> **\_sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int8/comparison.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/comparison.js#L83)
Get sign of value (-1, 0, or 1)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`-1` | `0` | `1`
***
### \_times()
> **\_times**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/arithmetic.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/arithmetic.js#L37)
Multiply two BrandedInt8 values
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### \_toBigint()
> **\_toBigint**(`value`): `bigint`
Defined in: [src/primitives/Int8/conversions.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/conversions.js#L15)
Convert BrandedInt8 to bigint
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`bigint`
***
### \_toBytes()
> **\_toBytes**(`value`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Int8/conversions.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/conversions.js#L35)
Convert BrandedInt8 to bytes (two's complement)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
***
### \_toHex()
> **\_toHex**(`value`): `string`
Defined in: [src/primitives/Int8/conversions.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/conversions.js#L24)
Convert BrandedInt8 to hex string (two's complement)
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`string`
***
### \_toNumber()
> **\_toNumber**(`value`): `number`
Defined in: [src/primitives/Int8/conversions.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/conversions.js#L6)
Convert BrandedInt8 to number
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`number`
***
### \_toString()
> **\_toString**(`value`): `string`
Defined in: [src/primitives/Int8/conversions.js:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/conversions.js#L46)
Convert BrandedInt8 to string
#### Parameters
##### value
[`BrandedInt8`](#brandedint8)
#### Returns
`string`
***
### \_xor()
> **\_xor**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/bitwise.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/bitwise.js#L37)
Bitwise XOR
#### Parameters
##### a
[`BrandedInt8`](#brandedint8)
##### b
[`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### abs()
> **abs**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L106)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### and()
> **and**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:150](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L150)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### bitLength()
> **bitLength**(`value`): `number`
Defined in: [src/primitives/Int8/index.ts:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L174)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`number`
***
### dividedBy()
> **dividedBy**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L98)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/index.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L114)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/from.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/from.js#L8)
Create a BrandedInt8 from a number, bigint, hex string, or another BrandedInt8
#### Parameters
##### value
`string` | `number` | `bigint` | [`BrandedInt8`](#brandedint8)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### fromBigint()
> **fromBigint**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/from.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/from.js#L44)
Create a BrandedInt8 from a bigint
#### Parameters
##### value
`bigint`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### fromBytes()
> **fromBytes**(`bytes`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/from.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/from.js#L74)
Create a BrandedInt8 from bytes (two's complement)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
single byte
#### Returns
[`BrandedInt8`](#brandedint8)
***
### fromHex()
> **fromHex**(`hex`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/from.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/from.js#L58)
Create a BrandedInt8 from a hex string (two's complement)
#### Parameters
##### hex
`string`
"0xFF" for -1, "0x80" for -128, "0x7F" for 127
#### Returns
[`BrandedInt8`](#brandedint8)
***
### fromNumber()
> **fromNumber**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/from.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/from.js#L27)
Create a BrandedInt8 from a number
#### Parameters
##### value
`number`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/index.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L122)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### isNegative()
> **isNegative**(`value`): `boolean`
Defined in: [src/primitives/Int8/index.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L130)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### isPositive()
> **isPositive**(`value`): `boolean`
Defined in: [src/primitives/Int8/index.ts:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L134)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### isValid()
> **isValid**(`value`): `boolean`
Defined in: [src/primitives/Int8/utilities.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/utilities.js#L53)
Validate if number is valid Int8
#### Parameters
##### value
`number`
#### Returns
`boolean`
***
### isZero()
> **isZero**(`value`): `boolean`
Defined in: [src/primitives/Int8/index.ts:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L126)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### leadingZeros()
> **leadingZeros**(`value`): `number`
Defined in: [src/primitives/Int8/index.ts:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L178)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`number`
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Int8/index.ts:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L118)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
`boolean`
***
### maximum()
> **maximum**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L142)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### minimum()
> **minimum**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L138)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### minus()
> **minus**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L90)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### modulo()
> **modulo**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L102)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### negate()
> **negate**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L110)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### not()
> **not**(`value`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L162)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### or()
> **or**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:154](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L154)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### plus()
> **plus**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L86)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### popCount()
> **popCount**(`value`): `number`
Defined in: [src/primitives/Int8/index.ts:182](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L182)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`number`
***
### shiftLeft()
> **shiftLeft**(`value`, `shift`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L166)
#### Parameters
##### value
[`Int8Input`](#int8input)
##### shift
`number`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### shiftRight()
> **shiftRight**(`value`, `shift`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L170)
#### Parameters
##### value
[`Int8Input`](#int8input)
##### shift
`number`
#### Returns
[`BrandedInt8`](#brandedint8)
***
### sign()
> **sign**(`value`): `-1` | `0` | `1`
Defined in: [src/primitives/Int8/index.ts:146](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L146)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`-1` | `0` | `1`
***
### times()
> **times**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L94)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
***
### toBigint()
> **toBigint**(`value`): `bigint`
Defined in: [src/primitives/Int8/index.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L69)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`bigint`
***
### toBytes()
> **toBytes**(`value`): `Uint8Array`
Defined in: [src/primitives/Int8/index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L77)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`Uint8Array`
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/Int8/index.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L73)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`string`
***
### toNumber()
> **toNumber**(`value`): `number`
Defined in: [src/primitives/Int8/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L65)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`number`
***
### toString()
> **toString**(`value`): `string`
Defined in: [src/primitives/Int8/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L82)
#### Parameters
##### value
[`Int8Input`](#int8input)
#### Returns
`string`
***
### xor()
> **xor**(`a`, `b`): [`BrandedInt8`](#brandedint8)
Defined in: [src/primitives/Int8/index.ts:158](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Int8/index.ts#L158)
#### Parameters
##### a
[`Int8Input`](#int8input)
##### b
[`Int8Input`](#int8input)
#### Returns
[`BrandedInt8`](#brandedint8)
# primitives/License
Source: https://voltaire.tevm.sh/generated-api/primitives/License
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/License
# primitives/License
## Type Aliases
### LicenseType
> **LicenseType** = `string` & `object`
Defined in: [src/primitives/License/LicenseType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/LicenseType.ts#L14)
Branded License type - represents SPDX license identifier
Used in smart contract metadata for license identification
Common values: "MIT", "Apache-2.0", "GPL-3.0", "BSD-3-Clause", "UNLICENSED"
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"License"`
#### Example
```typescript theme={null}
const license: LicenseType = "MIT";
```
## Variables
### COMMON\_LICENSES
> `const` **COMMON\_LICENSES**: `string`\[]
Defined in: [src/primitives/License/constants.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/constants.js#L5)
Common SPDX license identifiers
#### See
[https://spdx.org/licenses/](https://spdx.org/licenses/)
***
### License
> `const` **License**: `object`
Defined in: [src/primitives/License/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/index.ts#L33)
#### Type Declaration
##### COMMON\_LICENSES
> **COMMON\_LICENSES**: `string`\[]
Common SPDX license identifiers
###### See
[https://spdx.org/licenses/](https://spdx.org/licenses/)
##### from()
> **from**: (`value`) => [`LicenseType`](#licensetype)
Create License from SPDX identifier string
###### Parameters
###### value
`string`
SPDX license identifier (e.g., "MIT", "Apache-2.0")
###### Returns
[`LicenseType`](#licensetype)
License
###### Example
```typescript theme={null}
const license = License.from("MIT");
const unlicensed = License.from("UNLICENSED");
```
##### isOSI()
> **isOSI**: (`license`) => `boolean`
###### Parameters
###### license
`string`
###### Returns
`boolean`
##### OSI\_APPROVED\_LICENSES
> **OSI\_APPROVED\_LICENSES**: `string`\[]
OSI-approved open source licenses
###### See
[https://opensource.org/licenses](https://opensource.org/licenses)
##### toString()
> **toString**: (`license`) => `string`
###### Parameters
###### license
`string`
###### Returns
`string`
***
### OSI\_APPROVED\_LICENSES
> `const` **OSI\_APPROVED\_LICENSES**: `string`\[]
Defined in: [src/primitives/License/constants.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/constants.js#L22)
OSI-approved open source licenses
#### See
[https://opensource.org/licenses](https://opensource.org/licenses)
## Functions
### \_isOSI()
> **\_isOSI**(`license`): `boolean`
Defined in: [src/primitives/License/isOSI.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/isOSI.js#L18)
Check if license is OSI-approved
#### Parameters
##### license
[`LicenseType`](#licensetype)
License to check
#### Returns
`boolean`
True if OSI-approved
#### Example
```typescript theme={null}
const isOSI = License.isOSI("MIT");
console.log(isOSI); // true
const isOSI2 = License.isOSI("UNLICENSED");
console.log(isOSI2); // false
```
***
### \_toString()
> **\_toString**(`license`): `string`
Defined in: [src/primitives/License/toString.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/toString.js#L14)
Convert License to string
#### Parameters
##### license
[`LicenseType`](#licensetype)
License to convert
#### Returns
`string`
String representation
#### Example
```typescript theme={null}
const str = License.toString(license);
console.log(str); // "MIT"
```
***
### from()
> **from**(`value`): [`LicenseType`](#licensetype)
Defined in: [src/primitives/License/from.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/from.js#L13)
Create License from SPDX identifier string
#### Parameters
##### value
`string`
SPDX license identifier (e.g., "MIT", "Apache-2.0")
#### Returns
[`LicenseType`](#licensetype)
License
#### Example
```typescript theme={null}
const license = License.from("MIT");
const unlicensed = License.from("UNLICENSED");
```
***
### isOSI()
> **isOSI**(`license`): `boolean`
Defined in: [src/primitives/License/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/index.ts#L20)
#### Parameters
##### license
`string`
#### Returns
`boolean`
***
### toString()
> **toString**(`license`): `string`
Defined in: [src/primitives/License/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/License/index.ts#L25)
#### Parameters
##### license
`string`
#### Returns
`string`
# primitives/LogFilter
Source: https://voltaire.tevm.sh/generated-api/primitives/LogFilter
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/LogFilter
# primitives/LogFilter
## Classes
### InvalidLogFilterError
Defined in: [src/primitives/LogFilter/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/errors.js#L4)
Error thrown when LogFilter is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidLogFilterError**(`message`, `details?`): [`InvalidLogFilterError`](#invalidlogfiltererror)
Defined in: [src/primitives/LogFilter/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/errors.js#L9)
###### Parameters
###### message
`string`
###### details?
`object`
###### Returns
[`InvalidLogFilterError`](#invalidlogfiltererror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `object` | `undefined`
Defined in: [src/primitives/LogFilter/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/errors.js#L13)
##### name
> **name**: `string`
Defined in: [src/primitives/LogFilter/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### BlockTag
> **BlockTag** = `"earliest"` | `"latest"` | `"pending"`
Defined in: [src/primitives/LogFilter/LogFilterType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/LogFilterType.ts#L10)
Block identifier for log filter queries
***
### LogFilterType
> **LogFilterType** = `object` & `object`
Defined in: [src/primitives/LogFilter/LogFilterType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/LogFilterType.ts#L36)
Log filter parameters for eth\_getLogs and eth\_newFilter
Filters can specify:
* Block range (fromBlock/toBlock) OR specific block (blockhash)
* Contract address(es) to filter by
* Topic filters for indexed event parameters
#### Type Declaration
##### address?
> `readonly` `optional` **address**: [`AddressType`](Address.mdx#addresstype) | readonly [`AddressType`](Address.mdx#addresstype)\[]
Single address or array of addresses to filter by
##### blockhash?
> `readonly` `optional` **blockhash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Specific block hash (mutually exclusive with fromBlock/toBlock)
##### fromBlock?
> `readonly` `optional` **fromBlock**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype) | [`BlockTag`](#blocktag)
Starting block number or tag
##### toBlock?
> `readonly` `optional` **toBlock**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype) | [`BlockTag`](#blocktag)
Ending block number or tag
##### topics?
> `readonly` `optional` **topics**: [`TopicFilterType`](TopicFilter.mdx#topicfiltertype)
Topic filters (up to 4 indexed parameters)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"LogFilter"`
#### Example
```typescript theme={null}
// Filter Transfer events to specific address
const filter: LogFilter = {
fromBlock: "latest",
address: contractAddr,
topics: [transferEventSig, null, recipientHash]
};
// Filter by specific block hash
const filter2: LogFilter = {
blockhash: blockHash,
address: contractAddr
};
```
## Functions
### from()
> **from**(`params`): [`LogFilterType`](#logfiltertype)
Defined in: [src/primitives/LogFilter/from.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/from.js#L30)
Create LogFilter from parameters
#### Parameters
##### params
`Partial`\<[`LogFilterType`](#logfiltertype)>
Filter parameters
#### Returns
[`LogFilterType`](#logfiltertype)
#### Throws
#### Example
```javascript theme={null}
import * as LogFilter from './primitives/LogFilter/index.js';
import * as Address from './primitives/Address/index.js';
import * as BlockNumber from './primitives/BlockNumber/index.js';
// Filter by address and block range
const filter = LogFilter.from({
fromBlock: BlockNumber.from(1000000),
toBlock: "latest",
address: Address.from("0x...")
});
// Filter by specific block hash
const filter2 = LogFilter.from({
blockhash: Hash.from("0x..."),
address: Address.from("0x...")
});
```
***
### isEmpty()
> **isEmpty**(`filter`): `boolean`
Defined in: [src/primitives/LogFilter/isEmpty.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/isEmpty.js#L14)
Check if log filter is empty (no filtering criteria)
#### Parameters
##### filter
[`LogFilterType`](#logfiltertype)
#### Returns
`boolean`
#### Example
```javascript theme={null}
import * as LogFilter from './primitives/LogFilter/index.js';
const empty = LogFilter.isEmpty(filter); // true if no criteria
```
***
### matches()
> **matches**(`filter`, `log`): `boolean`
Defined in: [src/primitives/LogFilter/matches.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogFilter/matches.js#L16)
Check if a log entry matches this filter
#### Parameters
##### filter
[`LogFilterType`](#logfiltertype)
##### log
[`EventLogType`](EventLog.mdx#eventlogtype)\<[`AddressType`](Address.mdx#addresstype), readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]>
Log entry to test
#### Returns
`boolean`
#### Example
```javascript theme={null}
import * as LogFilter from './primitives/LogFilter/index.js';
const matches = LogFilter.matches(filter, log);
```
# primitives/LogIndex
Source: https://voltaire.tevm.sh/generated-api/primitives/LogIndex
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/LogIndex
# primitives/LogIndex
## Classes
### InvalidLogIndexError
Defined in: [src/primitives/LogIndex/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidLogIndexError**(`message`, `details?`): [`InvalidLogIndexError`](#invalidlogindexerror)
Defined in: [src/primitives/LogIndex/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/errors.js#L8)
###### Parameters
###### message
`string`
###### details?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidLogIndexError`](#invalidlogindexerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/LogIndex/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/LogIndex/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/errors.js#L10)
###### Inherited from
`Error.name`
## Type Aliases
### LogIndexType
> **LogIndexType** = `number` & `object`
Defined in: [src/primitives/LogIndex/LogIndexType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/LogIndexType.ts#L6)
Log index in receipt (0-based)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"LogIndex"`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/LogIndex/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/index.ts#L10)
Check if two LogIndexes are equal
#### Parameters
##### a
[`LogIndexType`](#logindextype)
##### b
[`LogIndexType`](#logindextype)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`LogIndexType`](#logindextype) = `_from`
Defined in: [src/primitives/LogIndex/index.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/index.ts#L8)
Create LogIndex from number
#### Parameters
##### value
`number` | `bigint`
#### Returns
[`LogIndexType`](#logindextype)
#### Throws
***
### toNumber()
> `const` **toNumber**: (`index`) => `number` = `_toNumber`
Defined in: [src/primitives/LogIndex/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/LogIndex/index.ts#L9)
Convert LogIndex to number
#### Parameters
##### index
[`LogIndexType`](#logindextype)
#### Returns
`number`
# primitives/MaxFeePerGas
Source: https://voltaire.tevm.sh/generated-api/primitives/MaxFeePerGas
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/MaxFeePerGas
# primitives/MaxFeePerGas
## Type Aliases
### MaxFeePerGasType
> **MaxFeePerGasType** = `bigint` & `object`
Defined in: [src/primitives/MaxFeePerGas/MaxFeePerGasType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/MaxFeePerGasType.ts#L10)
Branded MaxFeePerGas type - EIP-1559 maximum fee per gas
Represents the maximum total gas price user is willing to pay
Must be >= baseFeePerGas + maxPriorityFeePerGas for inclusion
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"MaxFeePerGas"`
#### See
[https://eips.ethereum.org/EIPS/eip-1559](https://eips.ethereum.org/EIPS/eip-1559)
## Variables
### MaxFeePerGas
> `const` **MaxFeePerGas**: `object`
Defined in: [src/primitives/MaxFeePerGas/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L53)
#### Type Declaration
##### compare()
> **compare**: (`maxFee1`, `maxFee2`) => `number`
###### Parameters
###### maxFee1
`string` | `number` | `bigint`
###### maxFee2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`maxFee1`, `maxFee2`) => `boolean`
###### Parameters
###### maxFee1
`string` | `number` | `bigint`
###### maxFee2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`MaxFeePerGasType`](#maxfeepergastype)
Create MaxFeePerGas from bigint, number, or hex string
###### Parameters
###### value
Max fee in Wei
`string` | `number` | `bigint`
###### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Branded max fee
###### Throws
If value is negative or invalid format
###### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n); // 100 Gwei
const maxFee2 = MaxFeePerGas.from("0x174876e800");
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`MaxFeePerGasType`](#maxfeepergastype)
Create MaxFeePerGas from Gwei value
###### Parameters
###### gwei
Value in Gwei
`number` | `bigint`
###### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Max fee in Wei
###### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.fromGwei(100n); // 100 Gwei = 100000000000 Wei
```
##### fromWei()
> **fromWei**: (`wei`) => [`MaxFeePerGasType`](#maxfeepergastype)
Create MaxFeePerGas from Wei value (alias for from)
###### Parameters
###### wei
Value in Wei
`string` | `number` | `bigint`
###### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Max fee
###### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.fromWei(100000000000n);
```
##### toBigInt()
> **toBigInt**: (`maxFee`) => `bigint`
###### Parameters
###### maxFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGwei()
> **toGwei**: (`maxFee`) => `bigint`
###### Parameters
###### maxFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`maxFee`) => `number`
###### Parameters
###### maxFee
`string` | `number` | `bigint`
###### Returns
`number`
##### toWei()
> **toWei**: (`maxFee`) => `bigint`
###### Parameters
###### maxFee
`string` | `number` | `bigint`
###### Returns
`bigint`
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/MaxFeePerGas/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/compare.js#L15)
Compare two MaxFeePerGas values
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
##### other
[`MaxFeePerGasType`](#maxfeepergastype)
Value to compare
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const fee1 = MaxFeePerGas.from(100000000000n);
const fee2 = MaxFeePerGas.from(120000000000n);
MaxFeePerGas.compare(fee1, fee2); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/MaxFeePerGas/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/equals.js#L15)
Check if two MaxFeePerGas values are equal
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
##### other
[`MaxFeePerGasType`](#maxfeepergastype)
Value to compare
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const fee1 = MaxFeePerGas.from(100000000000n);
const fee2 = MaxFeePerGas.from(100000000000n);
MaxFeePerGas.equals(fee1, fee2); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/toBigInt.js#L13)
Convert MaxFeePerGas to bigint (identity function)
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
#### Returns
`bigint`
Value as bigint
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n);
MaxFeePerGas.toBigInt(maxFee); // 100000000000n
```
***
### \_toGwei()
> **\_toGwei**(`this`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/toGwei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/toGwei.js#L13)
Convert MaxFeePerGas to Gwei
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
#### Returns
`bigint`
Value in Gwei
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n);
MaxFeePerGas.toGwei(maxFee); // 100n Gwei
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/MaxFeePerGas/toNumber.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/toNumber.js#L14)
Convert MaxFeePerGas to number
WARNING: May lose precision for large values
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
#### Returns
`number`
Value as number
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n);
MaxFeePerGas.toNumber(maxFee); // 100000000000
```
***
### \_toWei()
> **\_toWei**(`this`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/toWei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/toWei.js#L13)
Convert MaxFeePerGas to Wei (identity function)
#### Parameters
##### this
[`MaxFeePerGasType`](#maxfeepergastype)
#### Returns
`bigint`
Value in Wei
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n);
MaxFeePerGas.toWei(maxFee); // 100000000000n Wei
```
***
### compare()
> **compare**(`maxFee1`, `maxFee2`): `number`
Defined in: [src/primitives/MaxFeePerGas/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L42)
#### Parameters
##### maxFee1
`string` | `number` | `bigint`
##### maxFee2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`maxFee1`, `maxFee2`): `boolean`
Defined in: [src/primitives/MaxFeePerGas/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L35)
#### Parameters
##### maxFee1
`string` | `number` | `bigint`
##### maxFee2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`MaxFeePerGasType`](#maxfeepergastype)
Defined in: [src/primitives/MaxFeePerGas/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/from.js#L16)
Create MaxFeePerGas from bigint, number, or hex string
#### Parameters
##### value
Max fee in Wei
`string` | `number` | `bigint`
#### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Branded max fee
#### Throws
If value is negative or invalid format
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.from(100000000000n); // 100 Gwei
const maxFee2 = MaxFeePerGas.from("0x174876e800");
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`MaxFeePerGasType`](#maxfeepergastype)
Defined in: [src/primitives/MaxFeePerGas/fromGwei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/fromGwei.js#L12)
Create MaxFeePerGas from Gwei value
#### Parameters
##### gwei
Value in Gwei
`number` | `bigint`
#### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Max fee in Wei
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.fromGwei(100n); // 100 Gwei = 100000000000 Wei
```
***
### fromWei()
> **fromWei**(`wei`): [`MaxFeePerGasType`](#maxfeepergastype)
Defined in: [src/primitives/MaxFeePerGas/fromWei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/fromWei.js#L12)
Create MaxFeePerGas from Wei value (alias for from)
#### Parameters
##### wei
Value in Wei
`string` | `number` | `bigint`
#### Returns
[`MaxFeePerGasType`](#maxfeepergastype)
Max fee
#### Example
```typescript theme={null}
const maxFee = MaxFeePerGas.fromWei(100000000000n);
```
***
### toBigInt()
> **toBigInt**(`maxFee`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L31)
#### Parameters
##### maxFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toGwei()
> **toGwei**(`maxFee`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L19)
#### Parameters
##### maxFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toNumber()
> **toNumber**(`maxFee`): `number`
Defined in: [src/primitives/MaxFeePerGas/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L27)
#### Parameters
##### maxFee
`string` | `number` | `bigint`
#### Returns
`number`
***
### toWei()
> **toWei**(`maxFee`): `bigint`
Defined in: [src/primitives/MaxFeePerGas/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxFeePerGas/index.ts#L23)
#### Parameters
##### maxFee
`string` | `number` | `bigint`
#### Returns
`bigint`
# primitives/MaxPriorityFeePerGas
Source: https://voltaire.tevm.sh/generated-api/primitives/MaxPriorityFeePerGas
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/MaxPriorityFeePerGas
# primitives/MaxPriorityFeePerGas
## Type Aliases
### MaxPriorityFeePerGasType
> **MaxPriorityFeePerGasType** = `bigint` & `object`
Defined in: [src/primitives/MaxPriorityFeePerGas/MaxPriorityFeePerGasType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/MaxPriorityFeePerGasType.ts#L10)
Branded MaxPriorityFeePerGas type - EIP-1559 maximum priority fee (tip)
Represents the maximum tip user is willing to pay to miner/validator
Incentivizes transaction inclusion in blocks
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"MaxPriorityFeePerGas"`
#### See
[https://eips.ethereum.org/EIPS/eip-1559](https://eips.ethereum.org/EIPS/eip-1559)
## Variables
### MaxPriorityFeePerGas
> `const` **MaxPriorityFeePerGas**: `object`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L53)
#### Type Declaration
##### compare()
> **compare**: (`priorityFee1`, `priorityFee2`) => `number`
###### Parameters
###### priorityFee1
`string` | `number` | `bigint`
###### priorityFee2
`string` | `number` | `bigint`
###### Returns
`number`
##### equals()
> **equals**: (`priorityFee1`, `priorityFee2`) => `boolean`
###### Parameters
###### priorityFee1
`string` | `number` | `bigint`
###### priorityFee2
`string` | `number` | `bigint`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Create MaxPriorityFeePerGas from bigint, number, or hex string
###### Parameters
###### value
Priority fee in Wei
`string` | `number` | `bigint`
###### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Branded priority fee
###### Throws
If value is negative or invalid format
###### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n); // 2 Gwei
const priorityFee2 = MaxPriorityFeePerGas.from("0x77359400");
```
##### fromGwei()
> **fromGwei**: (`gwei`) => [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Create MaxPriorityFeePerGas from Gwei value
###### Parameters
###### gwei
Value in Gwei
`number` | `bigint`
###### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Priority fee in Wei
###### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.fromGwei(2n); // 2 Gwei = 2000000000 Wei
```
##### fromWei()
> **fromWei**: (`wei`) => [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Create MaxPriorityFeePerGas from Wei value (alias for from)
###### Parameters
###### wei
Value in Wei
`string` | `number` | `bigint`
###### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Priority fee
###### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.fromWei(2000000000n);
```
##### toBigInt()
> **toBigInt**: (`priorityFee`) => `bigint`
###### Parameters
###### priorityFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toGwei()
> **toGwei**: (`priorityFee`) => `bigint`
###### Parameters
###### priorityFee
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`priorityFee`) => `number`
###### Parameters
###### priorityFee
`string` | `number` | `bigint`
###### Returns
`number`
##### toWei()
> **toWei**: (`priorityFee`) => `bigint`
###### Parameters
###### priorityFee
`string` | `number` | `bigint`
###### Returns
`bigint`
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/MaxPriorityFeePerGas/compare.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/compare.js#L15)
Compare two MaxPriorityFeePerGas values
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
##### other
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Value to compare
#### Returns
`number`
-1 if this \< other, 0 if equal, 1 if this > other
#### Example
```typescript theme={null}
const fee1 = MaxPriorityFeePerGas.from(2000000000n);
const fee2 = MaxPriorityFeePerGas.from(5000000000n);
MaxPriorityFeePerGas.compare(fee1, fee2); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/MaxPriorityFeePerGas/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/equals.js#L15)
Check if two MaxPriorityFeePerGas values are equal
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
##### other
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Value to compare
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const fee1 = MaxPriorityFeePerGas.from(2000000000n);
const fee2 = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.equals(fee1, fee2); // true
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/toBigInt.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/toBigInt.js#L13)
Convert MaxPriorityFeePerGas to bigint (identity function)
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
#### Returns
`bigint`
Value as bigint
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.toBigInt(priorityFee); // 2000000000n
```
***
### \_toGwei()
> **\_toGwei**(`this`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/toGwei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/toGwei.js#L13)
Convert MaxPriorityFeePerGas to Gwei
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
#### Returns
`bigint`
Value in Gwei
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.toGwei(priorityFee); // 2n Gwei
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/MaxPriorityFeePerGas/toNumber.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/toNumber.js#L14)
Convert MaxPriorityFeePerGas to number
WARNING: May lose precision for large values
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
#### Returns
`number`
Value as number
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.toNumber(priorityFee); // 2000000000
```
***
### \_toWei()
> **\_toWei**(`this`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/toWei.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/toWei.js#L13)
Convert MaxPriorityFeePerGas to Wei (identity function)
#### Parameters
##### this
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
#### Returns
`bigint`
Value in Wei
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.toWei(priorityFee); // 2000000000n Wei
```
***
### compare()
> **compare**(`priorityFee1`, `priorityFee2`): `number`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L42)
#### Parameters
##### priorityFee1
`string` | `number` | `bigint`
##### priorityFee2
`string` | `number` | `bigint`
#### Returns
`number`
***
### equals()
> **equals**(`priorityFee1`, `priorityFee2`): `boolean`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L35)
#### Parameters
##### priorityFee1
`string` | `number` | `bigint`
##### priorityFee2
`string` | `number` | `bigint`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Defined in: [src/primitives/MaxPriorityFeePerGas/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/from.js#L16)
Create MaxPriorityFeePerGas from bigint, number, or hex string
#### Parameters
##### value
Priority fee in Wei
`string` | `number` | `bigint`
#### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Branded priority fee
#### Throws
If value is negative or invalid format
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.from(2000000000n); // 2 Gwei
const priorityFee2 = MaxPriorityFeePerGas.from("0x77359400");
```
***
### fromGwei()
> **fromGwei**(`gwei`): [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Defined in: [src/primitives/MaxPriorityFeePerGas/fromGwei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/fromGwei.js#L12)
Create MaxPriorityFeePerGas from Gwei value
#### Parameters
##### gwei
Value in Gwei
`number` | `bigint`
#### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Priority fee in Wei
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.fromGwei(2n); // 2 Gwei = 2000000000 Wei
```
***
### fromWei()
> **fromWei**(`wei`): [`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Defined in: [src/primitives/MaxPriorityFeePerGas/fromWei.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/fromWei.js#L12)
Create MaxPriorityFeePerGas from Wei value (alias for from)
#### Parameters
##### wei
Value in Wei
`string` | `number` | `bigint`
#### Returns
[`MaxPriorityFeePerGasType`](#maxpriorityfeepergastype)
Priority fee
#### Example
```typescript theme={null}
const priorityFee = MaxPriorityFeePerGas.fromWei(2000000000n);
```
***
### toBigInt()
> **toBigInt**(`priorityFee`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L31)
#### Parameters
##### priorityFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toGwei()
> **toGwei**(`priorityFee`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L19)
#### Parameters
##### priorityFee
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toNumber()
> **toNumber**(`priorityFee`): `number`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L27)
#### Parameters
##### priorityFee
`string` | `number` | `bigint`
#### Returns
`number`
***
### toWei()
> **toWei**(`priorityFee`): `bigint`
Defined in: [src/primitives/MaxPriorityFeePerGas/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MaxPriorityFeePerGas/index.ts#L23)
#### Parameters
##### priorityFee
`string` | `number` | `bigint`
#### Returns
`bigint`
# primitives/MemoryDump
Source: https://voltaire.tevm.sh/generated-api/primitives/MemoryDump
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/MemoryDump
# primitives/MemoryDump
## Type Aliases
### MemoryDumpType
> **MemoryDumpType** = `object`
Defined in: [src/primitives/MemoryDump/MemoryDumpType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/MemoryDumpType.ts#L15)
Memory state snapshot from EVM execution
Represents the complete memory state at a point in EVM execution.
EVM memory is byte-addressable and grows dynamically, organized in 32-byte words.
#### Example
```typescript theme={null}
const dump: MemoryDumpType = {
data: new Uint8Array([...]), // Full memory contents
length: 128, // Memory size in bytes
};
```
#### Properties
##### data
> `readonly` **data**: `Uint8Array`
Defined in: [src/primitives/MemoryDump/MemoryDumpType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/MemoryDumpType.ts#L19)
Raw memory bytes - complete memory contents
##### length
> `readonly` **length**: `number`
Defined in: [src/primitives/MemoryDump/MemoryDumpType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/MemoryDumpType.ts#L24)
Total memory size in bytes
## Variables
### MemoryDump
> `const` **MemoryDump**: `object`
Defined in: [src/primitives/MemoryDump/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/index.ts#L30)
#### Type Declaration
##### from()
> **from**: (`value`) => [`MemoryDumpType`](#memorydumptype) = `_from`
Create MemoryDump from raw bytes or object
###### Parameters
###### value
Memory data or object
`Uint8Array`\<`ArrayBufferLike`> | \{ `data`: `Uint8Array`; `length?`: `number`; }
###### Returns
[`MemoryDumpType`](#memorydumptype)
MemoryDump
###### Example
```typescript theme={null}
const dump1 = MemoryDump.from(new Uint8Array(64));
const dump2 = MemoryDump.from({ data: new Uint8Array(64), length: 64 });
```
##### readWord()
> **readWord**: (`dump`, `offset`) => `Uint8Array`
###### Parameters
###### dump
`Uint8Array`\<`ArrayBufferLike`> | [`MemoryDumpType`](#memorydumptype)
###### offset
`number`
###### Returns
`Uint8Array`
##### slice()
> **slice**: (`dump`, `start`, `end?`) => `Uint8Array`
###### Parameters
###### dump
`Uint8Array`\<`ArrayBufferLike`> | [`MemoryDumpType`](#memorydumptype)
###### start
`number`
###### end?
`number`
###### Returns
`Uint8Array`
## Functions
### \_readWord()
> **\_readWord**(`dump`, `offset`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/MemoryDump/readWord.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/readWord.js#L15)
Read a 32-byte word from memory at the given offset
#### Parameters
##### dump
[`MemoryDumpType`](#memorydumptype)
Memory dump
##### offset
`number`
Byte offset to read from
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte word
#### Throws
If offset is out of bounds or insufficient data
#### Example
```typescript theme={null}
const word = MemoryDump.readWord(dump, 0); // First 32 bytes
const word2 = MemoryDump.readWord(dump, 32); // Second 32 bytes
```
***
### \_slice()
> **\_slice**(`dump`, `start`, `end?`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/MemoryDump/slice.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/slice.js#L16)
Extract a slice of memory
#### Parameters
##### dump
[`MemoryDumpType`](#memorydumptype)
Memory dump
##### start
`number`
Start offset (inclusive)
##### end?
`number`
End offset (exclusive, defaults to length)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Memory slice
#### Throws
If offsets are invalid
#### Example
```typescript theme={null}
const slice = MemoryDump.slice(dump, 0, 64); // First 64 bytes
const tail = MemoryDump.slice(dump, 64); // From byte 64 to end
```
***
### from()
> **from**(`value`): [`MemoryDumpType`](#memorydumptype)
Defined in: [src/primitives/MemoryDump/from.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/from.js#L13)
Create MemoryDump from raw bytes or object
#### Parameters
##### value
Memory data or object
`Uint8Array`\<`ArrayBufferLike`> | \{ `data`: `Uint8Array`; `length?`: `number`; }
#### Returns
[`MemoryDumpType`](#memorydumptype)
MemoryDump
#### Example
```typescript theme={null}
const dump1 = MemoryDump.from(new Uint8Array(64));
const dump2 = MemoryDump.from({ data: new Uint8Array(64), length: 64 });
```
***
### readWord()
> **readWord**(`dump`, `offset`): `Uint8Array`
Defined in: [src/primitives/MemoryDump/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/index.ts#L11)
#### Parameters
##### dump
`Uint8Array`\<`ArrayBufferLike`> | [`MemoryDumpType`](#memorydumptype)
##### offset
`number`
#### Returns
`Uint8Array`
***
### slice()
> **slice**(`dump`, `start`, `end?`): `Uint8Array`
Defined in: [src/primitives/MemoryDump/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MemoryDump/index.ts#L18)
#### Parameters
##### dump
`Uint8Array`\<`ArrayBufferLike`> | [`MemoryDumpType`](#memorydumptype)
##### start
`number`
##### end?
`number`
#### Returns
`Uint8Array`
# primitives/Metadata
Source: https://voltaire.tevm.sh/generated-api/primitives/Metadata
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Metadata
# primitives/Metadata
## Type Aliases
### Metadata
> **Metadata** = `object`
Defined in: [src/primitives/Metadata/MetadataType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L7)
Solidity compiler metadata
Encoded in CBOR format at the end of contract bytecode.
Contains compiler version and source verification hashes.
#### Properties
##### bzzr0?
> `readonly` `optional` **bzzr0**: `string`
Defined in: [src/primitives/Metadata/MetadataType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L15)
Swarm hash (legacy)
##### bzzr1?
> `readonly` `optional` **bzzr1**: `string`
Defined in: [src/primitives/Metadata/MetadataType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L17)
Swarm hash v1
##### experimental?
> `readonly` `optional` **experimental**: `boolean`
Defined in: [src/primitives/Metadata/MetadataType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L19)
Experimental features enabled
##### ipfs?
> `readonly` `optional` **ipfs**: `string`
Defined in: [src/primitives/Metadata/MetadataType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L13)
IPFS content hash
##### raw
> `readonly` **raw**: `Uint8Array`
Defined in: [src/primitives/Metadata/MetadataType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L9)
Raw CBOR-encoded bytes
##### solc?
> `readonly` `optional` **solc**: `string`
Defined in: [src/primitives/Metadata/MetadataType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/MetadataType.ts#L11)
Solidity compiler version (e.g., "0.8.19")
## Functions
### decode()
> **decode**(`raw`): [`Metadata`](#metadata)
Defined in: [src/primitives/Metadata/decode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/decode.js#L19)
Decode CBOR-encoded metadata
Parses Solidity metadata format to extract compiler version and content hashes.
#### Parameters
##### raw
`Uint8Array`\<`ArrayBufferLike`>
CBOR-encoded metadata
#### Returns
[`Metadata`](#metadata)
Metadata
#### Example
```javascript theme={null}
import * as Metadata from './primitives/Metadata/index.js';
const raw = new Uint8Array([0xa2, 0x64, ...]);
const meta = Metadata.decode(raw);
console.log(meta.solc); // "0.8.19"
```
***
### encode()
> **encode**(`metadata`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Metadata/encode.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/encode.js#L22)
Encode metadata to CBOR format
Creates CBOR-encoded metadata following Solidity format.
#### Parameters
##### metadata
[`Metadata`](#metadata)
Metadata to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
CBOR-encoded bytes
#### Example
```javascript theme={null}
import * as Metadata from './primitives/Metadata/index.js';
const meta = {
raw: new Uint8Array(),
solc: "0.8.19",
ipfs: "0x1234...",
};
const encoded = Metadata.encode(meta);
```
***
### from()
> **from**(`raw`): [`Metadata`](#metadata)
Defined in: [src/primitives/Metadata/from.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/from.js#L14)
Create Metadata from raw CBOR bytes
#### Parameters
##### raw
`Uint8Array`\<`ArrayBufferLike`>
CBOR-encoded metadata bytes
#### Returns
[`Metadata`](#metadata)
Metadata
#### See
[https://voltaire.tevm.sh/primitives/metadata](https://voltaire.tevm.sh/primitives/metadata) for Metadata documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as Metadata from './primitives/Metadata/index.js';
const meta = Metadata.from(new Uint8Array([0xa2, 0x64, ...]));
```
***
### fromBytecode()
> **fromBytecode**(`bytecode`): [`Metadata`](#metadata) | `null`
Defined in: [src/primitives/Metadata/fromBytecode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Metadata/fromBytecode.js#L17)
Extract metadata from contract bytecode
Solidity appends CBOR metadata at the end: bytecode + metadata + 0x00 + length
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Contract bytecode with metadata
#### Returns
[`Metadata`](#metadata) | `null`
Metadata or null if not found
#### Example
```javascript theme={null}
import * as Metadata from './primitives/Metadata/index.js';
const bytecode = new Uint8Array([...code, 0xa2, 0x64, ...metadata, 0x00, 0x33]);
const meta = Metadata.fromBytecode(bytecode);
```
# primitives/MultiTokenId
Source: https://voltaire.tevm.sh/generated-api/primitives/MultiTokenId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/MultiTokenId
# primitives/MultiTokenId
## Classes
### InvalidMultiTokenIdError
Defined in: [src/primitives/MultiTokenId/errors.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/errors.ts#L23)
Base validation error
#### Example
```typescript theme={null}
throw new ValidationError('Invalid value', {
value: '0x123',
expected: '20 bytes',
code: 'VALIDATION_ERROR',
docsPath: '/primitives/address/from-hex#error-handling',
cause: originalError
})
```
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidMultiTokenIdError**(`message`, `options?`): [`InvalidMultiTokenIdError`](#invalidmultitokeniderror)
Defined in: [src/primitives/MultiTokenId/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/errors.ts#L24)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidMultiTokenIdError`](#invalidmultitokeniderror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### MultiTokenIdError
Defined in: [src/primitives/MultiTokenId/errors.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/errors.ts#L3)
Base error for all primitive-related errors
#### Example
```typescript theme={null}
throw new PrimitiveError('Invalid primitive value', {
code: 'INVALID_PRIMITIVE',
context: { value: '0x123' },
docsPath: '/primitives/overview#errors'
})
```
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new MultiTokenIdError**(`message`, `options?`): [`MultiTokenIdError`](#multitokeniderror)
Defined in: [src/primitives/MultiTokenId/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/errors.ts#L4)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`MultiTokenIdError`](#multitokeniderror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Type Aliases
### MultiTokenIdType
> **MultiTokenIdType** = `bigint` & `object`
Defined in: [src/primitives/MultiTokenId/MultiTokenIdType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/MultiTokenIdType.ts#L10)
MultiTokenId type - ERC-1155 token type identifier
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"MultiTokenId"`
#### See
* [https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
* [https://eips.ethereum.org/EIPS/eip-1155](https://eips.ethereum.org/EIPS/eip-1155) for ERC-1155 specification
#### Since
0.0.0
## Variables
### compare()
> `const` **compare**: (`a`, `b`) => `number` = `_compare`
Defined in: [src/primitives/MultiTokenId/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L32)
Compare two MultiTokenId values
#### Parameters
##### a
[`MultiTokenIdType`](#multitokenidtype)
First MultiTokenId
##### b
[`MultiTokenIdType`](#multitokenidtype)
Second MultiTokenId
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const a = MultiTokenId.from(1n);
const b = MultiTokenId.from(100n);
const result = MultiTokenId.compare(a, b); // -1
```
***
### constants
> `const` **constants**: `object`
Defined in: [src/primitives/MultiTokenId/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L37)
#### Type Declaration
##### FUNGIBLE\_THRESHOLD
> **FUNGIBLE\_THRESHOLD**: `bigint`
Fungible token threshold (by convention)
Token IDs below this are often fungible (like ERC-20)
Token IDs at or above are often non-fungible (like ERC-721)
##### MAX
> **MAX**: `bigint`
Maximum MultiTokenId value (2^256 - 1)
##### MIN
> **MIN**: `bigint`
Minimum MultiTokenId value (0)
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/MultiTokenId/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L31)
Check if two MultiTokenId values are equal
#### Parameters
##### a
[`MultiTokenIdType`](#multitokenidtype)
First MultiTokenId
##### b
[`MultiTokenIdType`](#multitokenidtype)
Second MultiTokenId
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const a = MultiTokenId.from(1n);
const b = MultiTokenId.from(1n);
const result = MultiTokenId.equals(a, b); // true
```
***
### ERC1155\_SELECTORS
> `const` **ERC1155\_SELECTORS**: `object`
Defined in: [src/primitives/MultiTokenId/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L44)
#### Type Declaration
##### balanceOf
> `readonly` **balanceOf**: `"0x00fdd58e"` = `"0x00fdd58e"`
##### balanceOfBatch
> `readonly` **balanceOfBatch**: `"0x4e1273f4"` = `"0x4e1273f4"`
##### isApprovedForAll
> `readonly` **isApprovedForAll**: `"0xe985e9c5"` = `"0xe985e9c5"`
##### safeBatchTransferFrom
> `readonly` **safeBatchTransferFrom**: `"0x2eb2c2d6"` = `"0x2eb2c2d6"`
##### safeTransferFrom
> `readonly` **safeTransferFrom**: `"0xf242432a"` = `"0xf242432a"`
##### setApprovalForAll
> `readonly` **setApprovalForAll**: `"0xa22cb465"` = `"0xa22cb465"`
##### uri
> `readonly` **uri**: `"0x0e89341c"` = `"0x0e89341c"`
***
### from()
> `const` **from**: (`value`) => [`MultiTokenIdType`](#multitokenidtype) = `_from`
Defined in: [src/primitives/MultiTokenId/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L27)
Create MultiTokenId from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n); // Fungible token type
const nftId = MultiTokenId.from(2n ** 128n); // Non-fungible token type
const fromHex = MultiTokenId.from("0xff");
```
***
### isValidFungible()
> `const` **isValidFungible**: (`tokenId`) => `boolean` = `_isValidFungible`
Defined in: [src/primitives/MultiTokenId/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L33)
Check if MultiTokenId is valid for fungible tokens (below threshold)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to check
#### Returns
`boolean`
true if likely fungible (below 2^128)
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const fungible = MultiTokenId.from(1n);
const isFungible = MultiTokenId.isValidFungible(fungible); // true
const nonFungible = MultiTokenId.from(2n ** 128n);
const notFungible = MultiTokenId.isValidFungible(nonFungible); // false
```
***
### isValidNonFungible()
> `const` **isValidNonFungible**: (`tokenId`) => `boolean` = `_isValidNonFungible`
Defined in: [src/primitives/MultiTokenId/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L34)
Check if MultiTokenId is valid for non-fungible tokens (at or above threshold)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to check
#### Returns
`boolean`
true if likely non-fungible (>= 2^128)
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const nonFungible = MultiTokenId.from(2n ** 128n);
const isNFT = MultiTokenId.isValidNonFungible(nonFungible); // true
const fungible = MultiTokenId.from(1n);
const notNFT = MultiTokenId.isValidNonFungible(fungible); // false
```
***
### toBigInt()
> `const` **toBigInt**: (`tokenId`) => `bigint` = `_toBigInt`
Defined in: [src/primitives/MultiTokenId/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L29)
Convert MultiTokenId to bigint
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const bigint = MultiTokenId.toBigInt(tokenId); // 1n
```
***
### toHex()
> `const` **toHex**: (`tokenId`) => `string` = `_toHex`
Defined in: [src/primitives/MultiTokenId/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L30)
Convert MultiTokenId to hex string
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const hex = MultiTokenId.toHex(tokenId); // "0x1"
```
***
### toNumber()
> `const` **toNumber**: (`tokenId`) => `number` = `_toNumber`
Defined in: [src/primitives/MultiTokenId/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/index.ts#L28)
Convert MultiTokenId to number (unsafe for large values)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const num = MultiTokenId.toNumber(tokenId); // 1
```
## Functions
### \_compare()
> **\_compare**(`a`, `b`): `number`
Defined in: [src/primitives/MultiTokenId/compare.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/compare.js#L17)
Compare two MultiTokenId values
#### Parameters
##### a
[`MultiTokenIdType`](#multitokenidtype)
First MultiTokenId
##### b
[`MultiTokenIdType`](#multitokenidtype)
Second MultiTokenId
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const a = MultiTokenId.from(1n);
const b = MultiTokenId.from(100n);
const result = MultiTokenId.compare(a, b); // -1
```
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/MultiTokenId/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/equals.js#L17)
Check if two MultiTokenId values are equal
#### Parameters
##### a
[`MultiTokenIdType`](#multitokenidtype)
First MultiTokenId
##### b
[`MultiTokenIdType`](#multitokenidtype)
Second MultiTokenId
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const a = MultiTokenId.from(1n);
const b = MultiTokenId.from(1n);
const result = MultiTokenId.equals(a, b); // true
```
***
### \_from()
> **\_from**(`value`): [`MultiTokenIdType`](#multitokenidtype)
Defined in: [src/primitives/MultiTokenId/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/from.js#L20)
Create MultiTokenId from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n); // Fungible token type
const nftId = MultiTokenId.from(2n ** 128n); // Non-fungible token type
const fromHex = MultiTokenId.from("0xff");
```
***
### \_isValidFungible()
> **\_isValidFungible**(`tokenId`): `boolean`
Defined in: [src/primitives/MultiTokenId/isValidFungible.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/isValidFungible.js#L19)
Check if MultiTokenId is valid for fungible tokens (below threshold)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to check
#### Returns
`boolean`
true if likely fungible (below 2^128)
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const fungible = MultiTokenId.from(1n);
const isFungible = MultiTokenId.isValidFungible(fungible); // true
const nonFungible = MultiTokenId.from(2n ** 128n);
const notFungible = MultiTokenId.isValidFungible(nonFungible); // false
```
***
### \_isValidNonFungible()
> **\_isValidNonFungible**(`tokenId`): `boolean`
Defined in: [src/primitives/MultiTokenId/isValidNonFungible.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/isValidNonFungible.js#L19)
Check if MultiTokenId is valid for non-fungible tokens (at or above threshold)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to check
#### Returns
`boolean`
true if likely non-fungible (>= 2^128)
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const nonFungible = MultiTokenId.from(2n ** 128n);
const isNFT = MultiTokenId.isValidNonFungible(nonFungible); // true
const fungible = MultiTokenId.from(1n);
const notNFT = MultiTokenId.isValidNonFungible(fungible); // false
```
***
### \_toBigInt()
> **\_toBigInt**(`tokenId`): `bigint`
Defined in: [src/primitives/MultiTokenId/toBigInt.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/toBigInt.js#L15)
Convert MultiTokenId to bigint
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const bigint = MultiTokenId.toBigInt(tokenId); // 1n
```
***
### \_toHex()
> **\_toHex**(`tokenId`): `string`
Defined in: [src/primitives/MultiTokenId/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/toHex.js#L15)
Convert MultiTokenId to hex string
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const hex = MultiTokenId.toHex(tokenId); // "0x1"
```
***
### \_toNumber()
> **\_toNumber**(`tokenId`): `number`
Defined in: [src/primitives/MultiTokenId/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/MultiTokenId/toNumber.js#L16)
Convert MultiTokenId to number (unsafe for large values)
#### Parameters
##### tokenId
[`MultiTokenIdType`](#multitokenidtype)
MultiTokenId value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/multi-token-id](https://voltaire.tevm.sh/primitives/multi-token-id) for MultiTokenId documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as MultiTokenId from './primitives/MultiTokenId/index.js';
const tokenId = MultiTokenId.from(1n);
const num = MultiTokenId.toNumber(tokenId); // 1
```
# primitives/NetworkId
Source: https://voltaire.tevm.sh/generated-api/primitives/NetworkId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/NetworkId
# primitives/NetworkId
## Type Aliases
### NetworkIdType
> **NetworkIdType** = `number` & `object`
Defined in: [src/primitives/NetworkId/NetworkIdType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/NetworkIdType.ts#L16)
Branded NetworkId type - Ethereum network identifier
Wraps a number representing a network ID (different from ChainId)
Network IDs identify different Ethereum networks for peer discovery:
* 1 = Mainnet
* 5 = Goerli (deprecated)
* 11155111 = Sepolia
Note: NetworkId is NOT the same as ChainId (EIP-155).
ChainId is used for replay protection in transactions,
while NetworkId is used for peer-to-peer network identification.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"NetworkId"`
## Variables
### GOERLI
> `const` **GOERLI**: [`NetworkIdType`](#networkidtype)
Defined in: [src/primitives/NetworkId/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/constants.js#L10)
***
### HOLESKY
> `const` **HOLESKY**: [`NetworkIdType`](#networkidtype)
Defined in: [src/primitives/NetworkId/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/constants.js#L18)
***
### MAINNET
> `const` **MAINNET**: [`NetworkIdType`](#networkidtype)
Defined in: [src/primitives/NetworkId/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/constants.js#L6)
***
### NetworkId
> `const` **NetworkId**: `object`
Defined in: [src/primitives/NetworkId/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/index.ts#L28)
#### Type Declaration
##### equals()
> **equals**: (`networkId1`, `networkId2`) => `boolean`
###### Parameters
###### networkId1
`number`
###### networkId2
`number`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`NetworkIdType`](#networkidtype)
Create NetworkId from number
###### Parameters
###### value
`number`
Network ID number
###### Returns
[`NetworkIdType`](#networkidtype)
Branded network ID
###### Throws
If value is not a non-negative integer
###### Example
```javascript theme={null}
import * as NetworkId from './primitives/NetworkId/index.js';
const mainnet = NetworkId.from(1);
const sepolia = NetworkId.from(11155111);
```
##### toNumber()
> **toNumber**: (`networkId`) => `number`
###### Parameters
###### networkId
`number`
###### Returns
`number`
***
### SEPOLIA
> `const` **SEPOLIA**: [`NetworkIdType`](#networkidtype)
Defined in: [src/primitives/NetworkId/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/constants.js#L14)
## Functions
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/NetworkId/equals.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/equals.js#L16)
Compare two NetworkIds for equality
#### Parameters
##### this
[`NetworkIdType`](#networkidtype)
##### other
[`NetworkIdType`](#networkidtype)
Network ID to compare
#### Returns
`boolean`
True if equal
#### Example
```javascript theme={null}
import * as NetworkId from './primitives/NetworkId/index.js';
const a = NetworkId.from(1);
const b = NetworkId.from(1);
const equal = NetworkId._equals.call(a, b); // true
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/NetworkId/toNumber.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/toNumber.js#L14)
Convert NetworkId to number (identity function for branded type)
#### Parameters
##### this
[`NetworkIdType`](#networkidtype)
#### Returns
`number`
Network ID as number
#### Example
```javascript theme={null}
import * as NetworkId from './primitives/NetworkId/index.js';
const netId = NetworkId.from(1);
const num = NetworkId._toNumber.call(netId); // 1
```
***
### equals()
> **equals**(`networkId1`, `networkId2`): `boolean`
Defined in: [src/primitives/NetworkId/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/index.ts#L20)
#### Parameters
##### networkId1
`number`
##### networkId2
`number`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`NetworkIdType`](#networkidtype)
Defined in: [src/primitives/NetworkId/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/from.js#L17)
Create NetworkId from number
#### Parameters
##### value
`number`
Network ID number
#### Returns
[`NetworkIdType`](#networkidtype)
Branded network ID
#### Throws
If value is not a non-negative integer
#### Example
```javascript theme={null}
import * as NetworkId from './primitives/NetworkId/index.js';
const mainnet = NetworkId.from(1);
const sepolia = NetworkId.from(11155111);
```
***
### toNumber()
> **toNumber**(`networkId`): `number`
Defined in: [src/primitives/NetworkId/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NetworkId/index.ts#L16)
#### Parameters
##### networkId
`number`
#### Returns
`number`
# primitives/NodeInfo
Source: https://voltaire.tevm.sh/generated-api/primitives/NodeInfo
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/NodeInfo
# primitives/NodeInfo
## Type Aliases
### NodeInfoType
> **NodeInfoType** = `object`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L17)
Node information structure from admin\_nodeInfo RPC method
Contains metadata about the local Ethereum node including:
* Network identity (enode, ID, IP)
* Protocol information
* Chain state (genesis, head, difficulty)
* Listening ports
#### See
[https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-admin#admin-nodeinfo](https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-admin#admin-nodeinfo)
#### Properties
##### enode
> `readonly` **enode**: [`PeerIdType`](PeerId.mdx#peeridtype)
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L19)
Enode URL of the node
##### id
> `readonly` **id**: `string`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L21)
Node ID (hex-encoded public key)
##### ip
> `readonly` **ip**: `string`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L23)
External IP address
##### listenAddr
> `readonly` **listenAddr**: `string`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L25)
Listen address (IP:PORT)
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L27)
Client identifier (e.g., "Geth/v1.10.26-stable/linux-amd64/go1.19.5")
##### ports
> `readonly` **ports**: `object`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L29)
Network ports
###### discovery
> `readonly` **discovery**: `number`
UDP discovery port
###### listener
> `readonly` **listener**: `number`
TCP listener port
##### protocols
> `readonly` **protocols**: `object`
Defined in: [src/primitives/NodeInfo/NodeInfoType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/NodeInfoType.ts#L36)
Protocol-specific information
###### Index Signature
\[`protocol`: `string`]: `unknown`
Other protocols (snap, les, etc.)
###### eth?
> `readonly` `optional` **eth**: `object`
Ethereum protocol info (if supported)
###### eth.config
> `readonly` **config**: `Record`\<`string`, `unknown`>
Chain configuration
###### eth.difficulty
> `readonly` **difficulty**: [`BrandedUint`](Uint.mdx#brandeduint)
Total difficulty of the chain
###### eth.genesis
> `readonly` **genesis**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Genesis block hash
###### eth.head
> `readonly` **head**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Current head block hash
###### eth.network
> `readonly` **network**: [`NetworkIdType`](NetworkId.mdx#networkidtype)
Network ID
## Variables
### NodeInfo
> `const` **NodeInfo**: `object`
Defined in: [src/primitives/NodeInfo/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/index.ts#L22)
#### Type Declaration
##### from()
> **from**: (`value`) => [`NodeInfoType`](#nodeinfotype)
Create NodeInfo from RPC response object
###### Parameters
###### value
`any`
Node info object from admin\_nodeInfo
###### Returns
[`NodeInfoType`](#nodeinfotype)
Node information
###### Throws
If value is not a valid node info object
###### Example
```javascript theme={null}
import * as NodeInfo from './primitives/NodeInfo/index.js';
const nodeInfo = NodeInfo.from(rpcResponse);
console.log(nodeInfo.name); // "Geth/v1.10.26-stable"
console.log(nodeInfo.protocols.eth?.network); // NetworkId
```
##### getProtocol()
> **getProtocol**: (`nodeInfo`, `protocolName`) => `unknown`
###### Parameters
###### nodeInfo
`any`
###### protocolName
`string`
###### Returns
`unknown`
## Functions
### \_getProtocol()
> **\_getProtocol**(`this`, `protocolName`): `unknown`
Defined in: [src/primitives/NodeInfo/getProtocol.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/getProtocol.js#L16)
Get protocol information by name
#### Parameters
##### this
[`NodeInfoType`](#nodeinfotype)
##### protocolName
`string`
Protocol name (e.g., "eth", "snap")
#### Returns
`unknown`
Protocol information or undefined
#### Example
```javascript theme={null}
import * as NodeInfo from './primitives/NodeInfo/index.js';
const nodeInfo = NodeInfo.from(rpcResponse);
const ethProtocol = NodeInfo._getProtocol.call(nodeInfo, "eth");
console.log(ethProtocol?.network); // NetworkId
```
***
### from()
> **from**(`value`): [`NodeInfoType`](#nodeinfotype)
Defined in: [src/primitives/NodeInfo/from.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/from.js#L23)
Create NodeInfo from RPC response object
#### Parameters
##### value
`any`
Node info object from admin\_nodeInfo
#### Returns
[`NodeInfoType`](#nodeinfotype)
Node information
#### Throws
If value is not a valid node info object
#### Example
```javascript theme={null}
import * as NodeInfo from './primitives/NodeInfo/index.js';
const nodeInfo = NodeInfo.from(rpcResponse);
console.log(nodeInfo.name); // "Geth/v1.10.26-stable"
console.log(nodeInfo.protocols.eth?.network); // NetworkId
```
***
### getProtocol()
> **getProtocol**(`nodeInfo`, `protocolName`): `unknown`
Defined in: [src/primitives/NodeInfo/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/NodeInfo/index.ts#L13)
#### Parameters
##### nodeInfo
`any`
##### protocolName
`string`
#### Returns
`unknown`
# primitives/Nonce
Source: https://voltaire.tevm.sh/generated-api/primitives/Nonce
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Nonce
# primitives/Nonce
## Type Aliases
### NonceType
> **NonceType** = `bigint` & `object`
Defined in: [src/primitives/Nonce/NonceType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/NonceType.ts#L7)
Branded Nonce type - prevents nonce reuse/confusion
Represents a transaction nonce as a branded bigint
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Nonce"`
## Variables
### Nonce
> `const` **Nonce**: (`value`) => [`NonceType`](#noncetype) & `object`
Defined in: [src/primitives/Nonce/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/index.ts#L30)
#### Type Declaration
##### from()
> **from**: (`value`) => [`NonceType`](#noncetype)
Create Nonce from number, bigint, or hex string
###### Parameters
###### value
Value to convert
`string` | `number` | `bigint`
###### Returns
[`NonceType`](#noncetype)
Nonce
###### Example
```typescript theme={null}
const nonce1 = Nonce.from(0);
const nonce2 = Nonce.from(42n);
const nonce3 = Nonce.from("0x2a");
```
##### increment()
> **increment**: (`nonce`) => [`NonceType`](#noncetype)
###### Parameters
###### nonce
`string` | `number` | `bigint`
###### Returns
[`NonceType`](#noncetype)
##### toBigInt()
> **toBigInt**: (`nonce`) => `bigint`
###### Parameters
###### nonce
`string` | `number` | `bigint`
###### Returns
`bigint`
##### toNumber()
> **toNumber**: (`nonce`) => `number`
###### Parameters
###### nonce
`string` | `number` | `bigint`
###### Returns
`number`
## Functions
### \_increment()
> **\_increment**(`this`): [`NonceType`](#noncetype)
Defined in: [src/primitives/Nonce/increment.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/increment.js#L14)
Increment nonce by 1
#### Parameters
##### this
[`NonceType`](#noncetype)
#### Returns
[`NonceType`](#noncetype)
New nonce incremented by 1
#### Example
```typescript theme={null}
const next = Nonce._increment.call(nonce);
```
***
### \_toBigInt()
> **\_toBigInt**(`this`): `bigint`
Defined in: [src/primitives/Nonce/toBigInt.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/toBigInt.js#L14)
Convert Nonce to bigint
#### Parameters
##### this
[`NonceType`](#noncetype)
#### Returns
`bigint`
BigInt
#### Example
```typescript theme={null}
const n = Nonce._toBigInt.call(nonce);
```
***
### \_toNumber()
> **\_toNumber**(`this`): `number`
Defined in: [src/primitives/Nonce/toNumber.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/toNumber.js#L15)
Convert Nonce to number
#### Parameters
##### this
[`NonceType`](#noncetype)
#### Returns
`number`
Number
#### Throws
If nonce exceeds safe integer range
#### Example
```typescript theme={null}
const n = Nonce._toNumber.call(nonce);
```
***
### from()
> **from**(`value`): [`NonceType`](#noncetype)
Defined in: [src/primitives/Nonce/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/from.js#L16)
Create Nonce from number, bigint, or hex string
#### Parameters
##### value
Value to convert
`string` | `number` | `bigint`
#### Returns
[`NonceType`](#noncetype)
Nonce
#### Example
```typescript theme={null}
const nonce1 = Nonce.from(0);
const nonce2 = Nonce.from(42n);
const nonce3 = Nonce.from("0x2a");
```
***
### increment()
> **increment**(`nonce`): [`NonceType`](#noncetype)
Defined in: [src/primitives/Nonce/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/index.ts#L22)
#### Parameters
##### nonce
`string` | `number` | `bigint`
#### Returns
[`NonceType`](#noncetype)
***
### toBigInt()
> **toBigInt**(`nonce`): `bigint`
Defined in: [src/primitives/Nonce/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/index.ts#L18)
#### Parameters
##### nonce
`string` | `number` | `bigint`
#### Returns
`bigint`
***
### toNumber()
> **toNumber**(`nonce`): `number`
Defined in: [src/primitives/Nonce/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Nonce/index.ts#L14)
#### Parameters
##### nonce
`string` | `number` | `bigint`
#### Returns
`number`
# primitives/OpStep
Source: https://voltaire.tevm.sh/generated-api/primitives/OpStep
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/OpStep
# primitives/OpStep
## Type Aliases
### OpStepType
> **OpStepType** = `object`
Defined in: [src/primitives/OpStep/OpStepType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L12)
Single opcode execution step
Represents the EVM state at a specific instruction
#### See
[https://voltaire.tevm.sh/primitives/op-step](https://voltaire.tevm.sh/primitives/op-step) for OpStep documentation
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"OpStep"`
Defined in: [src/primitives/OpStep/OpStepType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L13)
##### depth
> `readonly` **depth**: `number`
Defined in: [src/primitives/OpStep/OpStepType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L23)
Call depth (0 for top-level call)
##### error?
> `readonly` `optional` **error**: `string`
Defined in: [src/primitives/OpStep/OpStepType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L31)
Error message if step failed
##### gas
> `readonly` **gas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/OpStep/OpStepType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L19)
Remaining gas before executing this operation
##### gasCost
> `readonly` **gasCost**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/OpStep/OpStepType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L21)
Gas cost for this operation
##### memory?
> `readonly` `optional` **memory**: `Uint8Array`
Defined in: [src/primitives/OpStep/OpStepType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L27)
Memory state (raw bytes)
##### op
> `readonly` **op**: [`BrandedOpcode`](Opcode.mdx#brandedopcode)
Defined in: [src/primitives/OpStep/OpStepType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L17)
Opcode number (0x00-0xFF)
##### pc
> `readonly` **pc**: `number`
Defined in: [src/primitives/OpStep/OpStepType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L15)
Program counter (bytecode offset)
##### stack?
> `readonly` `optional` **stack**: readonly [`Type`](Uint.mdx#type)\[]
Defined in: [src/primitives/OpStep/OpStepType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L25)
Stack state (top to bottom)
##### storage?
> `readonly` `optional` **storage**: `Record`\<`string`, [`Type`](Uint.mdx#type)>
Defined in: [src/primitives/OpStep/OpStepType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/OpStepType.ts#L29)
Storage changes in this step (key -> value)
## Functions
### \_from()
> **\_from**(`data`): [`OpStepType`](#opsteptype)
Defined in: [src/primitives/OpStep/from.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/from.js#L21)
Creates an OpStep from raw data
#### Parameters
##### data
OpStep data
###### depth
`number`
Call depth
###### error?
`string`
Error message
###### gas
[`Type`](Uint.mdx#type)
Remaining gas
###### gasCost
[`Type`](Uint.mdx#type)
Gas cost
###### memory?
`Uint8Array`\<`ArrayBufferLike`>
Memory state
###### op
[`BrandedOpcode`](Opcode.mdx#brandedopcode)
Opcode
###### pc
`number`
Program counter
###### stack?
readonly [`Type`](Uint.mdx#type)\[]
Stack state
###### storage?
`Record`\<`string`, [`Type`](Uint.mdx#type)>
Storage changes
#### Returns
[`OpStepType`](#opsteptype)
OpStep instance
#### Example
```javascript theme={null}
import { from } from './from.js';
const step = from({ pc: 0, op: 0x60, gas: 1000000n, gasCost: 3n, depth: 0 });
```
***
### \_hasError()
> **\_hasError**(`step`): `boolean`
Defined in: [src/primitives/OpStep/hasError.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/hasError.js#L14)
Checks if an OpStep has an error
#### Parameters
##### step
[`OpStepType`](#opsteptype)
OpStep to check
#### Returns
`boolean`
True if step has an error
#### Example
```javascript theme={null}
import { hasError } from './hasError.js';
if (hasError(step)) {
console.error(`Error at PC ${step.pc}: ${step.error}`);
}
```
***
### from()
> **from**(`data`): [`OpStepType`](#opsteptype)
Defined in: [src/primitives/OpStep/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/index.ts#L22)
Creates an OpStep from raw data
#### Parameters
##### data
`Omit`\<[`OpStepType`](#opsteptype), `brand`>
OpStep data
#### Returns
[`OpStepType`](#opsteptype)
OpStep instance
#### See
[https://voltaire.tevm.sh/primitives/op-step](https://voltaire.tevm.sh/primitives/op-step) for OpStep documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import { OpStep } from './primitives/OpStep/index.js';
const step = OpStep.from({ pc: 0, op: 0x60, gas: 1000000n, gasCost: 3n, depth: 0 });
```
***
### hasError()
> **hasError**(`step`): `boolean`
Defined in: [src/primitives/OpStep/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/OpStep/index.ts#L41)
Checks if an OpStep has an error
#### Parameters
##### step
[`OpStepType`](#opsteptype)
OpStep to check
#### Returns
`boolean`
True if step has an error
#### Example
```typescript theme={null}
import { OpStep } from './primitives/OpStep/index.js';
if (OpStep.hasError(step)) {
console.error(`Error: ${step.error}`);
}
```
# primitives/Opcode
Source: https://voltaire.tevm.sh/generated-api/primitives/Opcode
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Opcode
# primitives/Opcode
## Type Aliases
### BrandedOpcode
> **BrandedOpcode** = `number` & `object`
Defined in: [src/primitives/Opcode/OpcodeType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L6)
Branded type for EVM opcodes (number 0x00-0xFF)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Opcode"`
***
### Info
> **Info** = `object`
Defined in: [src/primitives/Opcode/OpcodeType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L23)
Opcode metadata structure
#### Properties
##### gasCost
> **gasCost**: `number`
Defined in: [src/primitives/Opcode/OpcodeType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L25)
Base gas cost (may be dynamic at runtime)
##### name
> **name**: `string`
Defined in: [src/primitives/Opcode/OpcodeType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L31)
Opcode name
##### stackInputs
> **stackInputs**: `number`
Defined in: [src/primitives/Opcode/OpcodeType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L27)
Number of stack items consumed
##### stackOutputs
> **stackOutputs**: `number`
Defined in: [src/primitives/Opcode/OpcodeType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L29)
Number of stack items produced
***
### Instruction
> **Instruction** = `object`
Defined in: [src/primitives/Opcode/OpcodeType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L11)
Instruction with opcode and optional immediate data
#### Properties
##### immediate?
> `optional` **immediate**: `Uint8Array`
Defined in: [src/primitives/Opcode/OpcodeType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L17)
Immediate data for PUSH operations
##### offset
> **offset**: `number`
Defined in: [src/primitives/Opcode/OpcodeType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L13)
Program counter offset
##### opcode
> **opcode**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/OpcodeType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/OpcodeType.ts#L15)
The opcode
## Variables
### ADD
> `const` **ADD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L10)
***
### ADDMOD
> `const` **ADDMOD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L17)
***
### ADDRESS
> `const` **ADDRESS**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L52)
***
### AND
> `const` **AND**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L37)
***
### AUTH
> `const` **AUTH**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:312](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L312)
***
### AUTHCALL
> `const` **AUTHCALL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:313](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L313)
***
### BALANCE
> `const` **BALANCE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L55)
***
### BASEFEE
> `const` **BASEFEE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L121)
***
### BLOBBASEFEE
> `const` **BLOBBASEFEE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:127](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L127)
***
### BLOBHASH
> `const` **BLOBHASH**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L124)
***
### BLOCKHASH
> `const` **BLOCKHASH**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L97)
***
### BrandedOpcode
> `const` **BrandedOpcode**: `object`
Defined in: [src/primitives/Opcode/Opcode.js:164](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/Opcode.js#L164)
#### Type Declaration
##### ADD
> **ADD**: [`BrandedOpcode`](#brandedopcode)
##### ADDMOD
> **ADDMOD**: [`BrandedOpcode`](#brandedopcode)
##### ADDRESS
> **ADDRESS**: [`BrandedOpcode`](#brandedopcode)
##### AND
> **AND**: [`BrandedOpcode`](#brandedopcode)
##### AUTH
> **AUTH**: [`BrandedOpcode`](#brandedopcode)
##### AUTHCALL
> **AUTHCALL**: [`BrandedOpcode`](#brandedopcode)
##### BALANCE
> **BALANCE**: [`BrandedOpcode`](#brandedopcode)
##### BASEFEE
> **BASEFEE**: [`BrandedOpcode`](#brandedopcode)
##### BLOBBASEFEE
> **BLOBBASEFEE**: [`BrandedOpcode`](#brandedopcode)
##### BLOBHASH
> **BLOBHASH**: [`BrandedOpcode`](#brandedopcode)
##### BLOCKHASH
> **BLOCKHASH**: [`BrandedOpcode`](#brandedopcode)
##### BYTE
> **BYTE**: [`BrandedOpcode`](#brandedopcode)
##### CALL
> **CALL**: [`BrandedOpcode`](#brandedopcode)
##### CALLCODE
> **CALLCODE**: [`BrandedOpcode`](#brandedopcode)
##### CALLDATACOPY
> **CALLDATACOPY**: [`BrandedOpcode`](#brandedopcode)
##### CALLDATALOAD
> **CALLDATALOAD**: [`BrandedOpcode`](#brandedopcode)
##### CALLDATASIZE
> **CALLDATASIZE**: [`BrandedOpcode`](#brandedopcode)
##### CALLER
> **CALLER**: [`BrandedOpcode`](#brandedopcode)
##### CALLVALUE
> **CALLVALUE**: [`BrandedOpcode`](#brandedopcode)
##### CHAINID
> **CHAINID**: [`BrandedOpcode`](#brandedopcode)
##### CODECOPY
> **CODECOPY**: [`BrandedOpcode`](#brandedopcode)
##### CODESIZE
> **CODESIZE**: [`BrandedOpcode`](#brandedopcode)
##### COINBASE
> **COINBASE**: [`BrandedOpcode`](#brandedopcode)
##### CREATE
> **CREATE**: [`BrandedOpcode`](#brandedopcode)
##### CREATE2
> **CREATE2**: [`BrandedOpcode`](#brandedopcode)
##### DELEGATECALL
> **DELEGATECALL**: [`BrandedOpcode`](#brandedopcode)
##### DIFFICULTY
> **DIFFICULTY**: [`BrandedOpcode`](#brandedopcode)
##### disassemble()
> **disassemble**: (`bytecode`) => `string`\[]
Disassemble bytecode to human-readable strings
###### Parameters
###### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
###### Returns
`string`\[]
Array of formatted instruction strings
###### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const asm = Opcode.disassemble(bytecode);
// [
// "0x0000: PUSH1 0x01",
// "0x0002: PUSH1 0x02",
// "0x0004: ADD"
// ]
```
##### DIV
> **DIV**: [`BrandedOpcode`](#brandedopcode)
##### DUP1
> **DUP1**: [`BrandedOpcode`](#brandedopcode)
##### DUP10
> **DUP10**: [`BrandedOpcode`](#brandedopcode)
##### DUP11
> **DUP11**: [`BrandedOpcode`](#brandedopcode)
##### DUP12
> **DUP12**: [`BrandedOpcode`](#brandedopcode)
##### DUP13
> **DUP13**: [`BrandedOpcode`](#brandedopcode)
##### DUP14
> **DUP14**: [`BrandedOpcode`](#brandedopcode)
##### DUP15
> **DUP15**: [`BrandedOpcode`](#brandedopcode)
##### DUP16
> **DUP16**: [`BrandedOpcode`](#brandedopcode)
##### DUP2
> **DUP2**: [`BrandedOpcode`](#brandedopcode)
##### DUP3
> **DUP3**: [`BrandedOpcode`](#brandedopcode)
##### DUP4
> **DUP4**: [`BrandedOpcode`](#brandedopcode)
##### DUP5
> **DUP5**: [`BrandedOpcode`](#brandedopcode)
##### DUP6
> **DUP6**: [`BrandedOpcode`](#brandedopcode)
##### DUP7
> **DUP7**: [`BrandedOpcode`](#brandedopcode)
##### DUP8
> **DUP8**: [`BrandedOpcode`](#brandedopcode)
##### DUP9
> **DUP9**: [`BrandedOpcode`](#brandedopcode)
##### dupPosition()
> **dupPosition**: (`opcode`) => `number` | `undefined`
Get position for DUP instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a DUP
###### Example
```typescript theme={null}
Opcode.dupPosition(Opcode.DUP1); // 1
Opcode.dupPosition(Opcode.DUP16); // 16
Opcode.dupPosition(Opcode.ADD); // undefined
```
##### EQ
> **EQ**: [`BrandedOpcode`](#brandedopcode)
##### EXP
> **EXP**: [`BrandedOpcode`](#brandedopcode)
##### EXTCODECOPY
> **EXTCODECOPY**: [`BrandedOpcode`](#brandedopcode)
##### EXTCODEHASH
> **EXTCODEHASH**: [`BrandedOpcode`](#brandedopcode)
##### EXTCODESIZE
> **EXTCODESIZE**: [`BrandedOpcode`](#brandedopcode)
##### format()
> **format**: (`instruction`) => `string`
Format instruction to human-readable string
###### Parameters
###### instruction
[`Instruction`](#instruction)
Instruction to format
###### Returns
`string`
Human-readable string
###### Example
```typescript theme={null}
const inst = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42])
};
Opcode.format(inst); // "0x0000: PUSH1 0x42"
```
##### GAS
> **GAS**: [`BrandedOpcode`](#brandedopcode)
##### GASLIMIT
> **GASLIMIT**: [`BrandedOpcode`](#brandedopcode)
##### GASPRICE
> **GASPRICE**: [`BrandedOpcode`](#brandedopcode)
##### getCategory()
> **getCategory**: (`opcode`) => `string`
Get opcode category
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`string`
Category name
###### Example
```typescript theme={null}
Opcode.getCategory(Opcode.ADD); // "arithmetic"
Opcode.getCategory(Opcode.SSTORE); // "storage"
Opcode.getCategory(Opcode.CALL); // "system"
```
##### getDescription()
> **getDescription**: (`opcode`) => `string`
Get human-readable description of an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`string`
Description or generated description for PUSH/DUP/SWAP
###### Example
```typescript theme={null}
const desc = Opcode.getDescription(Opcode.ADD);
// "Addition operation"
const desc2 = Opcode.getDescription(Opcode.PUSH1);
// "Place 1-byte item on stack"
```
##### getGasCost()
> **getGasCost**: (`opcode`) => `number` | `undefined`
Get static gas cost for an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Static gas cost or undefined if invalid
###### Example
```typescript theme={null}
const gas = Opcode.getGasCost(Opcode.ADD); // 3
const gas2 = Opcode.getGasCost(Opcode.SSTORE); // 100 (base cost, may be higher at runtime)
```
##### getName()
> **getName**: (`opcode`) => `string`
Get mnemonic name of an opcode (alias for name)
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`string`
Opcode name or "UNKNOWN" if invalid
###### Example
```typescript theme={null}
const name = Opcode.getName(Opcode.ADD); // "ADD"
const name2 = Opcode.getName(0xFF); // "SELFDESTRUCT"
```
##### getPushSize()
> **getPushSize**: (`opcode`) => `number`
Get PUSH data size in bytes
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number`
Push size (0 for PUSH0, 1-32 for PUSH1-PUSH32, 0 for non-PUSH)
###### Example
```typescript theme={null}
Opcode.getPushSize(Opcode.PUSH0); // 0
Opcode.getPushSize(Opcode.PUSH1); // 1
Opcode.getPushSize(Opcode.PUSH32); // 32
Opcode.getPushSize(Opcode.ADD); // 0
```
##### getStackEffect()
> **getStackEffect**: (`opcode`) => \{ `pop`: `number`; `push`: `number`; } | `undefined`
Get stack effect for an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
\{ `pop`: `number`; `push`: `number`; } | `undefined`
Stack items consumed and produced
###### Example
```typescript theme={null}
const effect = Opcode.getStackEffect(Opcode.ADD);
// { pop: 2, push: 1 }
const effect2 = Opcode.getStackEffect(Opcode.DUP1);
// { pop: 1, push: 2 }
```
##### getStackInput()
> **getStackInput**: (`opcode`) => `number` | `undefined`
Get number of stack items consumed by an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Number of stack items consumed
###### Example
```typescript theme={null}
const inputs = Opcode.getStackInput(Opcode.ADD); // 2
const inputs2 = Opcode.getStackInput(Opcode.PUSH1); // 0
```
##### getStackOutput()
> **getStackOutput**: (`opcode`) => `number` | `undefined`
Get number of stack items produced by an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Number of stack items produced
###### Example
```typescript theme={null}
const outputs = Opcode.getStackOutput(Opcode.ADD); // 1
const outputs2 = Opcode.getStackOutput(Opcode.PUSH1); // 1
```
##### GT
> **GT**: [`BrandedOpcode`](#brandedopcode)
##### info()
> **info**: (`opcode`) => [`Info`](#info) | `undefined`
Get metadata for an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
[`Info`](#info) | `undefined`
Metadata with gas cost and stack requirements
###### Example
```typescript theme={null}
const info = Opcode.info(Opcode.ADD);
console.log(info?.name); // "ADD"
console.log(info?.gasCost); // 3
```
##### INVALID
> **INVALID**: [`BrandedOpcode`](#brandedopcode)
##### isDup()
> **isDup**: (`opcode`) => `boolean`
Check if opcode is a DUP instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if DUP1-DUP16
###### Example
```typescript theme={null}
Opcode.isDup(Opcode.DUP1); // true
Opcode.isDup(Opcode.ADD); // false
```
##### isJump()
> **isJump**: (`opcode`) => `boolean`
Check if opcode is a jump
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if JUMP or JUMPI
###### Example
```typescript theme={null}
Opcode.isJump(Opcode.JUMP); // true
Opcode.isJump(Opcode.JUMPI); // true
Opcode.isJump(Opcode.ADD); // false
```
##### isJumpDestination()
> **isJumpDestination**: (`opcode`) => `boolean`
Check if opcode is JUMPDEST
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if JUMPDEST
###### Example
```typescript theme={null}
Opcode.isJumpDestination(Opcode.JUMPDEST); // true
Opcode.isJumpDestination(Opcode.JUMP); // false
```
##### isLog()
> **isLog**: (`opcode`) => `boolean`
Check if opcode is a LOG instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if LOG0-LOG4
###### Example
```typescript theme={null}
Opcode.isLog(Opcode.LOG1); // true
Opcode.isLog(Opcode.ADD); // false
```
##### isPush()
> **isPush**: (`opcode`) => `boolean`
Check if opcode is a PUSH instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if PUSH0-PUSH32
###### Example
```typescript theme={null}
Opcode.isPush(Opcode.PUSH1); // true
Opcode.isPush(Opcode.ADD); // false
```
##### isSwap()
> **isSwap**: (`opcode`) => `boolean`
Check if opcode is a SWAP instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if SWAP1-SWAP16
###### Example
```typescript theme={null}
Opcode.isSwap(Opcode.SWAP1); // true
Opcode.isSwap(Opcode.ADD); // false
```
##### isTerminating()
> **isTerminating**: (`opcode`) => `boolean`
Check if opcode terminates execution
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
###### Example
```typescript theme={null}
Opcode.isTerminating(Opcode.RETURN); // true
Opcode.isTerminating(Opcode.ADD); // false
```
##### isTerminator()
> **isTerminator**: (`opcode`) => `boolean`
Check if opcode terminates execution (alias for isTerminating)
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
###### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
###### Example
```typescript theme={null}
Opcode.isTerminator(Opcode.RETURN); // true
Opcode.isTerminator(Opcode.ADD); // false
```
##### isValid()
> **isValid**: (`opcode`) => `opcode is BrandedOpcode`
Check if opcode is valid
###### Parameters
###### opcode
`number`
Byte value to check
###### Returns
`opcode is BrandedOpcode`
True if opcode is defined in the EVM
###### Example
```typescript theme={null}
Opcode.isValid(0x01); // true (ADD)
Opcode.isValid(0x0c); // false (undefined)
```
##### isValidJumpDest()
> **isValidJumpDest**: (`bytecode`, `offset`) => `boolean`
Check if offset is a valid jump destination
###### Parameters
###### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
###### offset
`number`
Byte offset to check
###### Returns
`boolean`
True if offset is a JUMPDEST and not inside immediate data
###### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01]);
Opcode.isValidJumpDest(bytecode, 0); // true (JUMPDEST)
Opcode.isValidJumpDest(bytecode, 2); // false (immediate data)
```
##### isValidOpcode()
> **isValidOpcode**: (`value`) => `boolean`
Check if value is a valid opcode (alias for isValid)
###### Parameters
###### value
`number`
Value to check
###### Returns
`boolean`
True if valid opcode
###### Example
```typescript theme={null}
Opcode.isValidOpcode(0x01); // true (ADD)
Opcode.isValidOpcode(0xFF); // true (SELFDESTRUCT)
Opcode.isValidOpcode(0x0C); // false
```
##### ISZERO
> **ISZERO**: [`BrandedOpcode`](#brandedopcode)
##### JUMP
> **JUMP**: [`BrandedOpcode`](#brandedopcode)
##### JUMPDEST
> **JUMPDEST**: [`BrandedOpcode`](#brandedopcode)
##### jumpDests()
> **jumpDests**: (`bytecode`) => `Set`\<`number`>
Find all valid JUMPDEST locations
###### Parameters
###### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
###### Returns
`Set`\<`number`>
Set of valid jump destinations (byte offsets)
###### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01, 0x5b]);
const dests = Opcode.jumpDests(bytecode); // Set { 0, 3 }
```
##### JUMPI
> **JUMPI**: [`BrandedOpcode`](#brandedopcode)
##### KECCAK256
> **KECCAK256**: [`BrandedOpcode`](#brandedopcode)
##### LOG0
> **LOG0**: [`BrandedOpcode`](#brandedopcode)
##### LOG1
> **LOG1**: [`BrandedOpcode`](#brandedopcode)
##### LOG2
> **LOG2**: [`BrandedOpcode`](#brandedopcode)
##### LOG3
> **LOG3**: [`BrandedOpcode`](#brandedopcode)
##### LOG4
> **LOG4**: [`BrandedOpcode`](#brandedopcode)
##### logTopics()
> **logTopics**: (`opcode`) => `number` | `undefined`
Get number of topics for LOG instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Number of topics (0-4), or undefined if not a LOG
###### Example
```typescript theme={null}
Opcode.logTopics(Opcode.LOG0); // 0
Opcode.logTopics(Opcode.LOG4); // 4
Opcode.logTopics(Opcode.ADD); // undefined
```
##### LT
> **LT**: [`BrandedOpcode`](#brandedopcode)
##### MCOPY
> **MCOPY**: [`BrandedOpcode`](#brandedopcode)
##### MLOAD
> **MLOAD**: [`BrandedOpcode`](#brandedopcode)
##### MOD
> **MOD**: [`BrandedOpcode`](#brandedopcode)
##### MSIZE
> **MSIZE**: [`BrandedOpcode`](#brandedopcode)
##### MSTORE
> **MSTORE**: [`BrandedOpcode`](#brandedopcode)
##### MSTORE8
> **MSTORE8**: [`BrandedOpcode`](#brandedopcode)
##### MUL
> **MUL**: [`BrandedOpcode`](#brandedopcode)
##### MULMOD
> **MULMOD**: [`BrandedOpcode`](#brandedopcode)
##### name()
> **name**: (`opcode`) => `string`
Get name of an opcode
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`string`
Opcode name or "UNKNOWN" if invalid
###### Example
```typescript theme={null}
const name = Opcode.name(Opcode.ADD); // "ADD"
```
##### NOT
> **NOT**: [`BrandedOpcode`](#brandedopcode)
##### NUMBER
> **NUMBER**: [`BrandedOpcode`](#brandedopcode)
##### OR
> **OR**: [`BrandedOpcode`](#brandedopcode)
##### ORIGIN
> **ORIGIN**: [`BrandedOpcode`](#brandedopcode)
##### parse()
> **parse**: (`bytecode`) => [`Instruction`](#instruction)\[]
Parse bytecode into instructions
###### Parameters
###### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
###### Returns
[`Instruction`](#instruction)\[]
Array of parsed instructions
###### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const instructions = Opcode.parse(bytecode);
// [
// { offset: 0, opcode: PUSH1, immediate: [0x01] },
// { offset: 2, opcode: PUSH1, immediate: [0x02] },
// { offset: 4, opcode: ADD }
// ]
```
##### PC
> **PC**: [`BrandedOpcode`](#brandedopcode)
##### POP
> **POP**: [`BrandedOpcode`](#brandedopcode)
##### PUSH0
> **PUSH0**: [`BrandedOpcode`](#brandedopcode)
##### PUSH1
> **PUSH1**: [`BrandedOpcode`](#brandedopcode)
##### PUSH10
> **PUSH10**: [`BrandedOpcode`](#brandedopcode)
##### PUSH11
> **PUSH11**: [`BrandedOpcode`](#brandedopcode)
##### PUSH12
> **PUSH12**: [`BrandedOpcode`](#brandedopcode)
##### PUSH13
> **PUSH13**: [`BrandedOpcode`](#brandedopcode)
##### PUSH14
> **PUSH14**: [`BrandedOpcode`](#brandedopcode)
##### PUSH15
> **PUSH15**: [`BrandedOpcode`](#brandedopcode)
##### PUSH16
> **PUSH16**: [`BrandedOpcode`](#brandedopcode)
##### PUSH17
> **PUSH17**: [`BrandedOpcode`](#brandedopcode)
##### PUSH18
> **PUSH18**: [`BrandedOpcode`](#brandedopcode)
##### PUSH19
> **PUSH19**: [`BrandedOpcode`](#brandedopcode)
##### PUSH2
> **PUSH2**: [`BrandedOpcode`](#brandedopcode)
##### PUSH20
> **PUSH20**: [`BrandedOpcode`](#brandedopcode)
##### PUSH21
> **PUSH21**: [`BrandedOpcode`](#brandedopcode)
##### PUSH22
> **PUSH22**: [`BrandedOpcode`](#brandedopcode)
##### PUSH23
> **PUSH23**: [`BrandedOpcode`](#brandedopcode)
##### PUSH24
> **PUSH24**: [`BrandedOpcode`](#brandedopcode)
##### PUSH25
> **PUSH25**: [`BrandedOpcode`](#brandedopcode)
##### PUSH26
> **PUSH26**: [`BrandedOpcode`](#brandedopcode)
##### PUSH27
> **PUSH27**: [`BrandedOpcode`](#brandedopcode)
##### PUSH28
> **PUSH28**: [`BrandedOpcode`](#brandedopcode)
##### PUSH29
> **PUSH29**: [`BrandedOpcode`](#brandedopcode)
##### PUSH3
> **PUSH3**: [`BrandedOpcode`](#brandedopcode)
##### PUSH30
> **PUSH30**: [`BrandedOpcode`](#brandedopcode)
##### PUSH31
> **PUSH31**: [`BrandedOpcode`](#brandedopcode)
##### PUSH32
> **PUSH32**: [`BrandedOpcode`](#brandedopcode)
##### PUSH4
> **PUSH4**: [`BrandedOpcode`](#brandedopcode)
##### PUSH5
> **PUSH5**: [`BrandedOpcode`](#brandedopcode)
##### PUSH6
> **PUSH6**: [`BrandedOpcode`](#brandedopcode)
##### PUSH7
> **PUSH7**: [`BrandedOpcode`](#brandedopcode)
##### PUSH8
> **PUSH8**: [`BrandedOpcode`](#brandedopcode)
##### PUSH9
> **PUSH9**: [`BrandedOpcode`](#brandedopcode)
##### pushBytes()
> **pushBytes**: (`opcode`) => `number` | `undefined`
Get number of bytes pushed by PUSH instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Number of bytes (0-32), or undefined if not a PUSH
###### Example
```typescript theme={null}
Opcode.pushBytes(Opcode.PUSH1); // 1
Opcode.pushBytes(Opcode.PUSH32); // 32
Opcode.pushBytes(Opcode.PUSH0); // 0
Opcode.pushBytes(Opcode.ADD); // undefined
```
##### pushOpcode()
> **pushOpcode**: (`bytes`) => [`BrandedOpcode`](#brandedopcode)
Get PUSH opcode for given byte count
###### Parameters
###### bytes
`number`
Number of bytes (0-32)
###### Returns
[`BrandedOpcode`](#brandedopcode)
PUSH opcode for that size
###### Throws
If bytes is not 0-32
###### Example
```typescript theme={null}
Opcode.pushOpcode(1); // Opcode.PUSH1
Opcode.pushOpcode(32); // Opcode.PUSH32
Opcode.pushOpcode(0); // Opcode.PUSH0
```
##### RETURN
> **RETURN**: [`BrandedOpcode`](#brandedopcode)
##### RETURNDATACOPY
> **RETURNDATACOPY**: [`BrandedOpcode`](#brandedopcode)
##### RETURNDATASIZE
> **RETURNDATASIZE**: [`BrandedOpcode`](#brandedopcode)
##### REVERT
> **REVERT**: [`BrandedOpcode`](#brandedopcode)
##### SAR
> **SAR**: [`BrandedOpcode`](#brandedopcode)
##### SDIV
> **SDIV**: [`BrandedOpcode`](#brandedopcode)
##### SELFBALANCE
> **SELFBALANCE**: [`BrandedOpcode`](#brandedopcode)
##### SELFDESTRUCT
> **SELFDESTRUCT**: [`BrandedOpcode`](#brandedopcode)
##### SGT
> **SGT**: [`BrandedOpcode`](#brandedopcode)
##### SHL
> **SHL**: [`BrandedOpcode`](#brandedopcode)
##### SHR
> **SHR**: [`BrandedOpcode`](#brandedopcode)
##### SIGNEXTEND
> **SIGNEXTEND**: [`BrandedOpcode`](#brandedopcode)
##### SLOAD
> **SLOAD**: [`BrandedOpcode`](#brandedopcode)
##### SLT
> **SLT**: [`BrandedOpcode`](#brandedopcode)
##### SMOD
> **SMOD**: [`BrandedOpcode`](#brandedopcode)
##### SSTORE
> **SSTORE**: [`BrandedOpcode`](#brandedopcode)
##### STATICCALL
> **STATICCALL**: [`BrandedOpcode`](#brandedopcode)
##### STOP
> **STOP**: [`BrandedOpcode`](#brandedopcode)
##### SUB
> **SUB**: [`BrandedOpcode`](#brandedopcode)
##### SWAP1
> **SWAP1**: [`BrandedOpcode`](#brandedopcode)
##### SWAP10
> **SWAP10**: [`BrandedOpcode`](#brandedopcode)
##### SWAP11
> **SWAP11**: [`BrandedOpcode`](#brandedopcode)
##### SWAP12
> **SWAP12**: [`BrandedOpcode`](#brandedopcode)
##### SWAP13
> **SWAP13**: [`BrandedOpcode`](#brandedopcode)
##### SWAP14
> **SWAP14**: [`BrandedOpcode`](#brandedopcode)
##### SWAP15
> **SWAP15**: [`BrandedOpcode`](#brandedopcode)
##### SWAP16
> **SWAP16**: [`BrandedOpcode`](#brandedopcode)
##### SWAP2
> **SWAP2**: [`BrandedOpcode`](#brandedopcode)
##### SWAP3
> **SWAP3**: [`BrandedOpcode`](#brandedopcode)
##### SWAP4
> **SWAP4**: [`BrandedOpcode`](#brandedopcode)
##### SWAP5
> **SWAP5**: [`BrandedOpcode`](#brandedopcode)
##### SWAP6
> **SWAP6**: [`BrandedOpcode`](#brandedopcode)
##### SWAP7
> **SWAP7**: [`BrandedOpcode`](#brandedopcode)
##### SWAP8
> **SWAP8**: [`BrandedOpcode`](#brandedopcode)
##### SWAP9
> **SWAP9**: [`BrandedOpcode`](#brandedopcode)
##### swapPosition()
> **swapPosition**: (`opcode`) => `number` | `undefined`
Get position for SWAP instruction
###### Parameters
###### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
###### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a SWAP
###### Example
```typescript theme={null}
Opcode.swapPosition(Opcode.SWAP1); // 1
Opcode.swapPosition(Opcode.SWAP16); // 16
Opcode.swapPosition(Opcode.ADD); // undefined
```
##### TIMESTAMP
> **TIMESTAMP**: [`BrandedOpcode`](#brandedopcode)
##### TLOAD
> **TLOAD**: [`BrandedOpcode`](#brandedopcode)
##### TSTORE
> **TSTORE**: [`BrandedOpcode`](#brandedopcode)
##### XOR
> **XOR**: [`BrandedOpcode`](#brandedopcode)
***
### BYTE
> `const` **BYTE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L41)
***
### CALL
> `const` **CALL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:300](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L300)
***
### CALLCODE
> `const` **CALLCODE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:301](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L301)
***
### CALLDATACOPY
> `const` **CALLDATACOPY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L71)
***
### CALLDATALOAD
> `const` **CALLDATALOAD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L67)
***
### CALLDATASIZE
> `const` **CALLDATASIZE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L69)
***
### CALLER
> `const` **CALLER**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L61)
***
### CALLVALUE
> `const` **CALLVALUE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L64)
***
### CHAINID
> `const` **CHAINID**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L115)
***
### CODECOPY
> `const` **CODECOPY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L76)
***
### CODESIZE
> `const` **CODESIZE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L73)
***
### COINBASE
> `const` **COINBASE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L100)
***
### CREATE
> `const` **CREATE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:297](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L297)
***
### CREATE2
> `const` **CREATE2**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:309](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L309)
***
### DELEGATECALL
> `const` **DELEGATECALL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:307](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L307)
***
### DIFFICULTY
> `const` **DIFFICULTY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L109)
***
### DIV
> `const` **DIV**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L13)
***
### DUP1
> `const` **DUP1**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:240](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L240)
***
### DUP10
> `const` **DUP10**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:249](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L249)
***
### DUP11
> `const` **DUP11**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:250](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L250)
***
### DUP12
> `const` **DUP12**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:251](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L251)
***
### DUP13
> `const` **DUP13**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:252](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L252)
***
### DUP14
> `const` **DUP14**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L253)
***
### DUP15
> `const` **DUP15**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:254](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L254)
***
### DUP16
> `const` **DUP16**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:255](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L255)
***
### DUP2
> `const` **DUP2**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:241](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L241)
***
### DUP3
> `const` **DUP3**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:242](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L242)
***
### DUP4
> `const` **DUP4**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:243](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L243)
***
### DUP5
> `const` **DUP5**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:244](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L244)
***
### DUP6
> `const` **DUP6**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:245](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L245)
***
### DUP7
> `const` **DUP7**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:246](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L246)
***
### DUP8
> `const` **DUP8**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:247](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L247)
***
### DUP9
> `const` **DUP9**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:248](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L248)
***
### EQ
> `const` **EQ**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L33)
***
### EXP
> `const` **EXP**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L23)
***
### EXTCODECOPY
> `const` **EXTCODECOPY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L85)
***
### EXTCODEHASH
> `const` **EXTCODEHASH**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L92)
***
### EXTCODESIZE
> `const` **EXTCODESIZE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L82)
***
### GAS
> `const` **GAS**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L148)
***
### GASLIMIT
> `const` **GASLIMIT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L112)
***
### GASPRICE
> `const` **GASPRICE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L79)
***
### GT
> `const` **GT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L30)
***
### INVALID
> `const` **INVALID**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:322](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L322)
***
### ISZERO
> `const` **ISZERO**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L34)
***
### JUMP
> `const` **JUMP**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:144](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L144)
***
### JUMPDEST
> `const` **JUMPDEST**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:149](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L149)
***
### JUMPI
> `const` **JUMPI**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:145](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L145)
***
### KECCAK256
> `const` **KECCAK256**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L47)
***
### LOG0
> `const` **LOG0**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:290](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L290)
***
### LOG1
> `const` **LOG1**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:291](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L291)
***
### LOG2
> `const` **LOG2**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:292](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L292)
***
### LOG3
> `const` **LOG3**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:293](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L293)
***
### LOG4
> `const` **LOG4**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:294](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L294)
***
### LT
> `const` **LT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L29)
***
### MCOPY
> `const` **MCOPY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L156)
***
### MLOAD
> `const` **MLOAD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L133)
***
### MOD
> `const` **MOD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L15)
***
### MSIZE
> `const` **MSIZE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:147](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L147)
***
### MSTORE
> `const` **MSTORE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L134)
***
### MSTORE8
> `const` **MSTORE8**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:137](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L137)
***
### MUL
> `const` **MUL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L11)
***
### MULMOD
> `const` **MULMOD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L20)
***
### NOT
> `const` **NOT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L40)
***
### NUMBER
> `const` **NUMBER**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L106)
***
### OR
> `const` **OR**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L38)
***
### ORIGIN
> `const` **ORIGIN**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L58)
***
### PC
> `const` **PC**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:146](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L146)
***
### POP
> `const` **POP**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:132](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L132)
***
### PUSH0
> `const` **PUSH0**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:157](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L157)
***
### PUSH1
> `const` **PUSH1**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:160](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L160)
***
### PUSH10
> `const` **PUSH10**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:169](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L169)
***
### PUSH11
> `const` **PUSH11**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L172)
***
### PUSH12
> `const` **PUSH12**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:175](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L175)
***
### PUSH13
> `const` **PUSH13**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L178)
***
### PUSH14
> `const` **PUSH14**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:181](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L181)
***
### PUSH15
> `const` **PUSH15**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:184](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L184)
***
### PUSH16
> `const` **PUSH16**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:187](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L187)
***
### PUSH17
> `const` **PUSH17**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:190](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L190)
***
### PUSH18
> `const` **PUSH18**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:193](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L193)
***
### PUSH19
> `const` **PUSH19**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:196](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L196)
***
### PUSH2
> `const` **PUSH2**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:161](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L161)
***
### PUSH20
> `const` **PUSH20**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:199](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L199)
***
### PUSH21
> `const` **PUSH21**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:202](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L202)
***
### PUSH22
> `const` **PUSH22**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:205](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L205)
***
### PUSH23
> `const` **PUSH23**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:208](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L208)
***
### PUSH24
> `const` **PUSH24**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:211](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L211)
***
### PUSH25
> `const` **PUSH25**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:214](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L214)
***
### PUSH26
> `const` **PUSH26**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:217](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L217)
***
### PUSH27
> `const` **PUSH27**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:220](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L220)
***
### PUSH28
> `const` **PUSH28**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:223](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L223)
***
### PUSH29
> `const` **PUSH29**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:226](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L226)
***
### PUSH3
> `const` **PUSH3**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L162)
***
### PUSH30
> `const` **PUSH30**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:229](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L229)
***
### PUSH31
> `const` **PUSH31**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:232](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L232)
***
### PUSH32
> `const` **PUSH32**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:235](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L235)
***
### PUSH4
> `const` **PUSH4**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:163](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L163)
***
### PUSH5
> `const` **PUSH5**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:164](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L164)
***
### PUSH6
> `const` **PUSH6**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:165](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L165)
***
### PUSH7
> `const` **PUSH7**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:166](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L166)
***
### PUSH8
> `const` **PUSH8**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:167](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L167)
***
### PUSH9
> `const` **PUSH9**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:168](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L168)
***
### RETURN
> `const` **RETURN**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:304](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L304)
***
### RETURNDATACOPY
> `const` **RETURNDATACOPY**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L90)
***
### RETURNDATASIZE
> `const` **RETURNDATASIZE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L88)
***
### REVERT
> `const` **REVERT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:319](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L319)
***
### SAR
> `const` **SAR**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L44)
***
### SDIV
> `const` **SDIV**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L14)
***
### SELFBALANCE
> `const` **SELFBALANCE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:118](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L118)
***
### SELFDESTRUCT
> `const` **SELFDESTRUCT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:325](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L325)
***
### SGT
> `const` **SGT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L32)
***
### SHL
> `const` **SHL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L42)
***
### SHR
> `const` **SHR**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L43)
***
### SIGNEXTEND
> `const` **SIGNEXTEND**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L24)
***
### SLOAD
> `const` **SLOAD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L140)
***
### SLT
> `const` **SLT**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L31)
***
### SMOD
> `const` **SMOD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L16)
***
### SSTORE
> `const` **SSTORE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:141](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L141)
***
### STATICCALL
> `const` **STATICCALL**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:316](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L316)
***
### STOP
> `const` **STOP**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L9)
***
### SUB
> `const` **SUB**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L12)
***
### SWAP1
> `const` **SWAP1**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:258](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L258)
***
### SWAP10
> `const` **SWAP10**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:267](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L267)
***
### SWAP11
> `const` **SWAP11**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:270](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L270)
***
### SWAP12
> `const` **SWAP12**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:273](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L273)
***
### SWAP13
> `const` **SWAP13**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:276](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L276)
***
### SWAP14
> `const` **SWAP14**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:279](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L279)
***
### SWAP15
> `const` **SWAP15**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:282](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L282)
***
### SWAP16
> `const` **SWAP16**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:285](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L285)
***
### SWAP2
> `const` **SWAP2**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:259](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L259)
***
### SWAP3
> `const` **SWAP3**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:260](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L260)
***
### SWAP4
> `const` **SWAP4**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:261](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L261)
***
### SWAP5
> `const` **SWAP5**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:262](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L262)
***
### SWAP6
> `const` **SWAP6**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:263](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L263)
***
### SWAP7
> `const` **SWAP7**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:264](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L264)
***
### SWAP8
> `const` **SWAP8**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:265](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L265)
***
### SWAP9
> `const` **SWAP9**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:266](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L266)
***
### TIMESTAMP
> `const` **TIMESTAMP**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L103)
***
### TLOAD
> `const` **TLOAD**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L152)
***
### TSTORE
> `const` **TSTORE**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:153](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L153)
***
### XOR
> `const` **XOR**: [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/constants.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/constants.js#L39)
## Functions
### \_disassemble()
> **\_disassemble**(`bytecode`): `string`\[]
Defined in: [src/primitives/Opcode/disassemble.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/disassemble.js#L22)
Disassemble bytecode to human-readable strings
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`string`\[]
Array of formatted instruction strings
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const asm = Opcode.disassemble(bytecode);
// [
// "0x0000: PUSH1 0x01",
// "0x0002: PUSH1 0x02",
// "0x0004: ADD"
// ]
```
***
### \_dupPosition()
> **\_dupPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/dupPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/dupPosition.js#L17)
Get position for DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a DUP
#### Example
```typescript theme={null}
Opcode.dupPosition(Opcode.DUP1); // 1
Opcode.dupPosition(Opcode.DUP16); // 16
Opcode.dupPosition(Opcode.ADD); // undefined
```
***
### \_format()
> **\_format**(`instruction`): `string`
Defined in: [src/primitives/Opcode/format.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/format.js#L20)
Format instruction to human-readable string
#### Parameters
##### instruction
[`Instruction`](#instruction)
Instruction to format
#### Returns
`string`
Human-readable string
#### Example
```typescript theme={null}
const inst = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42])
};
Opcode.format(inst); // "0x0000: PUSH1 0x42"
```
***
### \_getCategory()
> **\_getCategory**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getCategory.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getCategory.js#L18)
Get opcode category
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Category name
#### Example
```typescript theme={null}
Opcode.getCategory(Opcode.ADD); // "arithmetic"
Opcode.getCategory(Opcode.SSTORE); // "storage"
Opcode.getCategory(Opcode.CALL); // "system"
```
***
### \_getDescription()
> **\_getDescription**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getDescription.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getDescription.js#L140)
Get human-readable description of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Description or generated description for PUSH/DUP/SWAP
#### Example
```typescript theme={null}
const desc = Opcode.getDescription(Opcode.ADD);
// "Addition operation"
const desc2 = Opcode.getDescription(Opcode.PUSH1);
// "Place 1-byte item on stack"
```
***
### \_getGasCost()
> **\_getGasCost**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getGasCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getGasCost.js#L16)
Get static gas cost for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Static gas cost or undefined if invalid
#### Example
```typescript theme={null}
const gas = Opcode.getGasCost(Opcode.ADD); // 3
const gas2 = Opcode.getGasCost(Opcode.SSTORE); // 100 (base cost, may be higher at runtime)
```
***
### \_getName()
> **\_getName**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getName.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getName.js#L16)
Get mnemonic name of an opcode (alias for name)
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.getName(Opcode.ADD); // "ADD"
const name2 = Opcode.getName(0xFF); // "SELFDESTRUCT"
```
***
### \_getPushSize()
> **\_getPushSize**(`opcode`): `number`
Defined in: [src/primitives/Opcode/getPushSize.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getPushSize.js#L18)
Get PUSH data size in bytes
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number`
Push size (0 for PUSH0, 1-32 for PUSH1-PUSH32, 0 for non-PUSH)
#### Example
```typescript theme={null}
Opcode.getPushSize(Opcode.PUSH0); // 0
Opcode.getPushSize(Opcode.PUSH1); // 1
Opcode.getPushSize(Opcode.PUSH32); // 32
Opcode.getPushSize(Opcode.ADD); // 0
```
***
### \_getStackEffect()
> **\_getStackEffect**(`opcode`): \{ `pop`: `number`; `push`: `number`; } | `undefined`
Defined in: [src/primitives/Opcode/getStackEffect.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackEffect.js#L19)
Get stack effect for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
\{ `pop`: `number`; `push`: `number`; } | `undefined`
Stack items consumed and produced
#### Example
```typescript theme={null}
const effect = Opcode.getStackEffect(Opcode.ADD);
// { pop: 2, push: 1 }
const effect2 = Opcode.getStackEffect(Opcode.DUP1);
// { pop: 1, push: 2 }
```
***
### \_getStackInput()
> **\_getStackInput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackInput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackInput.js#L16)
Get number of stack items consumed by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items consumed
#### Example
```typescript theme={null}
const inputs = Opcode.getStackInput(Opcode.ADD); // 2
const inputs2 = Opcode.getStackInput(Opcode.PUSH1); // 0
```
***
### \_getStackOutput()
> **\_getStackOutput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackOutput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackOutput.js#L16)
Get number of stack items produced by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items produced
#### Example
```typescript theme={null}
const outputs = Opcode.getStackOutput(Opcode.ADD); // 1
const outputs2 = Opcode.getStackOutput(Opcode.PUSH1); // 1
```
***
### \_info()
> **\_info**(`opcode`): [`Info`](#info) | `undefined`
Defined in: [src/primitives/Opcode/info.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/info.js#L17)
Get metadata for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
[`Info`](#info) | `undefined`
Metadata with gas cost and stack requirements
#### Example
```typescript theme={null}
const info = Opcode.info(Opcode.ADD);
console.log(info?.name); // "ADD"
console.log(info?.gasCost); // 3
```
***
### \_isDup()
> **\_isDup**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isDup.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isDup.js#L16)
Check if opcode is a DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if DUP1-DUP16
#### Example
```typescript theme={null}
Opcode.isDup(Opcode.DUP1); // true
Opcode.isDup(Opcode.ADD); // false
```
***
### \_isJump()
> **\_isJump**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJump.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJump.js#L17)
Check if opcode is a jump
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMP or JUMPI
#### Example
```typescript theme={null}
Opcode.isJump(Opcode.JUMP); // true
Opcode.isJump(Opcode.JUMPI); // true
Opcode.isJump(Opcode.ADD); // false
```
***
### \_isJumpDestination()
> **\_isJumpDestination**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJumpDestination.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJumpDestination.js#L16)
Check if opcode is JUMPDEST
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMPDEST
#### Example
```typescript theme={null}
Opcode.isJumpDestination(Opcode.JUMPDEST); // true
Opcode.isJumpDestination(Opcode.JUMP); // false
```
***
### \_isLog()
> **\_isLog**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isLog.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isLog.js#L16)
Check if opcode is a LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if LOG0-LOG4
#### Example
```typescript theme={null}
Opcode.isLog(Opcode.LOG1); // true
Opcode.isLog(Opcode.ADD); // false
```
***
### \_isPush()
> **\_isPush**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isPush.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isPush.js#L16)
Check if opcode is a PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if PUSH0-PUSH32
#### Example
```typescript theme={null}
Opcode.isPush(Opcode.PUSH1); // true
Opcode.isPush(Opcode.ADD); // false
```
***
### \_isSwap()
> **\_isSwap**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isSwap.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isSwap.js#L16)
Check if opcode is a SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if SWAP1-SWAP16
#### Example
```typescript theme={null}
Opcode.isSwap(Opcode.SWAP1); // true
Opcode.isSwap(Opcode.ADD); // false
```
***
### \_isTerminating()
> **\_isTerminating**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminating.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminating.js#L16)
Check if opcode terminates execution
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminating(Opcode.RETURN); // true
Opcode.isTerminating(Opcode.ADD); // false
```
***
### \_isTerminator()
> **\_isTerminator**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminator.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminator.js#L16)
Check if opcode terminates execution (alias for isTerminating)
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminator(Opcode.RETURN); // true
Opcode.isTerminator(Opcode.ADD); // false
```
***
### \_isValid()
> **\_isValid**(`opcode`): `opcode is BrandedOpcode`
Defined in: [src/primitives/Opcode/isValid.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValid.js#L16)
Check if opcode is valid
#### Parameters
##### opcode
`number`
Byte value to check
#### Returns
`opcode is BrandedOpcode`
True if opcode is defined in the EVM
#### Example
```typescript theme={null}
Opcode.isValid(0x01); // true (ADD)
Opcode.isValid(0x0c); // false (undefined)
```
***
### \_isValidJumpDest()
> **\_isValidJumpDest**(`bytecode`, `offset`): `boolean`
Defined in: [src/primitives/Opcode/isValidJumpDest.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidJumpDest.js#L18)
Check if offset is a valid jump destination
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
##### offset
`number`
Byte offset to check
#### Returns
`boolean`
True if offset is a JUMPDEST and not inside immediate data
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01]);
Opcode.isValidJumpDest(bytecode, 0); // true (JUMPDEST)
Opcode.isValidJumpDest(bytecode, 2); // false (immediate data)
```
***
### \_isValidOpcode()
> **\_isValidOpcode**(`value`): `boolean`
Defined in: [src/primitives/Opcode/isValidOpcode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidOpcode.js#L17)
Check if value is a valid opcode (alias for isValid)
#### Parameters
##### value
`number`
Value to check
#### Returns
`boolean`
True if valid opcode
#### Example
```typescript theme={null}
Opcode.isValidOpcode(0x01); // true (ADD)
Opcode.isValidOpcode(0xFF); // true (SELFDESTRUCT)
Opcode.isValidOpcode(0x0C); // false
```
***
### \_jumpDests()
> **\_jumpDests**(`bytecode`): `Set`\<`number`>
Defined in: [src/primitives/Opcode/jumpDests.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/jumpDests.js#L17)
Find all valid JUMPDEST locations
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`Set`\<`number`>
Set of valid jump destinations (byte offsets)
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01, 0x5b]);
const dests = Opcode.jumpDests(bytecode); // Set { 0, 3 }
```
***
### \_logTopics()
> **\_logTopics**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/logTopics.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/logTopics.js#L17)
Get number of topics for LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of topics (0-4), or undefined if not a LOG
#### Example
```typescript theme={null}
Opcode.logTopics(Opcode.LOG0); // 0
Opcode.logTopics(Opcode.LOG4); // 4
Opcode.logTopics(Opcode.ADD); // undefined
```
***
### \_name()
> **\_name**(`opcode`): `string`
Defined in: [src/primitives/Opcode/name.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/name.js#L15)
Get name of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.name(Opcode.ADD); // "ADD"
```
***
### \_parse()
> **\_parse**(`bytecode`): [`Instruction`](#instruction)\[]
Defined in: [src/primitives/Opcode/parse.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/parse.js#L21)
Parse bytecode into instructions
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
[`Instruction`](#instruction)\[]
Array of parsed instructions
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const instructions = Opcode.parse(bytecode);
// [
// { offset: 0, opcode: PUSH1, immediate: [0x01] },
// { offset: 2, opcode: PUSH1, immediate: [0x02] },
// { offset: 4, opcode: ADD }
// ]
```
***
### \_pushBytes()
> **\_pushBytes**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/pushBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushBytes.js#L18)
Get number of bytes pushed by PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of bytes (0-32), or undefined if not a PUSH
#### Example
```typescript theme={null}
Opcode.pushBytes(Opcode.PUSH1); // 1
Opcode.pushBytes(Opcode.PUSH32); // 32
Opcode.pushBytes(Opcode.PUSH0); // 0
Opcode.pushBytes(Opcode.ADD); // undefined
```
***
### \_pushOpcode()
> **\_pushOpcode**(`bytes`): [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/pushOpcode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushOpcode.js#L19)
Get PUSH opcode for given byte count
#### Parameters
##### bytes
`number`
Number of bytes (0-32)
#### Returns
[`BrandedOpcode`](#brandedopcode)
PUSH opcode for that size
#### Throws
If bytes is not 0-32
#### Example
```typescript theme={null}
Opcode.pushOpcode(1); // Opcode.PUSH1
Opcode.pushOpcode(32); // Opcode.PUSH32
Opcode.pushOpcode(0); // Opcode.PUSH0
```
***
### \_swapPosition()
> **\_swapPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/swapPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/swapPosition.js#L17)
Get position for SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a SWAP
#### Example
```typescript theme={null}
Opcode.swapPosition(Opcode.SWAP1); // 1
Opcode.swapPosition(Opcode.SWAP16); // 16
Opcode.swapPosition(Opcode.ADD); // undefined
```
***
### disassemble()
> **disassemble**(`bytecode`): `string`\[]
Defined in: [src/primitives/Opcode/disassemble.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/disassemble.js#L22)
Disassemble bytecode to human-readable strings
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`string`\[]
Array of formatted instruction strings
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const asm = Opcode.disassemble(bytecode);
// [
// "0x0000: PUSH1 0x01",
// "0x0002: PUSH1 0x02",
// "0x0004: ADD"
// ]
```
***
### dupPosition()
> **dupPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/dupPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/dupPosition.js#L17)
Get position for DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a DUP
#### Example
```typescript theme={null}
Opcode.dupPosition(Opcode.DUP1); // 1
Opcode.dupPosition(Opcode.DUP16); // 16
Opcode.dupPosition(Opcode.ADD); // undefined
```
***
### format()
> **format**(`instruction`): `string`
Defined in: [src/primitives/Opcode/format.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/format.js#L20)
Format instruction to human-readable string
#### Parameters
##### instruction
[`Instruction`](#instruction)
Instruction to format
#### Returns
`string`
Human-readable string
#### Example
```typescript theme={null}
const inst = {
offset: 0,
opcode: Opcode.PUSH1,
immediate: new Uint8Array([0x42])
};
Opcode.format(inst); // "0x0000: PUSH1 0x42"
```
***
### getCategory()
> **getCategory**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getCategory.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getCategory.js#L18)
Get opcode category
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Category name
#### Example
```typescript theme={null}
Opcode.getCategory(Opcode.ADD); // "arithmetic"
Opcode.getCategory(Opcode.SSTORE); // "storage"
Opcode.getCategory(Opcode.CALL); // "system"
```
***
### getDescription()
> **getDescription**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getDescription.js:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getDescription.js#L140)
Get human-readable description of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Description or generated description for PUSH/DUP/SWAP
#### Example
```typescript theme={null}
const desc = Opcode.getDescription(Opcode.ADD);
// "Addition operation"
const desc2 = Opcode.getDescription(Opcode.PUSH1);
// "Place 1-byte item on stack"
```
***
### getGasCost()
> **getGasCost**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getGasCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getGasCost.js#L16)
Get static gas cost for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Static gas cost or undefined if invalid
#### Example
```typescript theme={null}
const gas = Opcode.getGasCost(Opcode.ADD); // 3
const gas2 = Opcode.getGasCost(Opcode.SSTORE); // 100 (base cost, may be higher at runtime)
```
***
### getName()
> **getName**(`opcode`): `string`
Defined in: [src/primitives/Opcode/getName.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getName.js#L16)
Get mnemonic name of an opcode (alias for name)
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.getName(Opcode.ADD); // "ADD"
const name2 = Opcode.getName(0xFF); // "SELFDESTRUCT"
```
***
### getPushSize()
> **getPushSize**(`opcode`): `number`
Defined in: [src/primitives/Opcode/getPushSize.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getPushSize.js#L18)
Get PUSH data size in bytes
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number`
Push size (0 for PUSH0, 1-32 for PUSH1-PUSH32, 0 for non-PUSH)
#### Example
```typescript theme={null}
Opcode.getPushSize(Opcode.PUSH0); // 0
Opcode.getPushSize(Opcode.PUSH1); // 1
Opcode.getPushSize(Opcode.PUSH32); // 32
Opcode.getPushSize(Opcode.ADD); // 0
```
***
### getStackEffect()
> **getStackEffect**(`opcode`): \{ `pop`: `number`; `push`: `number`; } | `undefined`
Defined in: [src/primitives/Opcode/getStackEffect.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackEffect.js#L19)
Get stack effect for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
\{ `pop`: `number`; `push`: `number`; } | `undefined`
Stack items consumed and produced
#### Example
```typescript theme={null}
const effect = Opcode.getStackEffect(Opcode.ADD);
// { pop: 2, push: 1 }
const effect2 = Opcode.getStackEffect(Opcode.DUP1);
// { pop: 1, push: 2 }
```
***
### getStackInput()
> **getStackInput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackInput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackInput.js#L16)
Get number of stack items consumed by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items consumed
#### Example
```typescript theme={null}
const inputs = Opcode.getStackInput(Opcode.ADD); // 2
const inputs2 = Opcode.getStackInput(Opcode.PUSH1); // 0
```
***
### getStackOutput()
> **getStackOutput**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/getStackOutput.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/getStackOutput.js#L16)
Get number of stack items produced by an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of stack items produced
#### Example
```typescript theme={null}
const outputs = Opcode.getStackOutput(Opcode.ADD); // 1
const outputs2 = Opcode.getStackOutput(Opcode.PUSH1); // 1
```
***
### info()
> **info**(`opcode`): [`Info`](#info) | `undefined`
Defined in: [src/primitives/Opcode/info.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/info.js#L17)
Get metadata for an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
[`Info`](#info) | `undefined`
Metadata with gas cost and stack requirements
#### Example
```typescript theme={null}
const info = Opcode.info(Opcode.ADD);
console.log(info?.name); // "ADD"
console.log(info?.gasCost); // 3
```
***
### isDup()
> **isDup**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isDup.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isDup.js#L16)
Check if opcode is a DUP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if DUP1-DUP16
#### Example
```typescript theme={null}
Opcode.isDup(Opcode.DUP1); // true
Opcode.isDup(Opcode.ADD); // false
```
***
### isJump()
> **isJump**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJump.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJump.js#L17)
Check if opcode is a jump
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMP or JUMPI
#### Example
```typescript theme={null}
Opcode.isJump(Opcode.JUMP); // true
Opcode.isJump(Opcode.JUMPI); // true
Opcode.isJump(Opcode.ADD); // false
```
***
### isJumpDestination()
> **isJumpDestination**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isJumpDestination.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isJumpDestination.js#L16)
Check if opcode is JUMPDEST
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if JUMPDEST
#### Example
```typescript theme={null}
Opcode.isJumpDestination(Opcode.JUMPDEST); // true
Opcode.isJumpDestination(Opcode.JUMP); // false
```
***
### isLog()
> **isLog**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isLog.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isLog.js#L16)
Check if opcode is a LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if LOG0-LOG4
#### Example
```typescript theme={null}
Opcode.isLog(Opcode.LOG1); // true
Opcode.isLog(Opcode.ADD); // false
```
***
### isPush()
> **isPush**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isPush.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isPush.js#L16)
Check if opcode is a PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if PUSH0-PUSH32
#### Example
```typescript theme={null}
Opcode.isPush(Opcode.PUSH1); // true
Opcode.isPush(Opcode.ADD); // false
```
***
### isSwap()
> **isSwap**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isSwap.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isSwap.js#L16)
Check if opcode is a SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if SWAP1-SWAP16
#### Example
```typescript theme={null}
Opcode.isSwap(Opcode.SWAP1); // true
Opcode.isSwap(Opcode.ADD); // false
```
***
### isTerminating()
> **isTerminating**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminating.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminating.js#L16)
Check if opcode terminates execution
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminating(Opcode.RETURN); // true
Opcode.isTerminating(Opcode.ADD); // false
```
***
### isTerminator()
> **isTerminator**(`opcode`): `boolean`
Defined in: [src/primitives/Opcode/isTerminator.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isTerminator.js#L16)
Check if opcode terminates execution (alias for isTerminating)
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to check
#### Returns
`boolean`
True if STOP, RETURN, REVERT, INVALID, or SELFDESTRUCT
#### Example
```typescript theme={null}
Opcode.isTerminator(Opcode.RETURN); // true
Opcode.isTerminator(Opcode.ADD); // false
```
***
### isValid()
> **isValid**(`opcode`): `opcode is BrandedOpcode`
Defined in: [src/primitives/Opcode/isValid.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValid.js#L16)
Check if opcode is valid
#### Parameters
##### opcode
`number`
Byte value to check
#### Returns
`opcode is BrandedOpcode`
True if opcode is defined in the EVM
#### Example
```typescript theme={null}
Opcode.isValid(0x01); // true (ADD)
Opcode.isValid(0x0c); // false (undefined)
```
***
### isValidJumpDest()
> **isValidJumpDest**(`bytecode`, `offset`): `boolean`
Defined in: [src/primitives/Opcode/isValidJumpDest.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidJumpDest.js#L18)
Check if offset is a valid jump destination
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
##### offset
`number`
Byte offset to check
#### Returns
`boolean`
True if offset is a JUMPDEST and not inside immediate data
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01]);
Opcode.isValidJumpDest(bytecode, 0); // true (JUMPDEST)
Opcode.isValidJumpDest(bytecode, 2); // false (immediate data)
```
***
### isValidOpcode()
> **isValidOpcode**(`value`): `boolean`
Defined in: [src/primitives/Opcode/isValidOpcode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/isValidOpcode.js#L17)
Check if value is a valid opcode (alias for isValid)
#### Parameters
##### value
`number`
Value to check
#### Returns
`boolean`
True if valid opcode
#### Example
```typescript theme={null}
Opcode.isValidOpcode(0x01); // true (ADD)
Opcode.isValidOpcode(0xFF); // true (SELFDESTRUCT)
Opcode.isValidOpcode(0x0C); // false
```
***
### jumpDests()
> **jumpDests**(`bytecode`): `Set`\<`number`>
Defined in: [src/primitives/Opcode/jumpDests.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/jumpDests.js#L17)
Find all valid JUMPDEST locations
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
`Set`\<`number`>
Set of valid jump destinations (byte offsets)
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x5b, 0x60, 0x01, 0x5b]);
const dests = Opcode.jumpDests(bytecode); // Set { 0, 3 }
```
***
### logTopics()
> **logTopics**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/logTopics.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/logTopics.js#L17)
Get number of topics for LOG instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of topics (0-4), or undefined if not a LOG
#### Example
```typescript theme={null}
Opcode.logTopics(Opcode.LOG0); // 0
Opcode.logTopics(Opcode.LOG4); // 4
Opcode.logTopics(Opcode.ADD); // undefined
```
***
### name()
> **name**(`opcode`): `string`
Defined in: [src/primitives/Opcode/name.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/name.js#L15)
Get name of an opcode
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`string`
Opcode name or "UNKNOWN" if invalid
#### Example
```typescript theme={null}
const name = Opcode.name(Opcode.ADD); // "ADD"
```
***
### parse()
> **parse**(`bytecode`): [`Instruction`](#instruction)\[]
Defined in: [src/primitives/Opcode/parse.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/parse.js#L21)
Parse bytecode into instructions
#### Parameters
##### bytecode
`Uint8Array`\<`ArrayBufferLike`>
Raw bytecode bytes
#### Returns
[`Instruction`](#instruction)\[]
Array of parsed instructions
#### Example
```typescript theme={null}
const bytecode = new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]);
const instructions = Opcode.parse(bytecode);
// [
// { offset: 0, opcode: PUSH1, immediate: [0x01] },
// { offset: 2, opcode: PUSH1, immediate: [0x02] },
// { offset: 4, opcode: ADD }
// ]
```
***
### pushBytes()
> **pushBytes**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/pushBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushBytes.js#L18)
Get number of bytes pushed by PUSH instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Number of bytes (0-32), or undefined if not a PUSH
#### Example
```typescript theme={null}
Opcode.pushBytes(Opcode.PUSH1); // 1
Opcode.pushBytes(Opcode.PUSH32); // 32
Opcode.pushBytes(Opcode.PUSH0); // 0
Opcode.pushBytes(Opcode.ADD); // undefined
```
***
### pushOpcode()
> **pushOpcode**(`bytes`): [`BrandedOpcode`](#brandedopcode)
Defined in: [src/primitives/Opcode/pushOpcode.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/pushOpcode.js#L19)
Get PUSH opcode for given byte count
#### Parameters
##### bytes
`number`
Number of bytes (0-32)
#### Returns
[`BrandedOpcode`](#brandedopcode)
PUSH opcode for that size
#### Throws
If bytes is not 0-32
#### Example
```typescript theme={null}
Opcode.pushOpcode(1); // Opcode.PUSH1
Opcode.pushOpcode(32); // Opcode.PUSH32
Opcode.pushOpcode(0); // Opcode.PUSH0
```
***
### swapPosition()
> **swapPosition**(`opcode`): `number` | `undefined`
Defined in: [src/primitives/Opcode/swapPosition.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Opcode/swapPosition.js#L17)
Get position for SWAP instruction
#### Parameters
##### opcode
[`BrandedOpcode`](#brandedopcode)
Opcode to query
#### Returns
`number` | `undefined`
Stack position (1-16), or undefined if not a SWAP
#### Example
```typescript theme={null}
Opcode.swapPosition(Opcode.SWAP1); // 1
Opcode.swapPosition(Opcode.SWAP16); // 16
Opcode.swapPosition(Opcode.ADD); // undefined
```
## References
### Opcode
Re-exports [Opcode](../index/index.mdx#opcode)
# primitives/PackedUserOperation
Source: https://voltaire.tevm.sh/generated-api/primitives/PackedUserOperation
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PackedUserOperation
# primitives/PackedUserOperation
## Type Aliases
### PackedUserOperationType
> **PackedUserOperationType** = `object` & `object`
Defined in: [src/primitives/PackedUserOperation/PackedUserOperationType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/PackedUserOperationType.ts#L19)
PackedUserOperation type - ERC-4337 v0.7+ format
Optimized format that packs gas limits and fees into bytes32 fields,
reducing calldata size and gas costs for bundlers.
Gas packing format:
* accountGasLimits: verificationGasLimit (128 bits) || callGasLimit (128 bits)
* gasFees: maxPriorityFeePerGas (128 bits) || maxFeePerGas (128 bits)
#### Type Declaration
##### accountGasLimits
> `readonly` **accountGasLimits**: `Uint8Array`
Packed gas limits: verificationGasLimit (128) || callGasLimit (128)
##### callData
> `readonly` **callData**: `Uint8Array`
Calldata to execute on the account
##### gasFees
> `readonly` **gasFees**: `Uint8Array`
Packed fees: maxPriorityFeePerGas (128) || maxFeePerGas (128)
##### initCode
> `readonly` **initCode**: `Uint8Array`
Account factory and initialization code for first-time deployment
##### nonce
> `readonly` **nonce**: [`Type`](Uint.mdx#type)
Anti-replay nonce (key + sequence)
##### paymasterAndData
> `readonly` **paymasterAndData**: `Uint8Array`
Paymaster address and data (empty if self-paying)
##### preVerificationGas
> `readonly` **preVerificationGas**: [`Type`](Uint.mdx#type)
Fixed gas overhead for bundler compensation
##### sender
> `readonly` **sender**: [`AddressType`](Address.mdx#addresstype)
Smart account address initiating the operation
##### signature
> `readonly` **signature**: `Uint8Array`
Account signature over userOpHash
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"PackedUserOperation"`
#### See
* [https://eips.ethereum.org/EIPS/eip-4337](https://eips.ethereum.org/EIPS/eip-4337)
* [https://voltaire.tevm.sh/primitives/packed-user-operation](https://voltaire.tevm.sh/primitives/packed-user-operation) for PackedUserOperation documentation
#### Since
0.0.0
## Variables
### PackedUserOperation
> `const` **PackedUserOperation**: `object`
Defined in: [src/primitives/PackedUserOperation/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/index.ts#L34)
#### Type Declaration
##### from()
> **from**: (`params`) => [`PackedUserOperationType`](#packeduseroperationtype)
Create PackedUserOperation from input object
###### Parameters
###### params
PackedUserOperation parameters
###### accountGasLimits
`string` | `Uint8Array`\<`ArrayBufferLike`>
Packed gas limits (32 bytes)
###### callData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Calldata to execute
###### gasFees
`string` | `Uint8Array`\<`ArrayBufferLike`>
Packed gas fees (32 bytes)
###### initCode
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account initialization code
###### nonce
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Anti-replay nonce
###### paymasterAndData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Paymaster address and data
###### preVerificationGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Fixed gas overhead
###### sender
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Smart account address
###### signature
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account signature
###### Returns
[`PackedUserOperationType`](#packeduseroperationtype)
PackedUserOperation
###### Example
```typescript theme={null}
const packedUserOp = PackedUserOperation.from({
sender: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
nonce: 0n,
initCode: "0x",
callData: "0x",
accountGasLimits: "0x...", // 32 bytes
preVerificationGas: 50000n,
gasFees: "0x...", // 32 bytes
paymasterAndData: "0x",
signature: "0x",
});
```
##### hash()
> **hash**: (`packedUserOp`, `entryPoint`, `chainId`) => `Uint8Array`
###### Parameters
###### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
###### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### chainId
`number` | `bigint`
###### Returns
`Uint8Array`
##### unpack()
> **unpack**: (`packedUserOp`) => [`UserOperationType`](UserOperation.mdx#useroperationtype)
###### Parameters
###### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
###### Returns
[`UserOperationType`](UserOperation.mdx#useroperationtype)
## Functions
### \_hash()
> **\_hash**(`packedUserOp`, `entryPoint`, `chainId`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/PackedUserOperation/hash.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/hash.js#L21)
Compute userOpHash for PackedUserOperation
userOpHash = keccak256(abi.encode(packedUserOp, entryPoint, chainId))
#### Parameters
##### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
Packed user operation
##### entryPoint
EntryPoint contract address
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### chainId
Chain ID
`number` | `bigint`
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte hash for signing
#### Example
```typescript theme={null}
const hash = PackedUserOperation.hash(packedUserOp, ENTRYPOINT_V07, 1n);
const signature = await account.signMessage(hash);
```
***
### \_unpack()
> **\_unpack**(`packedUserOp`): [`UserOperationType`](UserOperation.mdx#useroperationtype)
Defined in: [src/primitives/PackedUserOperation/unpack.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/unpack.js#L16)
Unpack PackedUserOperation (v0.7) to UserOperation (v0.6)
Extracts gas limits and fees from packed bytes32 fields.
#### Parameters
##### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
Packed user operation v0.7
#### Returns
[`UserOperationType`](UserOperation.mdx#useroperationtype)
User operation v0.6
#### Example
```typescript theme={null}
const userOp = PackedUserOperation.unpack(packedUserOp);
```
***
### from()
> **from**(`params`): [`PackedUserOperationType`](#packeduseroperationtype)
Defined in: [src/primitives/PackedUserOperation/from.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/from.js#L34)
Create PackedUserOperation from input object
#### Parameters
##### params
PackedUserOperation parameters
###### accountGasLimits
`string` | `Uint8Array`\<`ArrayBufferLike`>
Packed gas limits (32 bytes)
###### callData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Calldata to execute
###### gasFees
`string` | `Uint8Array`\<`ArrayBufferLike`>
Packed gas fees (32 bytes)
###### initCode
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account initialization code
###### nonce
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Anti-replay nonce
###### paymasterAndData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Paymaster address and data
###### preVerificationGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Fixed gas overhead
###### sender
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Smart account address
###### signature
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account signature
#### Returns
[`PackedUserOperationType`](#packeduseroperationtype)
PackedUserOperation
#### Example
```typescript theme={null}
const packedUserOp = PackedUserOperation.from({
sender: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
nonce: 0n,
initCode: "0x",
callData: "0x",
accountGasLimits: "0x...", // 32 bytes
preVerificationGas: 50000n,
gasFees: "0x...", // 32 bytes
paymasterAndData: "0x",
signature: "0x",
});
```
***
### hash()
> **hash**(`packedUserOp`, `entryPoint`, `chainId`): `Uint8Array`
Defined in: [src/primitives/PackedUserOperation/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/index.ts#L16)
#### Parameters
##### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
##### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### chainId
`number` | `bigint`
#### Returns
`Uint8Array`
***
### unpack()
> **unpack**(`packedUserOp`): [`UserOperationType`](UserOperation.mdx#useroperationtype)
Defined in: [src/primitives/PackedUserOperation/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PackedUserOperation/index.ts#L24)
#### Parameters
##### packedUserOp
[`PackedUserOperationType`](#packeduseroperationtype)
#### Returns
[`UserOperationType`](UserOperation.mdx#useroperationtype)
# primitives/Paymaster
Source: https://voltaire.tevm.sh/generated-api/primitives/Paymaster
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Paymaster
# primitives/Paymaster
## Type Aliases
### PaymasterType
> **PaymasterType** = `Uint8Array` & `object`
Defined in: [src/primitives/Paymaster/PaymasterType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/PaymasterType.ts#L13)
Paymaster address type - ERC-4337 paymaster contract
Paymasters sponsor gas fees for user operations, enabling gasless transactions
or allowing users to pay gas in ERC-20 tokens.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Paymaster"`
#### See
* [https://eips.ethereum.org/EIPS/eip-4337](https://eips.ethereum.org/EIPS/eip-4337)
* [https://voltaire.tevm.sh/primitives/paymaster](https://voltaire.tevm.sh/primitives/paymaster) for Paymaster documentation
#### Since
0.0.0
## Variables
### Paymaster
> `const` **Paymaster**: `object`
Defined in: [src/primitives/Paymaster/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/index.ts#L31)
#### Type Declaration
##### equals()
> **equals**: (`paymaster1`, `paymaster2`) => `boolean`
###### Parameters
###### paymaster1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### paymaster2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`PaymasterType`](#paymastertype)
Create Paymaster from address input
###### Parameters
###### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
[`PaymasterType`](#paymastertype)
Paymaster address
###### Throws
If address format is invalid
###### Example
```typescript theme={null}
const paymaster = Paymaster.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
##### toHex()
> **toHex**: (`paymaster`) => `string`
###### Parameters
###### paymaster
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### Returns
`string`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Paymaster/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/equals.js#L15)
Check if two Paymaster addresses are equal
#### Parameters
##### a
[`PaymasterType`](#paymastertype)
First Paymaster
##### b
[`PaymasterType`](#paymastertype)
Second Paymaster
#### Returns
`boolean`
True if addresses are equal
#### Example
```typescript theme={null}
const isEqual = Paymaster.equals(paymaster1, paymaster2);
```
***
### \_toHex()
> **\_toHex**(`paymaster`): `string`
Defined in: [src/primitives/Paymaster/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/toHex.js#L15)
Convert Paymaster to hex string
#### Parameters
##### paymaster
[`PaymasterType`](#paymastertype)
Paymaster address
#### Returns
`string`
Hex string (0x-prefixed)
#### Example
```typescript theme={null}
const hex = Paymaster.toHex(paymaster);
console.log(hex); // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
```
***
### equals()
> **equals**(`paymaster1`, `paymaster2`): `boolean`
Defined in: [src/primitives/Paymaster/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/index.ts#L20)
#### Parameters
##### paymaster1
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### paymaster2
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`PaymasterType`](#paymastertype)
Defined in: [src/primitives/Paymaster/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/from.js#L15)
Create Paymaster from address input
#### Parameters
##### value
Address value
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
[`PaymasterType`](#paymastertype)
Paymaster address
#### Throws
If address format is invalid
#### Example
```typescript theme={null}
const paymaster = Paymaster.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
```
***
### toHex()
> **toHex**(`paymaster`): `string`
Defined in: [src/primitives/Paymaster/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Paymaster/index.ts#L14)
#### Parameters
##### paymaster
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
#### Returns
`string`
# primitives/PeerId
Source: https://voltaire.tevm.sh/generated-api/primitives/PeerId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PeerId
# primitives/PeerId
## Type Aliases
### EnodeComponents
> **EnodeComponents** = `object`
Defined in: [src/primitives/PeerId/PeerIdType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L23)
Parsed enode URL components
#### Properties
##### discoveryPort?
> `readonly` `optional` **discoveryPort**: `number`
Defined in: [src/primitives/PeerId/PeerIdType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L31)
UDP port for discovery (optional)
##### ip
> `readonly` **ip**: `string`
Defined in: [src/primitives/PeerId/PeerIdType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L27)
IP address (IPv4 or IPv6)
##### port
> `readonly` **port**: `number`
Defined in: [src/primitives/PeerId/PeerIdType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L29)
TCP port for RLPx
##### publicKey
> `readonly` **publicKey**: `string`
Defined in: [src/primitives/PeerId/PeerIdType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L25)
Node public key (128 hex chars)
***
### PeerIdType
> **PeerIdType** = `string` & `object`
Defined in: [src/primitives/PeerId/PeerIdType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/PeerIdType.ts#L18)
Branded PeerId type - Ethereum peer identifier
Wraps a string representing a peer ID (typically an enode URL)
Enode URL format: enode://PUBKEY\@IP:PORT?discport=DISCPORT
* PUBKEY: 128 hex character node ID (secp256k1 public key)
* IP: IPv4 or IPv6 address
* PORT: TCP port for RLPx connection
* DISCPORT: (optional) UDP port for peer discovery
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"PeerId"`
#### Example
```typescript theme={null}
const peerId = "enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@10.3.58.6:30303?discport=30301"
```
## Variables
### PeerId
> `const` **PeerId**: `object`
Defined in: [src/primitives/PeerId/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/index.ts#L31)
#### Type Declaration
##### equals()
> **equals**: (`peerId1`, `peerId2`) => `boolean`
###### Parameters
###### peerId1
`string`
###### peerId2
`string`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`PeerIdType`](#peeridtype)
Create PeerId from string
###### Parameters
###### value
`string`
Peer ID string (enode URL or node ID)
###### Returns
[`PeerIdType`](#peeridtype)
Branded peer ID
###### Throws
If value is not a valid peer ID
###### Example
```javascript theme={null}
import * as PeerId from './primitives/PeerId/index.js';
const peerId = PeerId.from("enode://pubkey@192.168.1.1:30303");
```
##### parse()
> **parse**: (`peerId`) => [`EnodeComponents`](#enodecomponents)
###### Parameters
###### peerId
`string`
###### Returns
[`EnodeComponents`](#enodecomponents)
##### toString()
> **toString**: (`peerId`) => `string`
###### Parameters
###### peerId
`string`
###### Returns
`string`
## Functions
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/PeerId/equals.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/equals.js#L16)
Compare two PeerIds for equality
#### Parameters
##### this
[`PeerIdType`](#peeridtype)
##### other
[`PeerIdType`](#peeridtype)
Peer ID to compare
#### Returns
`boolean`
True if equal
#### Example
```javascript theme={null}
import * as PeerId from './primitives/PeerId/index.js';
const a = PeerId.from("enode://abc@192.168.1.1:30303");
const b = PeerId.from("enode://abc@192.168.1.1:30303");
const equal = PeerId._equals.call(a, b); // true
```
***
### \_parse()
> **\_parse**(`this`): [`EnodeComponents`](#enodecomponents)
Defined in: [src/primitives/PeerId/parse.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/parse.js#L21)
Parse enode URL into components
#### Parameters
##### this
[`PeerIdType`](#peeridtype)
#### Returns
[`EnodeComponents`](#enodecomponents)
Parsed enode components
#### Throws
If not a valid enode URL
#### Example
```javascript theme={null}
import * as PeerId from './primitives/PeerId/index.js';
const peerId = PeerId.from("enode://pubkey@192.168.1.1:30303?discport=30301");
const parsed = PeerId._parse.call(peerId);
console.log(parsed.ip); // "192.168.1.1"
console.log(parsed.port); // 30303
console.log(parsed.discoveryPort); // 30301
```
***
### \_toString()
> **\_toString**(`this`): `string`
Defined in: [src/primitives/PeerId/toString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/toString.js#L15)
Convert PeerId to string (identity function for branded type)
#### Parameters
##### this
[`PeerIdType`](#peeridtype)
#### Returns
`string`
Peer ID as string
#### Example
```javascript theme={null}
import * as PeerId from './primitives/PeerId/index.js';
const peerId = PeerId.from("enode://pubkey@192.168.1.1:30303");
const str = PeerId._toString.call(peerId);
```
***
### equals()
> **equals**(`peerId1`, `peerId2`): `boolean`
Defined in: [src/primitives/PeerId/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/index.ts#L19)
#### Parameters
##### peerId1
`string`
##### peerId2
`string`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`PeerIdType`](#peeridtype)
Defined in: [src/primitives/PeerId/from.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/from.js#L16)
Create PeerId from string
#### Parameters
##### value
`string`
Peer ID string (enode URL or node ID)
#### Returns
[`PeerIdType`](#peeridtype)
Branded peer ID
#### Throws
If value is not a valid peer ID
#### Example
```javascript theme={null}
import * as PeerId from './primitives/PeerId/index.js';
const peerId = PeerId.from("enode://pubkey@192.168.1.1:30303");
```
***
### parse()
> **parse**(`peerId`): [`EnodeComponents`](#enodecomponents)
Defined in: [src/primitives/PeerId/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/index.ts#L23)
#### Parameters
##### peerId
`string`
#### Returns
[`EnodeComponents`](#enodecomponents)
***
### toString()
> **toString**(`peerId`): `string`
Defined in: [src/primitives/PeerId/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerId/index.ts#L15)
#### Parameters
##### peerId
`string`
#### Returns
`string`
# primitives/PeerInfo
Source: https://voltaire.tevm.sh/generated-api/primitives/PeerInfo
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PeerInfo
# primitives/PeerInfo
## Type Aliases
### PeerInfoType
> **PeerInfoType** = `object`
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L16)
Peer information structure from admin\_peers RPC method
Contains metadata about a connected peer including:
* Peer identity (ID, name, capabilities)
* Network connection details (local/remote addresses, direction)
* Protocol-specific state (difficulty, head block)
#### See
[https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-admin#admin-peers](https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-admin#admin-peers)
#### Properties
##### caps
> `readonly` **caps**: readonly `string`\[]
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L22)
Supported capabilities (e.g., \["eth/67", "snap/1"])
##### id
> `readonly` **id**: [`PeerIdType`](PeerId.mdx#peeridtype)
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L18)
Peer ID (enode URL)
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L20)
Remote client identifier (e.g., "Geth/v1.10.26-stable")
##### network
> `readonly` **network**: `object`
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L24)
Network connection information
###### inbound
> `readonly` **inbound**: `boolean`
True if inbound connection
###### localAddress
> `readonly` **localAddress**: `string`
Local endpoint (IP:PORT)
###### remoteAddress
> `readonly` **remoteAddress**: `string`
Remote endpoint (IP:PORT)
###### static
> `readonly` **static**: `boolean`
True if static node
###### trusted
> `readonly` **trusted**: `boolean`
True if trusted peer
##### protocols
> `readonly` **protocols**: `object`
Defined in: [src/primitives/PeerInfo/PeerInfoType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/PeerInfoType.ts#L37)
Protocol-specific information
###### Index Signature
\[`protocol`: `string`]: `unknown`
Other protocols
###### eth?
> `readonly` `optional` **eth**: `object`
Ethereum protocol info (if supported)
###### eth.difficulty
> `readonly` **difficulty**: [`BrandedUint`](Uint.mdx#brandeduint)
Total difficulty of peer's chain
###### eth.head
> `readonly` **head**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Peer's head block hash
###### eth.version
> `readonly` **version**: [`ProtocolVersionType`](ProtocolVersion.mdx#protocolversiontype)
Protocol version
## Variables
### PeerInfo
> `const` **PeerInfo**: `object`
Defined in: [src/primitives/PeerInfo/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/index.ts#L29)
#### Type Declaration
##### from()
> **from**: (`value`) => [`PeerInfoType`](#peerinfotype)
Create PeerInfo from RPC response object
###### Parameters
###### value
`any`
Peer info object from admin\_peers
###### Returns
[`PeerInfoType`](#peerinfotype)
Peer information
###### Throws
If value is not a valid peer info object
###### Example
```javascript theme={null}
import * as PeerInfo from './primitives/PeerInfo/index.js';
const peers = rpcResponse.map(peer => PeerInfo.from(peer));
peers.forEach(peer => {
console.log(peer.name);
console.log(peer.network.inbound);
});
```
##### hasCapability()
> **hasCapability**: (`peerInfo`, `capability`) => `boolean`
###### Parameters
###### peerInfo
`any`
###### capability
`string`
###### Returns
`boolean`
##### isInbound()
> **isInbound**: (`peerInfo`) => `boolean`
###### Parameters
###### peerInfo
`any`
###### Returns
`boolean`
## Functions
### \_hasCapability()
> **\_hasCapability**(`this`, `capability`): `boolean`
Defined in: [src/primitives/PeerInfo/hasCapability.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/hasCapability.js#L15)
Check if peer supports a specific capability
#### Parameters
##### this
[`PeerInfoType`](#peerinfotype)
##### capability
`string`
Capability to check (e.g., "eth/67", "snap/1")
#### Returns
`boolean`
True if peer supports capability
#### Example
```javascript theme={null}
import * as PeerInfo from './primitives/PeerInfo/index.js';
const peer = PeerInfo.from(rpcResponse);
const hasEth67 = PeerInfo._hasCapability.call(peer, "eth/67");
```
***
### \_isInbound()
> **\_isInbound**(`this`): `boolean`
Defined in: [src/primitives/PeerInfo/isInbound.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/isInbound.js#L14)
Check if peer connection is inbound
#### Parameters
##### this
[`PeerInfoType`](#peerinfotype)
#### Returns
`boolean`
True if inbound connection
#### Example
```javascript theme={null}
import * as PeerInfo from './primitives/PeerInfo/index.js';
const peer = PeerInfo.from(rpcResponse);
const inbound = PeerInfo._isInbound.call(peer);
```
***
### from()
> **from**(`value`): [`PeerInfoType`](#peerinfotype)
Defined in: [src/primitives/PeerInfo/from.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/from.js#L25)
Create PeerInfo from RPC response object
#### Parameters
##### value
`any`
Peer info object from admin\_peers
#### Returns
[`PeerInfoType`](#peerinfotype)
Peer information
#### Throws
If value is not a valid peer info object
#### Example
```javascript theme={null}
import * as PeerInfo from './primitives/PeerInfo/index.js';
const peers = rpcResponse.map(peer => PeerInfo.from(peer));
peers.forEach(peer => {
console.log(peer.name);
console.log(peer.network.inbound);
});
```
***
### hasCapability()
> **hasCapability**(`peerInfo`, `capability`): `boolean`
Defined in: [src/primitives/PeerInfo/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/index.ts#L14)
#### Parameters
##### peerInfo
`any`
##### capability
`string`
#### Returns
`boolean`
***
### isInbound()
> **isInbound**(`peerInfo`): `boolean`
Defined in: [src/primitives/PeerInfo/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PeerInfo/index.ts#L20)
#### Parameters
##### peerInfo
`any`
#### Returns
`boolean`
# primitives/PendingTransactionFilter
Source: https://voltaire.tevm.sh/generated-api/primitives/PendingTransactionFilter
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PendingTransactionFilter
# primitives/PendingTransactionFilter
## Type Aliases
### PendingTransactionFilterType
> **PendingTransactionFilterType** = `object` & `object`
Defined in: [src/primitives/PendingTransactionFilter/PendingTransactionFilterType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PendingTransactionFilter/PendingTransactionFilterType.ts#L10)
Pending transaction filter created by eth\_newPendingTransactionFilter
Notifies of new pending transactions when polled with eth\_getFilterChanges.
Returns array of transaction hashes.
#### Type Declaration
##### filterId
> `readonly` **filterId**: [`FilterIdType`](FilterId.mdx#filteridtype)
Filter identifier
##### type
> `readonly` **type**: `"pendingTransaction"`
Filter type discriminator
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"PendingTransactionFilter"`
## Functions
### from()
> **from**(`filterId`): [`PendingTransactionFilterType`](#pendingtransactionfiltertype)
Defined in: [src/primitives/PendingTransactionFilter/from.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PendingTransactionFilter/from.js#L13)
Create PendingTransactionFilter from filter ID
#### Parameters
##### filterId
[`FilterIdType`](FilterId.mdx#filteridtype)
Filter identifier from eth\_newPendingTransactionFilter
#### Returns
[`PendingTransactionFilterType`](#pendingtransactionfiltertype)
#### Example
```javascript theme={null}
import * as PendingTransactionFilter from './primitives/PendingTransactionFilter/index.js';
import * as FilterId from './primitives/FilterId/index.js';
const filter = PendingTransactionFilter.from(FilterId.from("0x1"));
```
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/primitives/Permit/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / primitives/Permit
# primitives/Permit
## Namespaces
* [KnownTokens](namespaces/KnownTokens.mdx)
## Interfaces
### PermitDomainType
Defined in: [src/primitives/Permit/PermitType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L19)
EIP-712 Domain for Permit signatures
#### Properties
##### chainId
> `readonly` **chainId**: [`ChainIdType`](../ChainId.mdx#chainidtype)
Defined in: [src/primitives/Permit/PermitType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L22)
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/Permit/PermitType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L20)
##### verifyingContract
> `readonly` **verifyingContract**: [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Permit/PermitType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L23)
##### version
> `readonly` **version**: `string`
Defined in: [src/primitives/Permit/PermitType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L21)
***
### PermitType
Defined in: [src/primitives/Permit/PermitType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L8)
EIP-2612 Permit message structure
#### Properties
##### deadline
> `readonly` **deadline**: [`Type`](../Uint.mdx#type)
Defined in: [src/primitives/Permit/PermitType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L13)
##### nonce
> `readonly` **nonce**: [`Type`](../Uint.mdx#type)
Defined in: [src/primitives/Permit/PermitType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L12)
##### owner
> `readonly` **owner**: [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Permit/PermitType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L9)
##### spender
> `readonly` **spender**: [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Permit/PermitType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L10)
##### value
> `readonly` **value**: [`Type`](../Uint.mdx#type)
Defined in: [src/primitives/Permit/PermitType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/PermitType.ts#L11)
## Variables
### PERMIT\_TYPES
> `const` **PERMIT\_TYPES**: `object`
Defined in: [src/primitives/Permit/constants.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/constants.js#L4)
EIP-2612 Permit type definition for EIP-712
#### Type Declaration
##### Permit
> **Permit**: `object`\[]
## Functions
### createPermitSignature()
> **createPermitSignature**(`permit`, `domain`, `privateKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Permit/createPermitSignature.js:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/createPermitSignature.js#L37)
Creates an EIP-2612 permit signature
#### Parameters
##### permit
[`PermitType`](#permittype)
Permit message
##### domain
[`PermitDomainType`](#permitdomaintype)
EIP-712 domain
##### privateKey
`Uint8Array`\<`ArrayBufferLike`>
Private key (32 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compact signature (64 bytes + recovery id)
#### Example
```typescript theme={null}
import * as Permit from './primitives/Permit/index.js';
import * as Address from './primitives/Address/index.js';
import * as Uint256 from './primitives/Uint256/index.js';
const permit = {
owner: Address.fromHex('0x...'),
spender: Address.fromHex('0x...'),
value: Uint256.fromBigInt(1000000n),
nonce: Uint256.fromBigInt(0n),
deadline: Uint256.fromBigInt(1234567890n),
};
const domain = {
name: 'USD Coin',
version: '2',
chainId: 1,
verifyingContract: Address.fromHex('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
};
const signature = Permit.createPermitSignature(permit, domain, privateKey);
```
***
### verifyPermit()
> **verifyPermit**(`permit`, `signature`, `domain`): `boolean`
Defined in: [src/primitives/Permit/verifyPermit.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/verifyPermit.js#L21)
Verifies an EIP-2612 permit signature
#### Parameters
##### permit
[`PermitType`](#permittype)
Permit message
##### signature
`Uint8Array`\<`ArrayBufferLike`>
Compact signature (64 bytes + recovery id)
##### domain
[`PermitDomainType`](#permitdomaintype)
EIP-712 domain
#### Returns
`boolean`
True if signature is valid
#### Example
```typescript theme={null}
import * as Permit from './primitives/Permit/index.js';
const isValid = Permit.verifyPermit(permit, signature, domain);
```
# KnownTokens
Source: https://voltaire.tevm.sh/generated-api/primitives/Permit/namespaces/KnownTokens
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Permit](../index.mdx) / KnownTokens
# KnownTokens
## Variables
### DAI\_MAINNET
> `const` **DAI\_MAINNET**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L47)
DAI Mainnet (Ethereum)
#### Type Declaration
##### chainId
> **chainId**: `number` = `1`
##### name
> **name**: `string` = `"Dai Stablecoin"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"1"`
***
### UNI\_MAINNET
> `const` **UNI\_MAINNET**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L71)
UNI Mainnet (Ethereum)
#### Type Declaration
##### chainId
> **chainId**: `number` = `1`
##### name
> **name**: `string` = `"Uniswap"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"1"`
***
### USDC\_ARBITRUM
> `const` **USDC\_ARBITRUM**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L35)
USDC Arbitrum
#### Type Declaration
##### chainId
> **chainId**: `number` = `42161`
##### name
> **name**: `string` = `"USD Coin"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"2"`
***
### USDC\_MAINNET
> `const` **USDC\_MAINNET**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L11)
USDC Mainnet (Ethereum)
#### Type Declaration
##### chainId
> **chainId**: `number` = `1`
##### name
> **name**: `string` = `"USD Coin"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"2"`
***
### USDC\_POLYGON
> `const` **USDC\_POLYGON**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L23)
USDC Polygon
#### Type Declaration
##### chainId
> **chainId**: `number` = `137`
##### name
> **name**: `string` = `"USD Coin"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"2"`
***
### USDT\_MAINNET
> `const` **USDT\_MAINNET**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L59)
USDT Mainnet (Ethereum) - Note: USDT uses EIP-2612 on mainnet
#### Type Declaration
##### chainId
> **chainId**: `number` = `1`
##### name
> **name**: `string` = `"Tether USD"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"1"`
***
### WETH\_MAINNET
> `const` **WETH\_MAINNET**: `object`
Defined in: [src/primitives/Permit/knownTokens.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Permit/knownTokens.js#L83)
WETH Mainnet (Ethereum)
#### Type Declaration
##### chainId
> **chainId**: `number` = `1`
##### name
> **name**: `string` = `"Wrapped Ether"`
##### verifyingContract
> **verifyingContract**: [`AddressType`](../../Address.mdx#addresstype)
##### version
> **version**: `string` = `"1"`
# primitives/PrivateKey
Source: https://voltaire.tevm.sh/generated-api/primitives/PrivateKey
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PrivateKey
# primitives/PrivateKey
## Type Aliases
### PrivateKeyType
> **PrivateKeyType** = `Uint8Array` & `object`
Defined in: [src/primitives/PrivateKey/PrivateKeyType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/PrivateKeyType.ts#L7)
Branded PrivateKey type - 32 byte private key for cryptographic operations
Prevents accidental exposure or misuse of sensitive key material
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"PrivateKey"`
##### length
> `readonly` **length**: `32`
## Variables
### \_sign()
> `const` **\_sign**: (`privateKey`, `hash`) => [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
Defined in: [src/primitives/PrivateKey/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L25)
#### Parameters
##### privateKey
[`PrivateKeyType`](#privatekeytype)
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
***
### PrivateKey
> `const` **PrivateKey**: `object`
Defined in: [src/primitives/PrivateKey/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L51)
#### Type Declaration
##### from()
> **from**: (`hex`) => [`PrivateKeyType`](#privatekeytype)
Create PrivateKey from hex string
###### Parameters
###### hex
`string`
Hex string (32 bytes)
###### Returns
[`PrivateKeyType`](#privatekeytype)
Private key
###### Throws
If hex string format is invalid
###### Throws
If hex is not 32 bytes
###### Example
```typescript theme={null}
const pk = PrivateKey.from("0x1234...");
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`PrivateKeyType`](#privatekeytype)
Create PrivateKey from raw bytes
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 32 bytes)
###### Returns
[`PrivateKeyType`](#privatekeytype)
Private key
###### Throws
If bytes is not 32 bytes
###### Example
```javascript theme={null}
import * as PrivateKey from './primitives/PrivateKey/index.js';
const bytes = new Uint8Array(32);
const privateKey = PrivateKey.fromBytes(bytes);
```
##### sign()
> **sign**: (`privateKey`, `hash`) => [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
###### Parameters
###### privateKey
`string`
###### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Returns
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
##### toAddress()
> **toAddress**: (`privateKey`) => [`AddressType`](Address.mdx#addresstype)
###### Parameters
###### privateKey
`string`
###### Returns
[`AddressType`](Address.mdx#addresstype)
##### toHex()
> **toHex**: (`privateKey`) => `string`
###### Parameters
###### privateKey
`string`
###### Returns
`string`
##### toPublicKey()
> **toPublicKey**: (`privateKey`) => [`PublicKeyType`](PublicKey.mdx#publickeytype)
###### Parameters
###### privateKey
`string`
###### Returns
[`PublicKeyType`](PublicKey.mdx#publickeytype)
## Functions
### \_toAddress()
> **\_toAddress**(`this`): [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/PrivateKey/toAddress.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/toAddress.ts#L17)
Derive Ethereum address from private key
#### Parameters
##### this
[`PrivateKeyType`](#privatekeytype)
Private key
#### Returns
[`AddressType`](Address.mdx#addresstype)
Ethereum address (20 bytes)
#### Example
```typescript theme={null}
const address = PrivateKey._toAddress.call(pk);
```
***
### \_toHex()
> **\_toHex**(`this`): `string`
Defined in: [src/primitives/PrivateKey/toHex.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/toHex.ts#L14)
Convert PrivateKey to hex string
#### Parameters
##### this
[`PrivateKeyType`](#privatekeytype)
Private key
#### Returns
`string`
Hex string
#### Example
```typescript theme={null}
const hex = PrivateKey._toHex.call(pk);
```
***
### \_toPublicKey()
> **\_toPublicKey**(`this`): [`PublicKeyType`](PublicKey.mdx#publickeytype)
Defined in: [src/primitives/PrivateKey/toPublicKey.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/toPublicKey.ts#L16)
Derive public key from private key
#### Parameters
##### this
[`PrivateKeyType`](#privatekeytype)
Private key
#### Returns
[`PublicKeyType`](PublicKey.mdx#publickeytype)
Public key (uncompressed 64 bytes)
#### Example
```typescript theme={null}
const publicKey = PrivateKey._toPublicKey.call(pk);
```
***
### from()
> **from**(`hex`): [`PrivateKeyType`](#privatekeytype)
Defined in: [src/primitives/PrivateKey/from.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/from.ts#L22)
Create PrivateKey from hex string
#### Parameters
##### hex
`string`
Hex string (32 bytes)
#### Returns
[`PrivateKeyType`](#privatekeytype)
Private key
#### Throws
If hex string format is invalid
#### Throws
If hex is not 32 bytes
#### Example
```typescript theme={null}
const pk = PrivateKey.from("0x1234...");
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`PrivateKeyType`](#privatekeytype)
Defined in: [src/primitives/PrivateKey/fromBytes.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/fromBytes.js#L17)
Create PrivateKey from raw bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Raw bytes (must be 32 bytes)
#### Returns
[`PrivateKeyType`](#privatekeytype)
Private key
#### Throws
If bytes is not 32 bytes
#### Example
```javascript theme={null}
import * as PrivateKey from './primitives/PrivateKey/index.js';
const bytes = new Uint8Array(32);
const privateKey = PrivateKey.fromBytes(bytes);
```
***
### sign()
> **sign**(`privateKey`, `hash`): [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
Defined in: [src/primitives/PrivateKey/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L40)
#### Parameters
##### privateKey
`string`
##### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
***
### Sign()
> **Sign**(`deps`): (`privateKey`, `hash`) => [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
Defined in: [src/primitives/PrivateKey/sign.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/sign.js#L7)
Factory: Sign a message hash with private key
#### Parameters
##### deps
Crypto dependencies
###### secp256k1Sign
(`messageHash`, `privateKey`) => [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
Secp256k1 signing function
#### Returns
Function that creates ECDSA signature
> (`privateKey`, `hash`): [`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
##### Parameters
###### privateKey
[`PrivateKeyType`](#privatekeytype)
###### hash
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Returns
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
***
### toAddress()
> **toAddress**(`privateKey`): [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/PrivateKey/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L36)
#### Parameters
##### privateKey
`string`
#### Returns
[`AddressType`](Address.mdx#addresstype)
***
### toHex()
> **toHex**(`privateKey`): `string`
Defined in: [src/primitives/PrivateKey/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L28)
#### Parameters
##### privateKey
`string`
#### Returns
`string`
***
### toPublicKey()
> **toPublicKey**(`privateKey`): [`PublicKeyType`](PublicKey.mdx#publickeytype)
Defined in: [src/primitives/PrivateKey/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PrivateKey/index.ts#L32)
#### Parameters
##### privateKey
`string`
#### Returns
[`PublicKeyType`](PublicKey.mdx#publickeytype)
## References
### BrandedPrivateKey
Renames and re-exports [PrivateKeyType](#privatekeytype)
***
### default
Renames and re-exports [PrivateKey](#privatekey)
# primitives/Proof
Source: https://voltaire.tevm.sh/generated-api/primitives/Proof
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Proof
# primitives/Proof
## Type Aliases
### ProofLike
> **ProofLike** = [`ProofType`](#prooftype) | \{ `proof`: readonly `Uint8Array`\[]; `value`: `Uint8Array`; }
Defined in: [src/primitives/Proof/ProofType.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/ProofType.ts#L33)
Inputs that can be converted to Proof
***
### ProofType
> **ProofType** = `object`
Defined in: [src/primitives/Proof/ProofType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/ProofType.ts#L15)
Proof represents a generic Merkle proof for verifying inclusion in a Merkle tree.
A Merkle proof consists of:
* value: The leaf value being proven
* proof: An array of sibling hashes forming the path from leaf to root
To verify, you hash the value with each proof element in order, reconstructing
the path to the root hash. If the final hash matches the known root, the proof
is valid.
This generic structure is used as the basis for more specific proof types like
StateProof and StorageProof which follow the Ethereum Merkle Patricia Trie format.
#### Properties
##### proof
> `readonly` **proof**: readonly `Uint8Array`\[]
Defined in: [src/primitives/Proof/ProofType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/ProofType.ts#L27)
Array of sibling hashes forming the Merkle branch.
Each element is a node hash encountered on the path from leaf to root.
Order matters - typically bottom-up (leaf to root).
##### value
> `readonly` **value**: `Uint8Array`
Defined in: [src/primitives/Proof/ProofType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/ProofType.ts#L20)
The leaf value being proven for inclusion.
This is typically a hash or encoded data.
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Proof/equals.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/equals.js#L20)
Compares two Proofs for equality.
Both value and all proof elements must match.
#### Parameters
##### a
[`ProofType`](#prooftype)
First Proof
##### b
[`ProofType`](#prooftype)
Second Proof
#### Returns
`boolean`
* True if equal
#### Example
```typescript theme={null}
const isEqual = Proof.equals(proof1, proof2);
```
***
### from()
> **from**(`proof`): [`ProofType`](#prooftype)
Defined in: [src/primitives/Proof/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Proof/from.js#L22)
Creates a Proof from an object with value and proof array.
#### Parameters
##### proof
[`ProofLike`](#prooflike)
Object containing value and proof array
#### Returns
[`ProofType`](#prooftype)
* A validated Proof
#### Example
```typescript theme={null}
const proof = Proof.from({
value: leafValue,
proof: [hash1, hash2, hash3],
});
```
# primitives/ProtocolVersion
Source: https://voltaire.tevm.sh/generated-api/primitives/ProtocolVersion
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ProtocolVersion
# primitives/ProtocolVersion
## Type Aliases
### ProtocolVersionType
> **ProtocolVersionType** = `string` & `object`
Defined in: [src/primitives/ProtocolVersion/ProtocolVersionType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/ProtocolVersionType.ts#L14)
Branded ProtocolVersion type - Ethereum protocol version identifier
Wraps a string representing a protocol version (e.g., "eth/67", "eth/68")
Protocol versions identify the version of the Ethereum wire protocol
used for peer-to-peer communication:
* "eth/66" = ETH66 protocol
* "eth/67" = ETH67 protocol (current standard)
* "eth/68" = ETH68 protocol
* "snap/1" = Snapshot protocol
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ProtocolVersion"`
## Variables
### ETH\_66
> `const` **ETH\_66**: [`ProtocolVersionType`](#protocolversiontype)
Defined in: [src/primitives/ProtocolVersion/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/constants.js#L6)
***
### ETH\_67
> `const` **ETH\_67**: [`ProtocolVersionType`](#protocolversiontype)
Defined in: [src/primitives/ProtocolVersion/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/constants.js#L12)
***
### ETH\_68
> `const` **ETH\_68**: [`ProtocolVersionType`](#protocolversiontype)
Defined in: [src/primitives/ProtocolVersion/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/constants.js#L18)
***
### ProtocolVersion
> `const` **ProtocolVersion**: `object`
Defined in: [src/primitives/ProtocolVersion/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/index.ts#L40)
#### Type Declaration
##### compare()
> **compare**: (`protocolVersion1`, `protocolVersion2`) => `number`
###### Parameters
###### protocolVersion1
`string`
###### protocolVersion2
`string`
###### Returns
`number`
##### equals()
> **equals**: (`protocolVersion1`, `protocolVersion2`) => `boolean`
###### Parameters
###### protocolVersion1
`string`
###### protocolVersion2
`string`
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`ProtocolVersionType`](#protocolversiontype)
Create ProtocolVersion from string
###### Parameters
###### value
`string`
Protocol version string (e.g., "eth/67", "snap/1")
###### Returns
[`ProtocolVersionType`](#protocolversiontype)
Branded protocol version
###### Throws
If value is not a valid protocol version format
###### Example
```javascript theme={null}
import * as ProtocolVersion from './primitives/ProtocolVersion/index.js';
const eth67 = ProtocolVersion.from("eth/67");
const snap1 = ProtocolVersion.from("snap/1");
```
##### toString()
> **toString**: (`protocolVersion`) => `string`
###### Parameters
###### protocolVersion
`string`
###### Returns
`string`
***
### SNAP\_1
> `const` **SNAP\_1**: [`ProtocolVersionType`](#protocolversiontype)
Defined in: [src/primitives/ProtocolVersion/constants.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/constants.js#L24)
## Functions
### \_compare()
> **\_compare**(`this`, `other`): `number`
Defined in: [src/primitives/ProtocolVersion/compare.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/compare.js#L20)
Compare two ProtocolVersions for ordering
Returns negative if this \< other, positive if this > other, 0 if equal
Only compares versions within the same protocol family (e.g., eth/66 vs eth/67)
Returns 0 for different protocols
#### Parameters
##### this
[`ProtocolVersionType`](#protocolversiontype)
##### other
[`ProtocolVersionType`](#protocolversiontype)
Protocol version to compare
#### Returns
`number`
Comparison result (-1, 0, or 1)
#### Example
```javascript theme={null}
import * as ProtocolVersion from './primitives/ProtocolVersion/index.js';
const v66 = ProtocolVersion.from("eth/66");
const v67 = ProtocolVersion.from("eth/67");
const result = ProtocolVersion._compare.call(v66, v67); // -1
```
***
### \_equals()
> **\_equals**(`this`, `other`): `boolean`
Defined in: [src/primitives/ProtocolVersion/equals.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/equals.js#L16)
Compare two ProtocolVersions for equality
#### Parameters
##### this
[`ProtocolVersionType`](#protocolversiontype)
##### other
[`ProtocolVersionType`](#protocolversiontype)
Protocol version to compare
#### Returns
`boolean`
True if equal
#### Example
```javascript theme={null}
import * as ProtocolVersion from './primitives/ProtocolVersion/index.js';
const a = ProtocolVersion.from("eth/67");
const b = ProtocolVersion.from("eth/67");
const equal = ProtocolVersion._equals.call(a, b); // true
```
***
### \_toString()
> **\_toString**(`this`): `string`
Defined in: [src/primitives/ProtocolVersion/toString.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/toString.js#L15)
Convert ProtocolVersion to string (identity function for branded type)
#### Parameters
##### this
[`ProtocolVersionType`](#protocolversiontype)
#### Returns
`string`
Protocol version as string
#### Example
```javascript theme={null}
import * as ProtocolVersion from './primitives/ProtocolVersion/index.js';
const proto = ProtocolVersion.from("eth/67");
const str = ProtocolVersion._toString.call(proto); // "eth/67"
```
***
### compare()
> **compare**(`protocolVersion1`, `protocolVersion2`): `number`
Defined in: [src/primitives/ProtocolVersion/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/index.ts#L29)
#### Parameters
##### protocolVersion1
`string`
##### protocolVersion2
`string`
#### Returns
`number`
***
### equals()
> **equals**(`protocolVersion1`, `protocolVersion2`): `boolean`
Defined in: [src/primitives/ProtocolVersion/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/index.ts#L22)
#### Parameters
##### protocolVersion1
`string`
##### protocolVersion2
`string`
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`ProtocolVersionType`](#protocolversiontype)
Defined in: [src/primitives/ProtocolVersion/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/from.js#L17)
Create ProtocolVersion from string
#### Parameters
##### value
`string`
Protocol version string (e.g., "eth/67", "snap/1")
#### Returns
[`ProtocolVersionType`](#protocolversiontype)
Branded protocol version
#### Throws
If value is not a valid protocol version format
#### Example
```javascript theme={null}
import * as ProtocolVersion from './primitives/ProtocolVersion/index.js';
const eth67 = ProtocolVersion.from("eth/67");
const snap1 = ProtocolVersion.from("snap/1");
```
***
### toString()
> **toString**(`protocolVersion`): `string`
Defined in: [src/primitives/ProtocolVersion/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ProtocolVersion/index.ts#L18)
#### Parameters
##### protocolVersion
`string`
#### Returns
`string`
# primitives/PublicKey
Source: https://voltaire.tevm.sh/generated-api/primitives/PublicKey
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/PublicKey
# primitives/PublicKey
## Type Aliases
### PublicKeyType
> **PublicKeyType** = `Uint8Array` & `object`
Defined in: [src/primitives/PublicKey/PublicKeyType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/PublicKeyType.ts#L7)
PublicKey type - 64 byte uncompressed public key
Distinguishes from generic Hex/Uint8Array
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"PublicKey"`
##### length
> `readonly` **length**: `64`
## Variables
### \_verify()
> `const` **\_verify**: (`publicKey`, `hash`, `signature`) => `boolean`
Defined in: [src/primitives/PublicKey/index.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L25)
#### Parameters
##### publicKey
[`PublicKeyType`](#publickeytype)
##### hash
`HashType`
##### signature
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
#### Returns
`boolean`
***
### PublicKey
> `const` **PublicKey**: `object`
Defined in: [src/primitives/PublicKey/index.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L122)
#### Type Declaration
##### compress()
> **compress**: (`publicKey`) => `Uint8Array`
Compress a public key from 64 bytes (uncompressed) to 33 bytes (compressed)
Compressed format: prefix (1 byte) + x-coordinate (32 bytes)
Prefix is 0x02 if y is even, 0x03 if y is odd
Compressed keys are preferred for storage and transmission due to smaller size.
Uncompressed keys are needed by some legacy systems.
###### Parameters
###### publicKey
Public key (hex string or 64 bytes)
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### Returns
`Uint8Array`
Compressed public key (33 bytes)
###### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const compressed = PublicKey.compress("0x1234...");
console.log(compressed.length); // 33
```
##### decompress()
> **decompress**: (`compressed`) => [`PublicKeyType`](#publickeytype)
Decompress a public key from 33 bytes (compressed) to 64 bytes (uncompressed)
Solves the curve equation y² = x³ + 7 mod p and chooses y based on prefix parity.
###### Parameters
###### compressed
`Uint8Array`
Compressed public key (33 bytes with 0x02/0x03 prefix)
###### Returns
[`PublicKeyType`](#publickeytype)
Uncompressed public key (64 bytes)
###### Throws
If compressed format is invalid
###### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const uncompressed = PublicKey.decompress(compressed);
console.log(uncompressed.length); // 64
```
##### from()
> **from**: (`hex`) => [`PublicKeyType`](#publickeytype)
Create PublicKey from hex string
###### Parameters
###### hex
`string`
Hex string (64 bytes uncompressed)
###### Returns
[`PublicKeyType`](#publickeytype)
Public key
###### Throws
If hex string format is invalid
###### Throws
If hex is not 64 bytes
###### Example
```typescript theme={null}
const pk = PublicKey.from("0x1234...");
```
##### fromPrivateKey()
> **fromPrivateKey**: (`privateKey`) => [`PublicKeyType`](#publickeytype)
Derive public key from private key
###### Parameters
###### privateKey
[`PrivateKeyType`](PrivateKey.mdx#privatekeytype)
Private key
###### Returns
[`PublicKeyType`](#publickeytype)
Public key (64 bytes uncompressed)
###### Example
```typescript theme={null}
const publicKey = PublicKey.fromPrivateKey(pk);
```
##### isCompressed()
> **isCompressed**: (`bytes`) => `boolean`
Check if a public key is in compressed format
Returns true for 33 bytes with 0x02/0x03 prefix, false otherwise
###### Parameters
###### bytes
`Uint8Array`
Public key bytes
###### Returns
`boolean`
True if compressed format
###### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const isComp = PublicKey.isCompressed(bytes);
```
##### toAddress()
> **toAddress**: (`publicKey`) => [`AddressType`](Address.mdx#addresstype)
###### Parameters
###### publicKey
`string`
###### Returns
[`AddressType`](Address.mdx#addresstype)
##### toHex()
> **toHex**: (`publicKey`) => `string`
###### Parameters
###### publicKey
`string`
###### Returns
`string`
##### verify()
> **verify**: (`publicKey`, `hash`, `signature`) => `boolean`
###### Parameters
###### publicKey
`string`
###### hash
`HashType`
###### signature
[`SignatureType`](Signature.mdx#signaturetype)
###### Returns
`boolean`
## Functions
### \_compress()
> **\_compress**(`publicKey`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/PublicKey/compress.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/compress.js#L16)
Compress a public key from 64 bytes (uncompressed) to 33 bytes (compressed)
Compressed format: prefix (1 byte) + x-coordinate (32 bytes)
Prefix is 0x02 if y is even, 0x03 if y is odd
#### Parameters
##### publicKey
[`PublicKeyType`](#publickeytype)
Uncompressed public key (64 bytes)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compressed public key (33 bytes)
#### Example
```javascript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const compressed = PublicKey._compress(publicKey);
```
***
### \_decompress()
> **\_decompress**(`compressed`): [`PublicKeyType`](#publickeytype)
Defined in: [src/primitives/PublicKey/decompress.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/decompress.js#L16)
Decompress a public key from 33 bytes (compressed) to 64 bytes (uncompressed)
Solves y² = x³ + 7 mod p and chooses y based on prefix parity
#### Parameters
##### compressed
`Uint8Array`\<`ArrayBufferLike`>
Compressed public key (33 bytes with 0x02/0x03 prefix)
#### Returns
[`PublicKeyType`](#publickeytype)
Uncompressed public key (64 bytes)
#### Throws
If compressed format is invalid
#### Example
```javascript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const uncompressed = PublicKey._decompress(compressed);
```
***
### \_isCompressed()
> **\_isCompressed**(`bytes`): `boolean`
Defined in: [src/primitives/PublicKey/isCompressed.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/isCompressed.js#L15)
Check if a public key is in compressed format
Returns true for 33 bytes with 0x02/0x03 prefix, false otherwise
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Public key bytes
#### Returns
`boolean`
True if compressed format
#### Example
```javascript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const isCompressed = PublicKey._isCompressed(bytes);
```
***
### \_toAddress()
> **\_toAddress**(`this`): [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/PublicKey/toAddress.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/toAddress.ts#L16)
Derive Ethereum address from public key
#### Parameters
##### this
[`PublicKeyType`](#publickeytype)
Public key
#### Returns
[`AddressType`](Address.mdx#addresstype)
Ethereum address (20 bytes)
#### Example
```typescript theme={null}
const address = PublicKey._toAddress.call(pk);
```
***
### \_toHex()
> **\_toHex**(`this`): `string`
Defined in: [src/primitives/PublicKey/toHex.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/toHex.ts#L14)
Convert PublicKey to hex string
#### Parameters
##### this
[`PublicKeyType`](#publickeytype)
Public key
#### Returns
`string`
Hex string
#### Example
```typescript theme={null}
const hex = PublicKey._toHex.call(pk);
```
***
### compress()
> **compress**(`publicKey`): `Uint8Array`
Defined in: [src/primitives/PublicKey/index.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L68)
Compress a public key from 64 bytes (uncompressed) to 33 bytes (compressed)
Compressed format: prefix (1 byte) + x-coordinate (32 bytes)
Prefix is 0x02 if y is even, 0x03 if y is odd
Compressed keys are preferred for storage and transmission due to smaller size.
Uncompressed keys are needed by some legacy systems.
#### Parameters
##### publicKey
Public key (hex string or 64 bytes)
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
`Uint8Array`
Compressed public key (33 bytes)
#### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const compressed = PublicKey.compress("0x1234...");
console.log(compressed.length); // 33
```
***
### decompress()
> **decompress**(`compressed`): [`PublicKeyType`](#publickeytype)
Defined in: [src/primitives/PublicKey/index.ts:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L93)
Decompress a public key from 33 bytes (compressed) to 64 bytes (uncompressed)
Solves the curve equation y² = x³ + 7 mod p and chooses y based on prefix parity.
#### Parameters
##### compressed
`Uint8Array`
Compressed public key (33 bytes with 0x02/0x03 prefix)
#### Returns
[`PublicKeyType`](#publickeytype)
Uncompressed public key (64 bytes)
#### Throws
If compressed format is invalid
#### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const uncompressed = PublicKey.decompress(compressed);
console.log(uncompressed.length); // 64
```
***
### from()
> **from**(`hex`): [`PublicKeyType`](#publickeytype)
Defined in: [src/primitives/PublicKey/from.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/from.ts#L22)
Create PublicKey from hex string
#### Parameters
##### hex
`string`
Hex string (64 bytes uncompressed)
#### Returns
[`PublicKeyType`](#publickeytype)
Public key
#### Throws
If hex string format is invalid
#### Throws
If hex is not 64 bytes
#### Example
```typescript theme={null}
const pk = PublicKey.from("0x1234...");
```
***
### fromPrivateKey()
> **fromPrivateKey**(`privateKey`): [`PublicKeyType`](#publickeytype)
Defined in: [src/primitives/PublicKey/fromPrivateKey.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/fromPrivateKey.ts#L16)
Derive public key from private key
#### Parameters
##### privateKey
[`PrivateKeyType`](PrivateKey.mdx#privatekeytype)
Private key
#### Returns
[`PublicKeyType`](#publickeytype)
Public key (64 bytes uncompressed)
#### Example
```typescript theme={null}
const publicKey = PublicKey.fromPrivateKey(pk);
```
***
### isCompressed()
> **isCompressed**(`bytes`): `boolean`
Defined in: [src/primitives/PublicKey/index.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L114)
Check if a public key is in compressed format
Returns true for 33 bytes with 0x02/0x03 prefix, false otherwise
#### Parameters
##### bytes
`Uint8Array`
Public key bytes
#### Returns
`boolean`
True if compressed format
#### Example
```typescript theme={null}
import * as PublicKey from './primitives/PublicKey/index.js';
const isComp = PublicKey.isCompressed(bytes);
```
***
### toAddress()
> **toAddress**(`publicKey`): [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/PublicKey/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L32)
#### Parameters
##### publicKey
`string`
#### Returns
[`AddressType`](Address.mdx#addresstype)
***
### toHex()
> **toHex**(`publicKey`): `string`
Defined in: [src/primitives/PublicKey/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L28)
#### Parameters
##### publicKey
`string`
#### Returns
`string`
***
### verify()
> **verify**(`publicKey`, `hash`, `signature`): `boolean`
Defined in: [src/primitives/PublicKey/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/index.ts#L36)
#### Parameters
##### publicKey
`string`
##### hash
`HashType`
##### signature
[`SignatureType`](Signature.mdx#signaturetype)
#### Returns
`boolean`
***
### Verify()
> **Verify**(`deps`): (`publicKey`, `hash`, `signature`) => `boolean`
Defined in: [src/primitives/PublicKey/verify.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/PublicKey/verify.js#L7)
Factory: Verify signature against public key
#### Parameters
##### deps
Crypto dependencies
###### secp256k1Verify
(`signature`, `hash`, `publicKey`) => `boolean`
Secp256k1 signature verification function (expects 64-byte public key)
#### Returns
Function that verifies ECDSA signature
> (`publicKey`, `hash`, `signature`): `boolean`
##### Parameters
###### publicKey
[`PublicKeyType`](#publickeytype)
###### hash
`HashType`
###### signature
[`Secp256k1SignatureType`](../crypto/Secp256k1.mdx#secp256k1signaturetype)
##### Returns
`boolean`
# primitives/Receipt
Source: https://voltaire.tevm.sh/generated-api/primitives/Receipt
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Receipt
# primitives/Receipt
## Classes
### InvalidReceiptError
Defined in: [src/primitives/Receipt/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidReceiptError**(`message`, `details?`): [`InvalidReceiptError`](#invalidreceipterror)
Defined in: [src/primitives/Receipt/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/errors.js#L9)
###### Parameters
###### message
`string`
###### details?
###### context?
`Record`\<`string`, `unknown`>
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidReceiptError`](#invalidreceipterror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `context?`: `Record`\<`string`, `unknown`>; `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/Receipt/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/errors.js#L13)
##### name
> **name**: `string`
Defined in: [src/primitives/Receipt/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### ReceiptType
> **ReceiptType** = `object` & `object`
Defined in: [src/primitives/Receipt/ReceiptType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/ReceiptType.ts#L15)
Transaction receipt
#### Type Declaration
##### blobGasPrice?
> `readonly` `optional` **blobGasPrice**: [`Type`](Uint.mdx#type)
Blob gas price (EIP-4844)
##### blobGasUsed?
> `readonly` `optional` **blobGasUsed**: [`Type`](Uint.mdx#type)
Blob gas used (EIP-4844)
##### blockHash
> `readonly` **blockHash**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Block hash
##### blockNumber
> `readonly` **blockNumber**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Block number
##### contractAddress
> `readonly` **contractAddress**: [`AddressType`](Address.mdx#addresstype) | `null`
Contract address (non-null for creation)
##### cumulativeGasUsed
> `readonly` **cumulativeGasUsed**: [`Type`](Uint.mdx#type)
Cumulative gas used in block
##### effectiveGasPrice
> `readonly` **effectiveGasPrice**: [`Type`](Uint.mdx#type)
Effective gas price
##### from
> `readonly` **from**: [`AddressType`](Address.mdx#addresstype)
Sender address
##### gasUsed
> `readonly` **gasUsed**: [`Type`](Uint.mdx#type)
Gas used by this transaction
##### logs
> `readonly` **logs**: readonly [`EventLogType`](EventLog.mdx#eventlogtype)\[]
Event logs
##### logsBloom
> `readonly` **logsBloom**: `Uint8Array`
Logs bloom filter (256 bytes)
##### root?
> `readonly` `optional` **root**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
State root (pre-Byzantium only)
##### status?
> `readonly` `optional` **status**: [`TransactionStatusType`](TransactionStatus.mdx#transactionstatustype)
Transaction status (post-Byzantium)
##### to
> `readonly` **to**: [`AddressType`](Address.mdx#addresstype) | `null`
Recipient address (null for contract creation)
##### transactionHash
> `readonly` **transactionHash**: [`TransactionHashType`](TransactionHash.mdx#transactionhashtype)
Transaction hash
##### transactionIndex
> `readonly` **transactionIndex**: [`TransactionIndexType`](TransactionIndex.mdx#transactionindextype)
Transaction index in block
##### type
> `readonly` **type**: `"legacy"` | `"eip2930"` | `"eip1559"` | `"eip4844"` | `"eip7702"`
Transaction type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Receipt"`
## Variables
### from()
> `const` **from**: (`data`) => [`ReceiptType`](#receipttype) = `_from`
Defined in: [src/primitives/Receipt/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/index.ts#L10)
Create Receipt from partial data
#### Parameters
##### data
`Omit`\<[`ReceiptType`](#receipttype), *typeof* `brand`>
#### Returns
[`ReceiptType`](#receipttype)
#### Throws
***
### poll()
> `const` **poll**: (`txHash`, `provider`, `options?`) => `Promise`\<[`ReceiptType`](#receipttype)> = `_poll`
Defined in: [src/primitives/Receipt/index.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/index.ts#L38)
Poll for a transaction receipt until confirmed
#### Parameters
##### txHash
`string`
Transaction hash to poll for
##### provider
EIP-1193 provider
###### request
##### options?
Polling options (interval, timeout, confirmations)
###### confirmations?
`number`
###### interval?
`number`
###### timeout?
`number`
#### Returns
`Promise`\<[`ReceiptType`](#receipttype)>
Promise resolving to the transaction receipt
#### Example
```typescript theme={null}
import { Receipt } from '@tevm/voltaire';
const receipt = await Receipt.poll(txHash, provider, {
timeout: 120000,
confirmations: 3
});
```
## Functions
### \_assertValid()
> **\_assertValid**(`receipt`): `void`
Defined in: [src/primitives/Receipt/assertValid.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/assertValid.js#L18)
Validate receipt structure (Byzantium vs pre-Byzantium)
#### Parameters
##### receipt
[`ReceiptType`](#receipttype)
Receipt to validate
#### Returns
`void`
#### Throws
If receipt has both status and root, or neither
#### Example
```javascript theme={null}
import { assertValid } from './primitives/Receipt/assertValid.js';
// Post-Byzantium (has status)
assertValid({ ...receipt, status: 1 });
// Pre-Byzantium (has root)
assertValid({ ...receipt, root: stateRoot });
```
***
### \_isPreByzantium()
> **\_isPreByzantium**(`receipt`): `boolean`
Defined in: [src/primitives/Receipt/isPreByzantium.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/isPreByzantium.js#L18)
Check if receipt is pre-Byzantium (uses state root instead of status)
#### Parameters
##### receipt
[`ReceiptType`](#receipttype)
Receipt to check
#### Returns
`boolean`
True if receipt is pre-Byzantium
#### Example
```javascript theme={null}
import { isPreByzantium } from './primitives/Receipt/isPreByzantium.js';
// Pre-Byzantium receipt (has root)
isPreByzantium({ ...receipt, root: stateRoot }); // true
// Post-Byzantium receipt (has status)
isPreByzantium({ ...receipt, status: 1 }); // false
```
***
### \_poll()
> **\_poll**(`txHash`, `provider`, `options?`): `Promise`\<[`ReceiptType`](#receipttype)>
Defined in: [src/primitives/Receipt/poll.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/poll.js#L45)
Poll for a transaction receipt until it's available
Uses exponential backoff and handles transient RPC errors gracefully.
#### Parameters
##### txHash
`string`
Transaction hash to poll for
##### provider
EIP-1193 provider
###### request
##### options?
`PollReceiptOptions` = `{}`
Polling options
#### Returns
`Promise`\<[`ReceiptType`](#receipttype)>
Transaction receipt
#### Throws
If timeout is reached before receipt is available
#### Example
```typescript theme={null}
import { poll } from '@tevm/voltaire/Receipt';
// Wait for transaction confirmation
const receipt = await poll(txHash, provider);
console.log(`Status: ${receipt.status}`);
// With custom options
const receipt = await poll(txHash, provider, {
interval: 2000, // Poll every 2s
timeout: 120000, // Wait up to 2 minutes
confirmations: 3 // Wait for 3 confirmations
});
```
***
### assertValid()
> **assertValid**(`receipt`): `void`
Defined in: [src/primitives/Receipt/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/index.ts#L12)
#### Parameters
##### receipt
[`ReceiptType`](#receipttype)
#### Returns
`void`
***
### isPreByzantium()
> **isPreByzantium**(`receipt`): `boolean`
Defined in: [src/primitives/Receipt/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Receipt/index.ts#L16)
#### Parameters
##### receipt
[`ReceiptType`](#receipttype)
#### Returns
`boolean`
## References
### TransactionReceiptType
Renames and re-exports [ReceiptType](#receipttype)
# primitives/RelayData
Source: https://voltaire.tevm.sh/generated-api/primitives/RelayData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/RelayData
# primitives/RelayData
## Classes
### InvalidRelayDataError
Defined in: [src/primitives/RelayData/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/errors.js#L6)
Error thrown when RelayData operations fail
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidRelayDataError**(`message`, `details`): [`InvalidRelayDataError`](#invalidrelaydataerror)
Defined in: [src/primitives/RelayData/errors.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/errors.js#L7)
###### Parameters
###### message
`any`
###### details
`any`
###### Returns
[`InvalidRelayDataError`](#invalidrelaydataerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `any`
Defined in: [src/primitives/RelayData/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/errors.js#L10)
##### name
> **name**: `string`
Defined in: [src/primitives/RelayData/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/errors.js#L9)
###### Inherited from
`Error.name`
## Type Aliases
### RelayDataLike
> **RelayDataLike** = [`RelayDataType`](#relaydatatype) | \{ `builderPubkey?`: `Uint8Array` | `string`; `parentHash`: [`HashType`](../index/namespaces/HashType.mdx#hashtype) | `string` | `Uint8Array`; `proposerFeeRecipient`: [`AddressType`](Address.mdx#addresstype) | `string`; `relayPubkey`: `Uint8Array` | `string`; `relayUrl`: `string`; `slot`: [`SlotType`](Slot.mdx#slottype) | `bigint` | `number` | `string`; }
Defined in: [src/primitives/RelayData/RelayDataType.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L58)
Inputs that can be converted to RelayData
***
### RelayDataType
> **RelayDataType** = `object`
Defined in: [src/primitives/RelayData/RelayDataType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L17)
RelayData type
Represents MEV relay connection information for Proposer-Builder Separation (PBS).
Relays act as trusted intermediaries between block builders and validators,
ensuring builders cannot see validator signatures before block delivery.
#### See
* [https://voltaire.tevm.sh/primitives/relay-data](https://voltaire.tevm.sh/primitives/relay-data) for RelayData documentation
* [https://boost.flashbots.net/](https://boost.flashbots.net/) for MEV-Boost
* [https://ethereum.org/en/roadmap/pbs/](https://ethereum.org/en/roadmap/pbs/) for PBS overview
#### Since
0.0.0
#### Properties
##### builderPubkey?
> `readonly` `optional` **builderPubkey**: `Uint8Array`
Defined in: [src/primitives/RelayData/RelayDataType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L34)
Builder's BLS public key (48 bytes, optional)
If known, used to verify builder identity
##### parentHash
> `readonly` **parentHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/RelayData/RelayDataType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L46)
Parent block hash (32 bytes)
The block being built on top of
##### proposerFeeRecipient
> `readonly` **proposerFeeRecipient**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/RelayData/RelayDataType.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L52)
Validator fee recipient address (20 bytes)
Where block rewards should be sent
##### relayPubkey
> `readonly` **relayPubkey**: `Uint8Array`
Defined in: [src/primitives/RelayData/RelayDataType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L28)
Relay's BLS public key (48 bytes)
Used to verify relay signatures and attestations
##### relayUrl
> `readonly` **relayUrl**: `string`
Defined in: [src/primitives/RelayData/RelayDataType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L22)
MEV relay endpoint URL
Base URL for relay API (e.g., "[https://relay.flashbots.net](https://relay.flashbots.net)")
##### slot
> `readonly` **slot**: [`SlotType`](Slot.mdx#slottype)
Defined in: [src/primitives/RelayData/RelayDataType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L40)
Current consensus layer slot
The slot this relay data is valid for
## Variables
### MEV\_RELAYS
> `const` **MEV\_RELAYS**: `object`
Defined in: [src/primitives/RelayData/RelayDataType.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/RelayDataType.ts#L72)
Well-known MEV relay endpoints
#### Type Declaration
##### AGNOSTIC
> `readonly` **AGNOSTIC**: `"https://agnostic-relay.net"`
##### BLOXROUTE\_MAX\_PROFIT
> `readonly` **BLOXROUTE\_MAX\_PROFIT**: `"https://bloxroute.max-profit.bloxroute.com"`
##### BLOXROUTE\_REGULATED
> `readonly` **BLOXROUTE\_REGULATED**: `"https://bloxroute.regulated.bloxroute.com"`
##### EDEN
> `readonly` **EDEN**: `"https://relay.edennetwork.io"`
##### FLASHBOTS
> `readonly` **FLASHBOTS**: `"https://relay.flashbots.net"`
##### MANIFOLD
> `readonly` **MANIFOLD**: `"https://mainnet-relay.securerpc.com"`
##### ULTRASOUND
> `readonly` **ULTRASOUND**: `"https://relay.ultrasound.money"`
## Functions
### from()
> **from**(`value`): [`RelayDataType`](#relaydatatype)
Defined in: [src/primitives/RelayData/from.js:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/from.js#L68)
Creates RelayData from various input types
#### Parameters
##### value
[`RelayDataLike`](#relaydatalike)
RelayData input
#### Returns
[`RelayDataType`](#relaydatatype)
RelayData instance
#### Throws
If format is invalid
#### Example
```typescript theme={null}
import * as RelayData from './RelayData/index.js';
const relay = RelayData.from({
relayUrl: "https://relay.flashbots.net",
relayPubkey: relayKey,
slot: 123456n,
parentHash: parentHash,
proposerFeeRecipient: feeRecipient,
});
```
***
### getEndpoint()
> **getEndpoint**(`relay`, `method`): `string`
Defined in: [src/primitives/RelayData/getEndpoint.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RelayData/getEndpoint.js#L20)
Constructs API endpoint for a specific relay method
#### Parameters
##### relay
[`RelayDataType`](#relaydatatype)
RelayData instance
##### method
`string`
API method path (e.g., "/eth/v1/builder/header")
#### Returns
`string`
Full endpoint URL
#### Example
```typescript theme={null}
import * as RelayData from './RelayData/index.js';
const url = RelayData.getEndpoint(relay, "/eth/v1/builder/header");
console.log(url); // "https://relay.flashbots.net/eth/v1/builder/header"
```
# primitives/ReturnData
Source: https://voltaire.tevm.sh/generated-api/primitives/ReturnData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ReturnData
# primitives/ReturnData
## Classes
### InvalidHexFormatError
Defined in: [src/primitives/ReturnData/errors.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/errors.ts#L6)
Error thrown when hex string format is invalid
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new InvalidHexFormatError**(`message`, `context?`): [`InvalidHexFormatError`](#invalidhexformaterror)
Defined in: [src/primitives/ReturnData/errors.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/errors.ts#L7)
###### Parameters
###### message
`string`
###### context?
`Record`\<`string`, `unknown`>
###### Returns
[`InvalidHexFormatError`](#invalidhexformaterror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
***
### InvalidValueError
Defined in: [src/primitives/ReturnData/errors.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/errors.ts#L16)
Error thrown when value type is unsupported
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new InvalidValueError**(`message`, `context?`): [`InvalidValueError`](#invalidvalueerror)
Defined in: [src/primitives/ReturnData/errors.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/errors.ts#L17)
###### Parameters
###### message
`string`
###### context?
`Record`\<`string`, `unknown`>
###### Returns
[`InvalidValueError`](#invalidvalueerror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Type Aliases
### ReturnDataType
> **ReturnDataType** = `Uint8Array` & `object`
Defined in: [src/primitives/ReturnData/ReturnDataType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/ReturnDataType.ts#L9)
ReturnData - Raw bytes returned from contract call
Branded Uint8Array representing uninterpreted return data from
contract execution. Can be decoded using ABI specifications.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ReturnData"`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ReturnData/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/equals.js#L13)
Check if two ReturnData instances are equal
#### Parameters
##### a
[`ReturnDataType`](#returndatatype)
First ReturnData
##### b
[`ReturnDataType`](#returndatatype)
Second ReturnData
#### Returns
`boolean`
True if equal
#### Example
```typescript theme={null}
const isEqual = ReturnData.equals(data1, data2);
```
***
### \_from()
> **\_from**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/from.js#L19)
Create ReturnData from various input types
#### Parameters
##### value
Hex string or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`ReturnDataType`](#returndatatype)
ReturnData
#### Throws
If value type is unsupported
#### Throws
If hex string is invalid
#### Example
```typescript theme={null}
const data1 = ReturnData.from("0x0000...");
const data2 = ReturnData.from(new Uint8Array([0, 0, ...]));
```
***
### \_fromBytes()
> **\_fromBytes**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/fromBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/fromBytes.js#L12)
Create ReturnData from Uint8Array (zero-copy cast)
#### Parameters
##### value
`Uint8Array`\<`ArrayBufferLike`>
Byte array
#### Returns
[`ReturnDataType`](#returndatatype)
ReturnData
#### Example
```typescript theme={null}
const data = ReturnData.fromBytes(new Uint8Array([0, 0, 0, 1]));
```
***
### \_fromHex()
> **\_fromHex**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/fromHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/fromHex.js#L16)
Create ReturnData from hex string
#### Parameters
##### value
`string`
Hex string (with or without 0x prefix)
#### Returns
[`ReturnDataType`](#returndatatype)
ReturnData
#### Throws
If hex string is invalid
#### Example
```typescript theme={null}
const data = ReturnData.fromHex("0x00000001");
```
***
### \_isEmpty()
> **\_isEmpty**(`data`): `boolean`
Defined in: [src/primitives/ReturnData/isEmpty.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/isEmpty.js#L12)
Check if ReturnData is empty
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
ReturnData
#### Returns
`boolean`
True if empty
#### Example
```typescript theme={null}
const empty = ReturnData.isEmpty(data);
```
***
### \_toBytes()
> **\_toBytes**(`data`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/ReturnData/toBytes.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/toBytes.js#L12)
Convert ReturnData to plain Uint8Array
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
ReturnData
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Plain byte array
#### Example
```typescript theme={null}
const bytes = ReturnData.toBytes(data);
```
***
### \_toHex()
> **\_toHex**(`data`): `string`
Defined in: [src/primitives/ReturnData/toHex.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/toHex.js#L14)
Convert ReturnData to hex string
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
ReturnData
#### Returns
`string`
Hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = ReturnData.toHex(data); // "0x00000001"
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ReturnData/index.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L51)
Check if two ReturnData instances are equal
#### Parameters
##### a
[`ReturnDataType`](#returndatatype)
##### b
[`ReturnDataType`](#returndatatype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L16)
Create ReturnData from various input types
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`ReturnDataType`](#returndatatype)
***
### fromBytes()
> **fromBytes**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L30)
Create ReturnData from Uint8Array
#### Parameters
##### value
`Uint8Array`
#### Returns
[`ReturnDataType`](#returndatatype)
***
### fromHex()
> **fromHex**(`value`): [`ReturnDataType`](#returndatatype)
Defined in: [src/primitives/ReturnData/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L23)
Create ReturnData from hex string
#### Parameters
##### value
`string`
#### Returns
[`ReturnDataType`](#returndatatype)
***
### isEmpty()
> **isEmpty**(`data`): `boolean`
Defined in: [src/primitives/ReturnData/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L58)
Check if ReturnData is empty
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
#### Returns
`boolean`
***
### toBytes()
> **toBytes**(`data`): `Uint8Array`
Defined in: [src/primitives/ReturnData/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L44)
Convert ReturnData to plain Uint8Array
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
#### Returns
`Uint8Array`
***
### toHex()
> **toHex**(`data`): `string`
Defined in: [src/primitives/ReturnData/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ReturnData/index.ts#L37)
Convert ReturnData to hex string
#### Parameters
##### data
[`ReturnDataType`](#returndatatype)
#### Returns
`string`
# primitives/RevertReason
Source: https://voltaire.tevm.sh/generated-api/primitives/RevertReason
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/RevertReason
# primitives/RevertReason
## Type Aliases
### CustomRevertReason
> **CustomRevertReason** = `object`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L31)
Custom error with selector and data
#### Properties
##### data
> `readonly` **data**: `Uint8Array`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L34)
##### selector
> `readonly` **selector**: `string`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L33)
##### type
> `readonly` **type**: `"Custom"`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L32)
***
### ErrorRevertReason
> **ErrorRevertReason** = `object`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L14)
Standard Error(string) revert
#### Properties
##### message
> `readonly` **message**: `string`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L16)
##### type
> `readonly` **type**: `"Error"`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L15)
***
### PanicCode
> **PanicCode** = keyof *typeof* [`PANIC_CODES`](#panic_codes)
Defined in: [src/primitives/RevertReason/constants.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/constants.ts#L23)
***
### PanicRevertReason
> **PanicRevertReason** = `object`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L22)
Solidity 0.8+ Panic(uint256) revert
#### Properties
##### code
> `readonly` **code**: `number`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L24)
##### description
> `readonly` **description**: `string`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L25)
##### type
> `readonly` **type**: `"Panic"`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L23)
***
### RevertReasonType
> **RevertReasonType** = [`ErrorRevertReason`](#errorrevertreason) | [`PanicRevertReason`](#panicrevertreason) | [`CustomRevertReason`](#customrevertreason) | [`UnknownRevertReason`](#unknownrevertreason)
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L48)
RevertReason union type
***
### UnknownRevertReason
> **UnknownRevertReason** = `object`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L40)
Unknown/unrecognized revert
#### Properties
##### data
> `readonly` **data**: `Uint8Array`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L42)
##### type
> `readonly` **type**: `"Unknown"`
Defined in: [src/primitives/RevertReason/RevertReasonType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/RevertReasonType.ts#L41)
## Variables
### ERROR\_SELECTOR
> `const` **ERROR\_SELECTOR**: `"0x08c379a0"` = `"0x08c379a0"`
Defined in: [src/primitives/RevertReason/constants.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/constants.ts#L4)
Standard error selectors
***
### PANIC\_CODES
> `const` **PANIC\_CODES**: `object`
Defined in: [src/primitives/RevertReason/constants.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/constants.ts#L10)
Solidity 0.8+ panic codes
#### Type Declaration
##### 0
> `readonly` **0**: `"Generic panic"` = `"Generic panic"`
##### 1
> `readonly` **1**: `"Assertion failed"` = `"Assertion failed"`
##### 17
> `readonly` **17**: `"Arithmetic overflow/underflow"` = `"Arithmetic overflow/underflow"`
##### 18
> `readonly` **18**: `"Division by zero"` = `"Division by zero"`
##### 33
> `readonly` **33**: `"Invalid enum value"` = `"Invalid enum value"`
##### 34
> `readonly` **34**: `"Invalid storage encoding"` = `"Invalid storage encoding"`
##### 49
> `readonly` **49**: `"Array pop on empty array"` = `"Array pop on empty array"`
##### 50
> `readonly` **50**: `"Array out of bounds"` = `"Array out of bounds"`
##### 65
> `readonly` **65**: `"Out of memory"` = `"Out of memory"`
##### 81
> `readonly` **81**: `"Invalid internal function"` = `"Invalid internal function"`
***
### PANIC\_SELECTOR
> `const` **PANIC\_SELECTOR**: `"0x4e487b71"` = `"0x4e487b71"`
Defined in: [src/primitives/RevertReason/constants.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/constants.ts#L5)
## Functions
### \_from()
> **\_from**(`value`): [`RevertReasonType`](#revertreasontype)
Defined in: [src/primitives/RevertReason/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/from.js#L15)
Create RevertReason from various inputs
#### Parameters
##### value
Return data
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`RevertReasonType`](#revertreasontype)
Decoded revert reason
#### Example
```typescript theme={null}
const reason = RevertReason.from("0x08c379a0...");
```
***
### \_fromReturnData()
> **\_fromReturnData**(`returnData`): [`RevertReasonType`](#revertreasontype)
Defined in: [src/primitives/RevertReason/fromReturnData.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/fromReturnData.js#L24)
Decode RevertReason from ReturnData
#### Parameters
##### returnData
[`ReturnDataType`](ReturnData.mdx#returndatatype)
Return data from failed call
#### Returns
[`RevertReasonType`](#revertreasontype)
Decoded revert reason
#### Example
```typescript theme={null}
const returnData = ReturnData.fromHex("0x08c379a0...");
const reason = RevertReason.fromReturnData(returnData);
if (reason.type === "Error") {
console.log(reason.message);
}
```
***
### \_toString()
> **\_toString**(`reason`): `string`
Defined in: [src/primitives/RevertReason/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/toString.js#L17)
Convert RevertReason to string representation
#### Parameters
##### reason
[`RevertReasonType`](#revertreasontype)
Revert reason
#### Returns
`string`
String representation
#### Example
```typescript theme={null}
const str = RevertReason.toString(reason);
// "Error: Insufficient balance"
// "Panic(0x11): Arithmetic overflow/underflow"
```
***
### from()
> **from**(`value`): [`RevertReasonType`](#revertreasontype)
Defined in: [src/primitives/RevertReason/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/index.ts#L19)
Create RevertReason from various inputs
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`RevertReasonType`](#revertreasontype)
***
### fromReturnData()
> **fromReturnData**(`returnData`): [`RevertReasonType`](#revertreasontype)
Defined in: [src/primitives/RevertReason/index.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/index.ts#L28)
Decode RevertReason from ReturnData
#### Parameters
##### returnData
[`ReturnDataType`](ReturnData.mdx#returndatatype)
#### Returns
[`RevertReasonType`](#revertreasontype)
***
### getPanicDescription()
> **getPanicDescription**(`code`): `string`
Defined in: [src/primitives/RevertReason/constants.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/constants.ts#L28)
Get panic code description
#### Parameters
##### code
`number`
#### Returns
`string`
***
### toString()
> **toString**(`reason`): `string`
Defined in: [src/primitives/RevertReason/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RevertReason/index.ts#L36)
Convert RevertReason to string representation
#### Parameters
##### reason
[`RevertReasonType`](#revertreasontype)
#### Returns
`string`
# primitives/Rlp
Source: https://voltaire.tevm.sh/generated-api/primitives/Rlp
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Rlp
# primitives/Rlp
## Classes
### Error
Defined in: [src/primitives/Rlp/errors.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L6)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new Error**(`type`, `message?`): [`Error`](#error)
Defined in: [src/primitives/Rlp/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L11)
###### Parameters
###### type
[`ErrorType`](#errortype-1)
###### message?
`string`
###### Returns
[`Error`](#error)
###### Overrides
`globalThis.Error.constructor`
#### Properties
##### name
> **name**: `string`
Defined in: [src/primitives/Rlp/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L13)
###### Inherited from
`globalThis.Error.name`
##### type
> **type**: [`ErrorType`](#errortype-1)
Defined in: [src/primitives/Rlp/errors.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L14)
## Type Aliases
### BrandedRlp
> **BrandedRlp** = \{ `type`: `"bytes"`; `value`: `Uint8Array`; } | \{ `type`: `"list"`; `value`: [`BrandedRlp`](#brandedrlp)\[]; }
Defined in: [src/primitives/Rlp/RlpType.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/RlpType.ts#L4)
Branded RLP data type
***
### Encodable
> **Encodable** = `Uint8Array` | [`BrandedRlp`](#brandedrlp) | [`Encodable`](#encodable)\[]
Defined in: [src/primitives/Rlp/RlpType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/RlpType.ts#L11)
Type that can be RLP-encoded
***
### ErrorType
> **ErrorType**\<> = `"InputTooShort"` | `"InputTooLong"` | `"LeadingZeros"` | `"NonCanonicalSize"` | `"InvalidLength"` | `"UnexpectedInput"` | `"InvalidRemainder"` | `"ExtraZeros"` | `"RecursionDepthExceeded"`
Defined in: [src/primitives/Rlp/errors.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L2)
#### Type Parameters
## Variables
### MAX\_DEPTH
> `const` **MAX\_DEPTH**: `number` = `32`
Defined in: [src/primitives/Rlp/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/constants.js#L13)
Maximum recursion depth to prevent stack overflow attacks
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MAX_DEPTH } from './primitives/Rlp/index.js';
console.log(MAX_DEPTH); // => 32
```
***
### RlpError
> `const` **RlpError**: *typeof* [`Error`](#error) = `Error`
Defined in: [src/primitives/Rlp/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/errors.js#L19)
## Functions
### decode()
> **decode**(`bytes`, `stream?`): `Decoded`
Defined in: [src/primitives/Rlp/decode.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decode.js#L75)
Decodes RLP-encoded bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
##### stream?
`boolean` = `false`
If true, allows extra data after decoded value. If false, expects exact match
#### Returns
`Decoded`
Decoded RLP data with remainder
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If input is too short, invalid, or has unexpected remainder (when stream=false)
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Decode single value
const bytes = new Uint8Array([0x83, 1, 2, 3]);
const result = Rlp.decode(bytes);
// => { data: { type: 'bytes', value: Uint8Array([1, 2, 3]) }, remainder: Uint8Array([]) }
// Stream decoding (multiple values)
const stream = new Uint8Array([0x01, 0x02]);
const result = Rlp.decode(stream, true);
// => { data: { type: 'bytes', value: Uint8Array([1]) }, remainder: Uint8Array([2]) }
// Decode list
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
const result = Rlp.decode(list);
```
***
### decodeArray()
> **decodeArray**(`data`): `any`\[]
Defined in: [src/primitives/Rlp/decodeArray.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeArray.js#L23)
Decodes RLP-encoded bytes to an array
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`any`\[]
Decoded array
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeArray([
new Uint8Array([1, 2]),
new Uint8Array([3, 4])
]);
const arr = Rlp.decodeArray(encoded);
// => [Uint8Array([1, 2]), Uint8Array([3, 4])]
```
***
### decodeBatch()
> **decodeBatch**(`data`): `any`\[]\[]
Defined in: [src/primitives/Rlp/decodeBatch.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeBatch.js#L23)
Decodes multiple RLP-encoded items
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded data
#### Returns
`any`\[]\[]
Array of decoded results
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails for any item
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
Rlp.encode([new Uint8Array([1, 2])]),
Rlp.encode([new Uint8Array([3, 4])])
];
const decoded = Rlp.decodeBatch(items);
// => [[Uint8Array([1, 2])], [Uint8Array([3, 4])]]
```
***
### decodeObject()
> **decodeObject**(`data`): `Record`\<`string`, `any`>
Defined in: [src/primitives/Rlp/decodeObject.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/decodeObject.js#L20)
Decodes RLP-encoded bytes to an object with known keys
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`Record`\<`string`, `any`>
Decoded object
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If decoding fails or data format is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = { name: new Uint8Array([65, 66]), age: new Uint8Array([25]) };
const encoded = Rlp.encodeObject(obj);
const decoded = Rlp.decodeObject(encoded);
```
***
### encode()
> **encode**(`data`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encode.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encode.js#L47)
Encodes data to RLP format
#### Parameters
##### data
`Encodable`
Data to encode (Uint8Array, RlpData, or array)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data type is invalid or encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Encode bytes
const bytes = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encode(bytes);
// => Uint8Array([0x83, 1, 2, 3])
// Encode list
const list = [new Uint8Array([1, 2]), new Uint8Array([3, 4])];
const encoded = Rlp.encode(list);
// Encode nested structures
const nested = [new Uint8Array([1]), [new Uint8Array([2]), new Uint8Array([3])]];
const encoded = Rlp.encode(nested);
```
***
### encodeArray()
> **encodeArray**(`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeArray.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeArray.js#L25)
Encodes an array of values to RLP format
#### Parameters
##### items
`Encodable`\[]
Array of values to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
new Uint8Array([1, 2, 3]),
new Uint8Array([4, 5, 6])
];
const encoded = Rlp.encodeArray(items);
```
***
### encodeBatch()
> **encodeBatch**(`items`): `Uint8Array`\<`ArrayBufferLike`>\[]
Defined in: [src/primitives/Rlp/encodeBatch.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeBatch.js#L26)
Encodes multiple items efficiently
#### Parameters
##### items
`Encodable`\[]\[]
Array of items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>\[]
Array of RLP-encoded results
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails for any item
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const items = [
[new Uint8Array([1, 2]), new Uint8Array([3, 4])],
[new Uint8Array([5, 6]), new Uint8Array([7, 8])]
];
const encoded = Rlp.encodeBatch(items);
// => [Uint8Array(...), Uint8Array(...)]
```
***
### encodeBytes()
> **encodeBytes**(`bytes`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeBytes.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeBytes.js#L30)
Encodes a byte array according to RLP string rules
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Byte array to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Single byte < 0x80
const b1 = new Uint8Array([0x7f]);
const encoded = Rlp.encodeBytes(b1);
// => Uint8Array([0x7f])
// Short string
const b2 = new Uint8Array([1, 2, 3]);
const encoded = Rlp.encodeBytes(b2);
// => Uint8Array([0x83, 1, 2, 3])
// Long string (> 55 bytes)
const longBytes = new Uint8Array(60).fill(0x42);
const encoded = Rlp.encodeBytes(longBytes);
// => Uint8Array([0xb8, 60, ...longBytes])
```
***
### encodeList()
> **encodeList**(`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeList.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeList.js#L29)
Encodes a list of RLP-encodable items
#### Parameters
##### items
(`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](#brandedrlp))\[]
Array of items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded list
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Empty list
const empty = [];
const encoded = Rlp.encodeList(empty);
// => Uint8Array([0xc0])
// Simple list
const list = [new Uint8Array([1]), new Uint8Array([2])];
const encoded = Rlp.encodeList(list);
// => Uint8Array([0xc4, 0x01, 0x02])
// Nested list
const nested = [new Uint8Array([1]), [new Uint8Array([2])]];
const encoded = Rlp.encodeList(nested);
```
***
### encodeObject()
> **encodeObject**(`obj`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeObject.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeObject.js#L26)
Encodes an object (key-value pairs) to RLP format
Converts object to array of \[key, value] pairs and encodes
#### Parameters
##### obj
`Record`\<`string`, `Encodable`>
Object to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const obj = {
name: new Uint8Array([65, 66, 67]),
age: new Uint8Array([25])
};
const encoded = Rlp.encodeObject(obj);
```
***
### encodeVariadic()
> **encodeVariadic**(...`items`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/encodeVariadic.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/encodeVariadic.js#L25)
Encodes a variadic list of items to RLP format
#### Parameters
##### items
...`Encodable`\[]
Items to encode
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If encoding fails
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = Rlp.encodeVariadic(
new Uint8Array([1, 2]),
new Uint8Array([3, 4]),
new Uint8Array([5, 6])
);
```
***
### equals()
> **equals**(`data`, `other`): `boolean`
Defined in: [src/primitives/Rlp/equals.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/equals.js#L19)
Check if two RLP Data structures are equal
#### Parameters
##### data
[`BrandedRlp`](#brandedrlp)
First RLP data structure
##### other
[`BrandedRlp`](#brandedrlp)
Second RLP data structure
#### Returns
`boolean`
True if structures are deeply equal
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const a = { type: 'bytes', value: new Uint8Array([1, 2]) };
const b = { type: 'bytes', value: new Uint8Array([1, 2]) };
Rlp.equals(a, b); // => true
```
***
### flatten()
> **flatten**(`data`): [`BrandedRlp`](#brandedrlp) & `object`\[]
Defined in: [src/primitives/Rlp/flatten.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/flatten.js#L29)
Flatten nested list Data into array of bytes Data (depth-first)
#### Parameters
##### data
[`BrandedRlp`](#brandedrlp)
RLP data structure to flatten
#### Returns
[`BrandedRlp`](#brandedrlp) & `object`\[]
Array of bytes data (all nested lists flattened)
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const nested = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{
type: 'list',
value: [{ type: 'bytes', value: new Uint8Array([2]) }]
}
]
};
const flat = Rlp.flatten(nested);
// => [
// { type: 'bytes', value: Uint8Array([1]) },
// { type: 'bytes', value: Uint8Array([2]) }
// ]
```
***
### from()
> **from**(`value`): [`BrandedRlp`](#brandedrlp)
Defined in: [src/primitives/Rlp/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/from.js#L20)
Create RLP data from various inputs
#### Parameters
##### value
Uint8Array (bytes), RlpData, or array (list)
`Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](#brandedrlp) | [`BrandedRlp`](#brandedrlp)\[]
#### Returns
[`BrandedRlp`](#brandedrlp)
RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If input type is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const rlp = Rlp.from(new Uint8Array([1, 2, 3]));
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
const rlp2 = Rlp.from([{ type: 'bytes', value: new Uint8Array([1]) }]);
// => { type: 'list', value: [...] }
```
***
### fromJSON()
> **fromJSON**(`json`): [`BrandedRlp`](#brandedrlp)
Defined in: [src/primitives/Rlp/fromJSON.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/fromJSON.js#L19)
Convert JSON representation back to RLP Data
#### Parameters
##### json
`unknown`
JSON object from toJSON
#### Returns
[`BrandedRlp`](#brandedrlp)
RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If JSON format is invalid or type is unrecognized
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const json = { type: 'bytes', value: [1, 2, 3] };
const data = Rlp.fromJSON(json);
// => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
```
***
### getEncodedLength()
> **getEncodedLength**(`data`): `number`
Defined in: [src/primitives/Rlp/getEncodedLength.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/getEncodedLength.js#L21)
Get the total byte length of RLP-encoded data without actually encoding
#### Parameters
##### data
Data to measure
`any`\[] | `Uint8Array`\<`ArrayBufferLike`> | [`BrandedRlp`](#brandedrlp)
#### Returns
`number`
Length in bytes after RLP encoding
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data type is invalid
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([1, 2, 3]);
const length = Rlp.getEncodedLength(bytes);
// => 4 (0x83 prefix + 3 bytes)
```
***
### getLength()
> **getLength**(`data`): `number`
Defined in: [src/primitives/Rlp/getLength.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/getLength.js#L20)
Gets the total length of an RLP item (prefix + payload)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`number`
Total length in bytes
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty, too short, or has invalid prefix
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const encoded = new Uint8Array([0x83, 1, 2, 3]);
const length = Rlp.getLength(encoded);
// => 4 (1 byte prefix + 3 bytes payload)
```
***
### isBytesData()
> **isBytesData**(`value`): `boolean`
Defined in: [src/primitives/Rlp/isBytesData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isBytesData.js#L20)
Check if value is RLP bytes data
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if value is RLP bytes data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isBytesData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isBytesData({ type: 'list', value: [] });
// => false
```
***
### isCanonical()
> **isCanonical**(`bytes`, `depth?`): `boolean`
Defined in: [src/primitives/Rlp/isCanonical.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isCanonical.js#L34)
Validates if RLP encoding is canonical
Canonical encoding rules:
* Integers must use minimum bytes (no leading zeros)
* Strings/bytes must use shortest length prefix
* Single byte \< 0x80 must not be encoded as string
* Length prefix must use minimum bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
##### depth?
`number` = `0`
Current recursion depth (internal)
#### Returns
`boolean`
True if encoding is canonical
#### See
* [https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
* [https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/) for canonical rules
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
// Canonical encoding
const canonical = new Uint8Array([0x83, 0x64, 0x6f, 0x67]); // "dog"
Rlp.isCanonical(canonical); // => true
// Non-canonical: single byte should not be prefixed
const nonCanonical = new Uint8Array([0x81, 0x7f]); // should be just 0x7f
Rlp.isCanonical(nonCanonical); // => false
// Non-canonical: leading zeros in length
const leadingZeros = new Uint8Array([0xb8, 0x00, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f]);
Rlp.isCanonical(leadingZeros); // => false
```
***
### isData()
> **isData**(`value`): `value is BrandedRlp`
Defined in: [src/primitives/Rlp/isData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isData.js#L20)
Check if value is RLP Data structure
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is BrandedRlp`
True if value is valid RLP data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isData({ type: 'bytes', value: new Uint8Array([1]) });
// => true
Rlp.isData({ type: 'list', value: [] });
// => true
Rlp.isData('invalid');
// => false
```
***
### isList()
> **isList**(`data`): `boolean`
Defined in: [src/primitives/Rlp/isList.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isList.js#L23)
Checks if RLP-encoded data represents a list
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`boolean`
True if data encodes a list
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isList(list);
// => true
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isList(bytes);
// => false
```
***
### isListData()
> **isListData**(`value`): `boolean`
Defined in: [src/primitives/Rlp/isListData.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isListData.js#L20)
Check if value is RLP list data
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`boolean`
True if value is RLP list data structure
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
Rlp.isListData({ type: 'list', value: [] });
// => true
Rlp.isListData({ type: 'bytes', value: new Uint8Array([1]) });
// => false
```
***
### isString()
> **isString**(`data`): `boolean`
Defined in: [src/primitives/Rlp/isString.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/isString.js#L23)
Checks if RLP-encoded data represents a string (byte array)
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP-encoded data
#### Returns
`boolean`
True if data encodes a string
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
If data is empty
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03]);
Rlp.isString(bytes);
// => true
const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03]);
Rlp.isString(list);
// => false
```
***
### Rlp()
> **Rlp**(`value`): [`BrandedRlp`](#brandedrlp)
Defined in: [src/primitives/Rlp/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/index.ts#L20)
Creates an RLP data structure from various inputs
#### Parameters
##### value
`RlpInput`
Uint8Array, BrandedRlp, or array to convert
#### Returns
[`BrandedRlp`](#brandedrlp)
BrandedRlp data structure
#### Example
```typescript theme={null}
const data = Rlp(new Uint8Array([1, 2, 3]))
```
***
### toJSON()
> **toJSON**(`data`): `unknown`
Defined in: [src/primitives/Rlp/toJSON.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/toJSON.js#L17)
Convert RLP Data to human-readable JSON format
#### Parameters
##### data
[`BrandedRlp`](#brandedrlp)
RLP data structure
#### Returns
`unknown`
JSON-serializable representation
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const json = Rlp.toJSON(data);
// => { type: 'bytes', value: [1, 2, 3] }
```
***
### toRaw()
> **toRaw**(`data`): `any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Rlp/toRaw.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/toRaw.js#L27)
Converts RLP Data structure to raw JavaScript values (Uint8Array or nested arrays)
#### Parameters
##### data
[`BrandedRlp`](#brandedrlp)
RLP data structure to convert
#### Returns
`any`\[] | `Uint8Array`\<`ArrayBufferLike`>
Raw value (Uint8Array for bytes, array for list)
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) };
const raw = Rlp.toRaw(data);
// => Uint8Array([1, 2, 3])
const listData = {
type: 'list',
value: [
{ type: 'bytes', value: new Uint8Array([1]) },
{ type: 'bytes', value: new Uint8Array([2]) }
]
};
const rawList = Rlp.toRaw(listData);
// => [Uint8Array([1]), Uint8Array([2])]
```
***
### validate()
> **validate**(`data`): `boolean`
Defined in: [src/primitives/Rlp/validate.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Rlp/validate.js#L21)
Validates if data is valid RLP encoding
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
Data to validate
#### Returns
`boolean`
True if valid RLP encoding
#### See
[https://voltaire.tevm.sh/primitives/rlp](https://voltaire.tevm.sh/primitives/rlp) for RLP documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Rlp from './primitives/Rlp/index.js';
const valid = Rlp.validate(new Uint8Array([0x83, 1, 2, 3]));
// => true
const invalid = Rlp.validate(new Uint8Array([0x83, 1]));
// => false (incomplete)
```
# primitives/RuntimeCode
Source: https://voltaire.tevm.sh/generated-api/primitives/RuntimeCode
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/RuntimeCode
# primitives/RuntimeCode
## Type Aliases
### RuntimeCodeType
> **RuntimeCodeType** = `Uint8Array` & `object`
Defined in: [src/primitives/RuntimeCode/RuntimeCodeType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/RuntimeCodeType.ts#L7)
Branded RuntimeCode type
Pure runtime bytecode without constructor or metadata
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"RuntimeCode"`
## Functions
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/RuntimeCode/equals.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/equals.js#L15)
Check if two RuntimeCode instances are equal
#### Parameters
##### a
[`RuntimeCodeType`](#runtimecodetype)
First RuntimeCode
##### b
[`RuntimeCodeType`](#runtimecodetype)
Second RuntimeCode
#### Returns
`boolean`
true if equal
#### Example
```javascript theme={null}
import * as RuntimeCode from './primitives/RuntimeCode/index.js';
const code1 = RuntimeCode.from("0x6001");
const code2 = RuntimeCode.from("0x6001");
RuntimeCode._equals(code1, code2); // true
```
***
### \_toHex()
> **\_toHex**(`data`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/RuntimeCode/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/toHex.js#L15)
Convert RuntimeCode to hex string
#### Parameters
##### data
[`RuntimeCodeType`](#runtimecodetype)
RuntimeCode
#### Returns
[`HexType`](Hex.mdx#hextype)
Hex string
#### Example
```javascript theme={null}
import * as RuntimeCode from './primitives/RuntimeCode/index.js';
const code = RuntimeCode.from("0x6001600155");
const hex = RuntimeCode._toHex(code);
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/RuntimeCode/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/index.ts#L16)
#### Parameters
##### a
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`RuntimeCodeType`](#runtimecodetype)
##### b
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`RuntimeCodeType`](#runtimecodetype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`RuntimeCodeType`](#runtimecodetype)
Defined in: [src/primitives/RuntimeCode/from.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/from.js#L18)
Create RuntimeCode from various input types
#### Parameters
##### value
Hex string or Uint8Array
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`RuntimeCodeType`](#runtimecodetype)
RuntimeCode
#### See
[https://voltaire.tevm.sh/primitives/runtime-code](https://voltaire.tevm.sh/primitives/runtime-code) for RuntimeCode documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as RuntimeCode from './primitives/RuntimeCode/index.js';
const code1 = RuntimeCode.from("0x6001600155");
const code2 = RuntimeCode.from(new Uint8Array([0x60, 0x01, 0x60, 0x01, 0x55]));
```
***
### fromHex()
> **fromHex**(`hex`): [`RuntimeCodeType`](#runtimecodetype)
Defined in: [src/primitives/RuntimeCode/fromHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/fromHex.js#L15)
Create RuntimeCode from hex string
#### Parameters
##### hex
`string`
Hex string
#### Returns
[`RuntimeCodeType`](#runtimecodetype)
RuntimeCode
#### Throws
If hex string is invalid
#### Example
```javascript theme={null}
import * as RuntimeCode from './primitives/RuntimeCode/index.js';
const code = RuntimeCode.fromHex("0x6001600155");
```
***
### toHex()
> **toHex**(`value`): [`HexType`](Hex.mdx#hextype)
Defined in: [src/primitives/RuntimeCode/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/RuntimeCode/index.ts#L23)
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`RuntimeCodeType`](#runtimecodetype)
#### Returns
[`HexType`](Hex.mdx#hextype)
# primitives/Selector
Source: https://voltaire.tevm.sh/generated-api/primitives/Selector
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Selector
# primitives/Selector
## Type Aliases
### SelectorLike
> **SelectorLike** = [`SelectorType`](#selectortype) | `string` | `Uint8Array`
Defined in: [src/primitives/Selector/SelectorType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/SelectorType.ts#L8)
***
### SelectorType
> **SelectorType** = `Uint8Array` & `object`
Defined in: [src/primitives/Selector/SelectorType.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/SelectorType.ts#L3)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Selector"`
##### length
> `readonly` **length**: `4`
## Variables
### Selector
> `const` **Selector**: `object`
Defined in: [src/primitives/Selector/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L46)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two Selectors are equal
###### Parameters
###### a
[`SelectorType`](#selectortype)
###### b
[`SelectorType`](#selectortype)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`SelectorType`](#selectortype)
Create Selector from various input types
###### Parameters
###### value
[`SelectorLike`](#selectorlike)
###### Returns
[`SelectorType`](#selectortype)
##### fromHex()
> **fromHex**: (`hex`) => [`SelectorType`](#selectortype)
Create Selector from hex string
###### Parameters
###### hex
`string`
###### Returns
[`SelectorType`](#selectortype)
##### fromSignature()
> **fromSignature**: (`signature`) => [`SelectorType`](#selectortype)
Compute Selector from function signature
###### Parameters
###### signature
`string`
###### Returns
[`SelectorType`](#selectortype)
##### toHex()
> **toHex**: (`selector`) => `string`
Convert Selector to hex string
###### Parameters
###### selector
[`SelectorType`](#selectortype)
###### Returns
`string`
***
### SIZE
> `const` **SIZE**: `4` = `4`
Defined in: [src/primitives/Selector/SelectorType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/SelectorType.ts#L10)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Selector/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L41)
Check if two Selectors are equal
#### Parameters
##### a
[`SelectorType`](#selectortype)
##### b
[`SelectorType`](#selectortype)
#### Returns
`boolean`
***
### from()
> **from**(`value`): [`SelectorType`](#selectortype)
Defined in: [src/primitives/Selector/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L13)
Create Selector from various input types
#### Parameters
##### value
[`SelectorLike`](#selectorlike)
#### Returns
[`SelectorType`](#selectortype)
***
### fromHex()
> **fromHex**(`hex`): [`SelectorType`](#selectortype)
Defined in: [src/primitives/Selector/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L20)
Create Selector from hex string
#### Parameters
##### hex
`string`
#### Returns
[`SelectorType`](#selectortype)
***
### fromSignature()
> **fromSignature**(`signature`): [`SelectorType`](#selectortype)
Defined in: [src/primitives/Selector/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L27)
Compute Selector from function signature
#### Parameters
##### signature
`string`
#### Returns
[`SelectorType`](#selectortype)
***
### toHex()
> **toHex**(`selector`): `string`
Defined in: [src/primitives/Selector/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Selector/index.ts#L34)
Convert Selector to hex string
#### Parameters
##### selector
[`SelectorType`](#selectortype)
#### Returns
`string`
# primitives/Signature
Source: https://voltaire.tevm.sh/generated-api/primitives/Signature
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Signature
# primitives/Signature
## Classes
### InvalidAlgorithmError
Defined in: [src/primitives/Signature/errors.js:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L103)
Error for invalid signature algorithm
#### Example
```typescript theme={null}
throw new InvalidAlgorithmError(
'DER encoding only supported for ECDSA signatures',
{
value: algorithm,
expected: 'secp256k1 or p256',
code: 'SIGNATURE_INVALID_ALGORITHM',
docsPath: '/primitives/signature/to-der#error-handling'
}
)
```
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new InvalidAlgorithmError**(`message`, `options?`): [`InvalidAlgorithmError`](#invalidalgorithmerror)
Defined in: [src/primitives/Signature/errors.js:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L114)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidAlgorithmError`](#invalidalgorithmerror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/primitives/Signature/errors.js:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L125)
###### Inherited from
`InvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
***
### InvalidDERError
Defined in: [src/primitives/Signature/errors.js:187](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L187)
Error for invalid DER encoding
#### Example
```typescript theme={null}
throw new InvalidDERError(
'Expected SEQUENCE tag (0x30)',
{
value: tag,
expected: '0x30',
code: 'SIGNATURE_INVALID_DER',
docsPath: '/primitives/signature/from-der#error-handling'
}
)
```
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidDERError**(`message`, `options?`): [`InvalidDERError`](#invaliddererror)
Defined in: [src/primitives/Signature/errors.js:198](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L198)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidDERError`](#invaliddererror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Signature/errors.js:208](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L208)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidSignatureFormatError
Defined in: [src/primitives/Signature/errors.js:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L63)
Error for invalid signature format
#### Example
```typescript theme={null}
throw new InvalidSignatureFormatError(
'Unsupported signature value type',
{
value: typeof input,
expected: 'Uint8Array or signature object',
code: 'SIGNATURE_INVALID_FORMAT',
docsPath: '/primitives/signature/from#error-handling'
}
)
```
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidSignatureFormatError**(`message`, `options?`): [`InvalidSignatureFormatError`](#invalidsignatureformaterror)
Defined in: [src/primitives/Signature/errors.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L74)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidSignatureFormatError`](#invalidsignatureformaterror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Signature/errors.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L83)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidSignatureLengthError
Defined in: [src/primitives/Signature/errors.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L23)
Error for invalid signature length
#### Example
```typescript theme={null}
throw new InvalidSignatureLengthError(
'Compact signature must be 64 bytes',
{
value: sig.length,
expected: '64 bytes',
code: 'SIGNATURE_INVALID_LENGTH',
docsPath: '/primitives/signature/from-compact#error-handling'
}
)
```
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidSignatureLengthError**(`message`, `options?`): [`InvalidSignatureLengthError`](#invalidsignaturelengtherror)
Defined in: [src/primitives/Signature/errors.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L34)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidSignatureLengthError`](#invalidsignaturelengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/Signature/errors.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L43)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### NonCanonicalSignatureError
Defined in: [src/primitives/Signature/errors.js:145](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L145)
Error for non-canonical signature
#### Example
```typescript theme={null}
throw new NonCanonicalSignatureError(
's value is not in canonical form',
{
value: s,
expected: 's < n/2',
code: 'SIGNATURE_NON_CANONICAL',
docsPath: '/primitives/signature/canonical#error-handling'
}
)
```
#### Extends
* [`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror)
#### Constructors
##### Constructor
> **new NonCanonicalSignatureError**(`message`, `options?`): [`NonCanonicalSignatureError`](#noncanonicalsignatureerror)
Defined in: [src/primitives/Signature/errors.js:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L156)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`NonCanonicalSignatureError`](#noncanonicalsignatureerror)
###### Overrides
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`constructor`](../index/index.mdx#constructor-12)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`cause`](../index/index.mdx#cause-12)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`code`](../index/index.mdx#code-12)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`context`](../index/index.mdx#context-12)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`docsPath`](../index/index.mdx#docspath-12)
##### name
> **name**: `string`
Defined in: [src/primitives/Signature/errors.js:167](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/errors.js#L167)
###### Inherited from
`InvalidSignatureError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`getErrorChain`](../index/index.mdx#geterrorchain-24)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidSignatureError`](../index/index.mdx#invalidsignatureerror).[`toJSON`](../index/index.mdx#tojson-24)
## Type Aliases
### SignatureAlgorithm
> **SignatureAlgorithm** = `"secp256k1"` | `"p256"` | `"ed25519"`
Defined in: [src/primitives/Signature/SignatureType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/SignatureType.ts#L6)
Algorithm types supported by the Signature primitive
***
### SignatureType
> **SignatureType** = `Uint8Array` & `object`
Defined in: [src/primitives/Signature/SignatureType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/SignatureType.ts#L17)
Unified signature type with algorithm tagging
Structure:
* For ECDSA (secp256k1, p256): r (32 bytes) + s (32 bytes) + optional v (1 byte for secp256k1)
* For Ed25519: signature (64 bytes)
Algorithm is tracked in metadata, not in the bytes
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Signature"`
##### algorithm
> `readonly` **algorithm**: [`SignatureAlgorithm`](#signaturealgorithm)
##### v?
> `readonly` `optional` **v**: `number`
## Variables
### COMPONENT\_SIZE
> `const` **COMPONENT\_SIZE**: `32` = `32`
Defined in: [src/primitives/Signature/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L15)
Size of r or s component in bytes
***
### ECDSA\_SIZE
> `const` **ECDSA\_SIZE**: `64` = `64`
Defined in: [src/primitives/Signature/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L6)
Size of ECDSA signature (r + s) in bytes
***
### ECDSA\_WITH\_V\_SIZE
> `const` **ECDSA\_WITH\_V\_SIZE**: `65` = `65`
Defined in: [src/primitives/Signature/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L9)
Size of ECDSA signature with recovery ID (r + s + v) in bytes
***
### ED25519\_SIZE
> `const` **ED25519\_SIZE**: `64` = `64`
Defined in: [src/primitives/Signature/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L12)
Size of Ed25519 signature in bytes
***
### RECOVERY\_ID\_MAX
> `const` **RECOVERY\_ID\_MAX**: `28` = `28`
Defined in: [src/primitives/Signature/constants.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L19)
***
### RECOVERY\_ID\_MIN
> `const` **RECOVERY\_ID\_MIN**: `27` = `27`
Defined in: [src/primitives/Signature/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/constants.js#L18)
Ethereum recovery ID values
***
### Signature
> `const` **Signature**: `object`
Defined in: [src/primitives/Signature/index.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/index.ts#L69)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two signatures are equal
###### Parameters
###### a
[`SignatureType`](#signaturetype)
First signature
###### b
[`SignatureType`](#signaturetype)
Second signature
###### Returns
`boolean`
True if signatures are equal
###### Example
```typescript theme={null}
const isEqual = Signature.equals(sig1, sig2);
```
##### from()
> **from**: (`value`) => [`SignatureType`](#signaturetype)
Create Signature from various input types (universal constructor)
###### Parameters
###### value
Signature data
`Uint8Array`\<`ArrayBufferLike`> | \{ `algorithm?`: [`SignatureAlgorithm`](#signaturealgorithm); `r`: `Uint8Array`; `s`: `Uint8Array`; `v?`: `number`; } | \{ `algorithm`: `"ed25519"`; `signature`: `Uint8Array`; }
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If value format is unsupported or invalid
###### Throws
If signature length is invalid
###### Example
```typescript theme={null}
// From compact bytes (64 bytes, defaults to secp256k1)
const sig1 = Signature.from(bytes64);
// From object with r, s, v
const sig2 = Signature.from({ r, s, v: 27, algorithm: 'secp256k1' });
// From Ed25519
const sig3 = Signature.from({ signature: bytes64, algorithm: 'ed25519' });
```
##### fromBytes()
> **fromBytes**: (`bytes`, `algorithmOrV?`) => [`SignatureType`](#signaturetype)
Create Signature from raw bytes
Wrapper around fromCompact with clearer semantics for byte input.
Formats supported:
* 64 bytes: ECDSA r+s (with optional EIP-2098 yParity in bit 255) or Ed25519 signature
* 65 bytes: ECDSA r+s+v (secp256k1 only)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Signature bytes
###### algorithmOrV?
Algorithm or explicit v value
`number` | [`SignatureAlgorithm`](#signaturealgorithm)
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If bytes length is invalid
###### Example
```typescript theme={null}
// 64 bytes - defaults to secp256k1
const sig1 = Signature.fromBytes(bytes64);
// 65 bytes with v
const sig2 = Signature.fromBytes(bytes65);
// Explicit algorithm
const sig3 = Signature.fromBytes(bytes64, 'ed25519');
// Explicit v value (overrides EIP-2098 encoding)
const sig4 = Signature.fromBytes(bytes64, 0);
```
##### fromCompact()
> **fromCompact**: (`bytes`, `algorithmOrV`) => [`SignatureType`](#signaturetype)
Create Signature from compact format (EIP-2098: supports yParity in bit 255 of s)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Compact signature bytes (64 or 65 bytes)
###### algorithmOrV
Algorithm or explicit v value
`number` | [`SignatureAlgorithm`](#signaturealgorithm)
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If bytes length is invalid
###### Example
```typescript theme={null}
// EIP-2098: Extract yParity from bit 255 of s (64 bytes)
const sig1 = Signature.fromCompact(bytes64, 'secp256k1');
// Explicit v value (64 bytes)
const sig2 = Signature.fromCompact(bytes64, 0);
// Legacy: 65 bytes with v at end
const sig3 = Signature.fromCompact(bytes65, 'secp256k1');
// Ed25519 (64 bytes)
const sig4 = Signature.fromCompact(bytes64, 'ed25519');
```
##### fromDER()
> **fromDER**: (`der`, `algorithm`, `v?`) => [`SignatureType`](#signaturetype)
Create Signature from DER-encoded ECDSA signature
###### Parameters
###### der
`Uint8Array`\<`ArrayBufferLike`>
DER-encoded signature
###### algorithm
[`SignatureAlgorithm`](#signaturealgorithm)
Algorithm (secp256k1 or p256)
###### v?
`number`
Optional recovery ID for secp256k1
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If DER encoding is invalid
###### Example
```typescript theme={null}
const sig = Signature.fromDER(derBytes, 'secp256k1', 27);
```
##### fromEd25519()
> **fromEd25519**: (`signature`) => [`SignatureType`](#signaturetype)
Create Signature from Ed25519 signature
###### Parameters
###### signature
`Uint8Array`\<`ArrayBufferLike`>
Ed25519 signature (64 bytes)
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If signature is not 64 bytes
###### Example
```typescript theme={null}
const sig = Signature.fromEd25519(signature);
```
##### fromHex()
> **fromHex**: (`value`, `algorithm?`) => [`SignatureType`](#signaturetype)
Create Signature from hex string
Formats supported:
* 128 hex chars (64 bytes): ECDSA r+s or Ed25519 signature
* 130 hex chars (65 bytes): ECDSA r+s+v
###### Parameters
###### value
`string`
Hex string (with or without 0x prefix)
###### algorithm?
[`SignatureAlgorithm`](#signaturealgorithm) = `"secp256k1"`
Signature algorithm
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Throws
If value is not a string
###### Throws
If hex length is invalid
###### Example
```typescript theme={null}
// 128 hex chars (64 bytes) - defaults to secp256k1
const sig1 = Signature.fromHex("0x1234...");
// 130 hex chars (65 bytes) - includes v
const sig2 = Signature.fromHex("0x1234...ab");
// Ed25519 (128 hex chars)
const sig3 = Signature.fromHex("0x1234...", "ed25519");
// P256 (128 hex chars)
const sig4 = Signature.fromHex("0x1234...", "p256");
```
##### fromP256()
> **fromP256**: (`r`, `s`) => [`SignatureType`](#signaturetype)
Create Signature from P-256 ECDSA signature
###### Parameters
###### r
`Uint8Array`\<`ArrayBufferLike`>
r component (32 bytes)
###### s
`Uint8Array`\<`ArrayBufferLike`>
s component (32 bytes)
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Example
```typescript theme={null}
const sig = Signature.fromP256(rBytes, sBytes);
```
##### fromRpc()
> **fromRpc**: (`rpc`) => [`SignatureType`](#signaturetype)
Create Signature from RPC format
###### Parameters
###### rpc
RPC format signature
###### r
`string`
###### s
`string`
###### v?
`string` | `number`
###### yParity?
`string` | `number`
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromRpc({
r: '0x...',
s: '0x...',
yParity: '0x0'
});
```
##### fromSecp256k1()
> **fromSecp256k1**: (`r`, `s`, `v?`) => [`SignatureType`](#signaturetype)
Create Signature from secp256k1 ECDSA signature
###### Parameters
###### r
`Uint8Array`\<`ArrayBufferLike`>
r component (32 bytes)
###### s
`Uint8Array`\<`ArrayBufferLike`>
s component (32 bytes)
###### v?
`number`
Optional recovery ID (27 or 28 for Ethereum)
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Example
```typescript theme={null}
const sig = Signature.fromSecp256k1(rBytes, sBytes, 27);
```
##### fromTuple()
> **fromTuple**: (`tuple`, `chainId?`) => [`SignatureType`](#signaturetype)
Create Signature from tuple format \[yParity, r, s]
###### Parameters
###### tuple
\[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Tuple \[yParity, r, s]
###### chainId?
`number`
Optional chain ID for EIP-155 v encoding
###### Returns
[`SignatureType`](#signaturetype)
Signature
###### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromTuple([0, r, s]);
// With chain ID for EIP-155
const sig155 = Signature.fromTuple([0, r, s], 1);
```
##### getAlgorithm()
> **getAlgorithm**: (`signature`) => [`SignatureAlgorithm`](#signaturealgorithm)
Get the algorithm of a signature
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to check
###### Returns
[`SignatureAlgorithm`](#signaturealgorithm)
Signature algorithm
###### Example
```typescript theme={null}
const algorithm = Signature.getAlgorithm(sig);
// "secp256k1" | "p256" | "ed25519"
```
##### getR()
> **getR**: (`signature`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Get r component from ECDSA signature
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
r component (32 bytes, HashType)
###### Throws
If signature is not ECDSA
###### Example
```typescript theme={null}
const r = Signature.getR(sig);
```
##### getS()
> **getS**: (`signature`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Get s component from ECDSA signature
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature
###### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
s component (32 bytes, HashType)
###### Throws
If signature is not ECDSA
###### Example
```typescript theme={null}
const s = Signature.getS(sig);
```
##### getV()
> **getV**: (`signature`) => `number` | `undefined`
Get v (recovery ID) from secp256k1 signature
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature
###### Returns
`number` | `undefined`
Recovery ID (27 or 28) or undefined
###### Throws
If signature is not secp256k1
###### Example
```typescript theme={null}
const v = Signature.getV(sig);
```
##### is()
> **is**: (`value`) => `value is SignatureType`
Check if value is a SignatureType
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is SignatureType`
True if value is a SignatureType
###### Example
```typescript theme={null}
if (Signature.is(value)) {
console.log(value.algorithm);
}
```
##### isCanonical()
> **isCanonical**: (`signature`) => `boolean`
Check if ECDSA signature has canonical s-value (s is less than or equal to n/2)
For secp256k1 and p256, a signature is canonical if s is at most curve\_order / 2
This prevents signature malleability.
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to check
###### Returns
`boolean`
True if signature is canonical or Ed25519
###### Example
```typescript theme={null}
if (!Signature.isCanonical(sig)) {
sig = Signature.normalize(sig);
}
```
##### normalize()
> **normalize**: (`signature`) => [`SignatureType`](#signaturetype)
Normalize ECDSA signature to canonical form (s = n - s if s > n/2)
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to normalize
###### Returns
[`SignatureType`](#signaturetype)
Normalized signature
###### Example
```typescript theme={null}
const normalized = Signature.normalize(sig);
```
##### toBytes()
> **toBytes**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Signature to raw bytes (without metadata)
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw signature bytes
###### Example
```typescript theme={null}
const bytes = Signature.toBytes(sig);
// Returns r + s (64 bytes) for ECDSA or signature (64 bytes) for Ed25519
```
##### toCompact()
> **toCompact**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Signature to compact format (EIP-2098: yParity encoded in bit 255 of s)
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compact signature (64 bytes with yParity in bit 255 of s)
###### Example
```typescript theme={null}
const compact = Signature.toCompact(sig);
// Returns r + s (64 bytes) with yParity encoded in bit 255 of s (EIP-2098)
```
##### toDER()
> **toDER**: (`signature`) => `Uint8Array`\<`ArrayBufferLike`>
Convert ECDSA signature to DER encoding
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
DER-encoded signature
###### Throws
If signature is not ECDSA (secp256k1 or p256)
###### Example
```typescript theme={null}
const der = Signature.toDER(sig);
// Returns DER-encoded SEQUENCE of r and s integers
```
##### toHex()
> **toHex**: (`signature`, `includeV?`) => `string`
Convert Signature to hex string
Formats:
* ECDSA without v: 128 hex chars (64 bytes: r + s)
* ECDSA with v: 130 hex chars (65 bytes: r + s + v)
* Ed25519: 128 hex chars (64 bytes)
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### includeV?
`boolean` = `true`
Include v byte for secp256k1 (if present)
###### Returns
`string`
Hex string with 0x prefix
###### Example
```typescript theme={null}
const hex = Signature.toHex(sig);
// Returns "0x..." (130 chars with v, 128 chars without)
// Exclude v even if present
const hexNoV = Signature.toHex(sig, false);
// Returns "0x..." (128 chars)
```
##### toRpc()
> **toRpc**: (`signature`) => `object`
Convert Signature to RPC format (r, s, yParity as hex strings)
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### Returns
`object`
RPC format signature
###### r
> **r**: `string`
###### s
> **s**: `string`
###### v?
> `optional` **v**: `string`
###### yParity
> **yParity**: `string`
###### Throws
If signature is not secp256k1
###### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromSecp256k1(r, s, 27);
const rpc = Signature.toRpc(sig);
// { r: '0x...', s: '0x...', yParity: '0x0', v: '0x1b' }
```
##### toTuple()
> **toTuple**: (`signature`) => \[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Convert Signature to tuple format \[yParity, r, s] for transaction envelopes
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to convert
###### Returns
\[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Tuple \[yParity, r, s]
###### Throws
If signature is not secp256k1 or has no v value
###### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromSecp256k1(r, s, 27);
const [yParity, r, s] = Signature.toTuple(sig);
```
##### verify()
> **verify**: (`signature`, `_message`, `_publicKey`) => `boolean`
Verify signature against message and public key
Note: This is a placeholder. Actual verification requires crypto implementations.
Use this in conjunction with crypto library functions.
###### Parameters
###### signature
[`SignatureType`](#signaturetype)
Signature to verify
###### \_message
`Uint8Array`\<`ArrayBufferLike`>
Message that was signed
###### \_publicKey
`Uint8Array`\<`ArrayBufferLike`>
Public key to verify against
###### Returns
`boolean`
True if signature is valid
###### Throws
If algorithm-specific verification is not available
###### Example
```typescript theme={null}
const isValid = Signature.verify(sig, message, publicKey);
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Signature/equals.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/equals.js#L13)
Check if two signatures are equal
#### Parameters
##### a
[`SignatureType`](#signaturetype)
First signature
##### b
[`SignatureType`](#signaturetype)
Second signature
#### Returns
`boolean`
True if signatures are equal
#### Example
```typescript theme={null}
const isEqual = Signature.equals(sig1, sig2);
```
***
### from()
> **from**(`value`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/from.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/from.js#L29)
Create Signature from various input types (universal constructor)
#### Parameters
##### value
Signature data
`Uint8Array`\<`ArrayBufferLike`> | \{ `algorithm?`: [`SignatureAlgorithm`](#signaturealgorithm); `r`: `Uint8Array`; `s`: `Uint8Array`; `v?`: `number`; } | \{ `algorithm`: `"ed25519"`; `signature`: `Uint8Array`; }
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If value format is unsupported or invalid
#### Throws
If signature length is invalid
#### Example
```typescript theme={null}
// From compact bytes (64 bytes, defaults to secp256k1)
const sig1 = Signature.from(bytes64);
// From object with r, s, v
const sig2 = Signature.from({ r, s, v: 27, algorithm: 'secp256k1' });
// From Ed25519
const sig3 = Signature.from({ signature: bytes64, algorithm: 'ed25519' });
```
***
### fromBytes()
> **fromBytes**(`bytes`, `algorithmOrV?`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromBytes.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromBytes.js#L32)
Create Signature from raw bytes
Wrapper around fromCompact with clearer semantics for byte input.
Formats supported:
* 64 bytes: ECDSA r+s (with optional EIP-2098 yParity in bit 255) or Ed25519 signature
* 65 bytes: ECDSA r+s+v (secp256k1 only)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Signature bytes
##### algorithmOrV?
Algorithm or explicit v value
`number` | [`SignatureAlgorithm`](#signaturealgorithm)
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If bytes length is invalid
#### Example
```typescript theme={null}
// 64 bytes - defaults to secp256k1
const sig1 = Signature.fromBytes(bytes64);
// 65 bytes with v
const sig2 = Signature.fromBytes(bytes65);
// Explicit algorithm
const sig3 = Signature.fromBytes(bytes64, 'ed25519');
// Explicit v value (overrides EIP-2098 encoding)
const sig4 = Signature.fromBytes(bytes64, 0);
```
***
### fromCompact()
> **fromCompact**(`bytes`, `algorithmOrV`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromCompact.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromCompact.js#L35)
Create Signature from compact format (EIP-2098: supports yParity in bit 255 of s)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Compact signature bytes (64 or 65 bytes)
##### algorithmOrV
Algorithm or explicit v value
`number` | [`SignatureAlgorithm`](#signaturealgorithm)
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If bytes length is invalid
#### Example
```typescript theme={null}
// EIP-2098: Extract yParity from bit 255 of s (64 bytes)
const sig1 = Signature.fromCompact(bytes64, 'secp256k1');
// Explicit v value (64 bytes)
const sig2 = Signature.fromCompact(bytes64, 0);
// Legacy: 65 bytes with v at end
const sig3 = Signature.fromCompact(bytes65, 'secp256k1');
// Ed25519 (64 bytes)
const sig4 = Signature.fromCompact(bytes64, 'ed25519');
```
***
### fromDER()
> **fromDER**(`der`, `algorithm`, `v?`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromDER.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromDER.js#L20)
Create Signature from DER-encoded ECDSA signature
#### Parameters
##### der
`Uint8Array`\<`ArrayBufferLike`>
DER-encoded signature
##### algorithm
[`SignatureAlgorithm`](#signaturealgorithm)
Algorithm (secp256k1 or p256)
##### v?
`number`
Optional recovery ID for secp256k1
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If DER encoding is invalid
#### Example
```typescript theme={null}
const sig = Signature.fromDER(derBytes, 'secp256k1', 27);
```
***
### fromEd25519()
> **fromEd25519**(`signature`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromEd25519.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromEd25519.js#L16)
Create Signature from Ed25519 signature
#### Parameters
##### signature
`Uint8Array`\<`ArrayBufferLike`>
Ed25519 signature (64 bytes)
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If signature is not 64 bytes
#### Example
```typescript theme={null}
const sig = Signature.fromEd25519(signature);
```
***
### fromHex()
> **fromHex**(`value`, `algorithm?`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromHex.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromHex.js#L36)
Create Signature from hex string
Formats supported:
* 128 hex chars (64 bytes): ECDSA r+s or Ed25519 signature
* 130 hex chars (65 bytes): ECDSA r+s+v
#### Parameters
##### value
`string`
Hex string (with or without 0x prefix)
##### algorithm?
[`SignatureAlgorithm`](#signaturealgorithm) = `"secp256k1"`
Signature algorithm
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Throws
If value is not a string
#### Throws
If hex length is invalid
#### Example
```typescript theme={null}
// 128 hex chars (64 bytes) - defaults to secp256k1
const sig1 = Signature.fromHex("0x1234...");
// 130 hex chars (65 bytes) - includes v
const sig2 = Signature.fromHex("0x1234...ab");
// Ed25519 (128 hex chars)
const sig3 = Signature.fromHex("0x1234...", "ed25519");
// P256 (128 hex chars)
const sig4 = Signature.fromHex("0x1234...", "p256");
```
***
### fromP256()
> **fromP256**(`r`, `s`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromP256.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromP256.js#L16)
Create Signature from P-256 ECDSA signature
#### Parameters
##### r
`Uint8Array`\<`ArrayBufferLike`>
r component (32 bytes)
##### s
`Uint8Array`\<`ArrayBufferLike`>
s component (32 bytes)
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Example
```typescript theme={null}
const sig = Signature.fromP256(rBytes, sBytes);
```
***
### fromRpc()
> **fromRpc**(`rpc`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromRpc.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromRpc.js#L19)
Create Signature from RPC format
#### Parameters
##### rpc
RPC format signature
###### r
`string`
###### s
`string`
###### v?
`string` | `number`
###### yParity?
`string` | `number`
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromRpc({
r: '0x...',
s: '0x...',
yParity: '0x0'
});
```
***
### fromSecp256k1()
> **fromSecp256k1**(`r`, `s`, `v?`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromSecp256k1.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromSecp256k1.js#L17)
Create Signature from secp256k1 ECDSA signature
#### Parameters
##### r
`Uint8Array`\<`ArrayBufferLike`>
r component (32 bytes)
##### s
`Uint8Array`\<`ArrayBufferLike`>
s component (32 bytes)
##### v?
`number`
Optional recovery ID (27 or 28 for Ethereum)
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Example
```typescript theme={null}
const sig = Signature.fromSecp256k1(rBytes, sBytes, 27);
```
***
### fromTuple()
> **fromTuple**(`tuple`, `chainId?`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/fromTuple.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/fromTuple.js#L18)
Create Signature from tuple format \[yParity, r, s]
#### Parameters
##### tuple
\[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Tuple \[yParity, r, s]
##### chainId?
`number`
Optional chain ID for EIP-155 v encoding
#### Returns
[`SignatureType`](#signaturetype)
Signature
#### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromTuple([0, r, s]);
// With chain ID for EIP-155
const sig155 = Signature.fromTuple([0, r, s], 1);
```
***
### getAlgorithm()
> **getAlgorithm**(`signature`): [`SignatureAlgorithm`](#signaturealgorithm)
Defined in: [src/primitives/Signature/getAlgorithm.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/getAlgorithm.js#L13)
Get the algorithm of a signature
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to check
#### Returns
[`SignatureAlgorithm`](#signaturealgorithm)
Signature algorithm
#### Example
```typescript theme={null}
const algorithm = Signature.getAlgorithm(sig);
// "secp256k1" | "p256" | "ed25519"
```
***
### getR()
> **getR**(`signature`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Signature/getR.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/getR.js#L16)
Get r component from ECDSA signature
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
r component (32 bytes, HashType)
#### Throws
If signature is not ECDSA
#### Example
```typescript theme={null}
const r = Signature.getR(sig);
```
***
### getS()
> **getS**(`signature`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Signature/getS.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/getS.js#L16)
Get s component from ECDSA signature
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
s component (32 bytes, HashType)
#### Throws
If signature is not ECDSA
#### Example
```typescript theme={null}
const s = Signature.getS(sig);
```
***
### getV()
> **getV**(`signature`): `number` | `undefined`
Defined in: [src/primitives/Signature/getV.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/getV.js#L15)
Get v (recovery ID) from secp256k1 signature
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature
#### Returns
`number` | `undefined`
Recovery ID (27 or 28) or undefined
#### Throws
If signature is not secp256k1
#### Example
```typescript theme={null}
const v = Signature.getV(sig);
```
***
### is()
> **is**(`value`): `value is SignatureType`
Defined in: [src/primitives/Signature/is.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/is.js#L14)
Check if value is a SignatureType
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is SignatureType`
True if value is a SignatureType
#### Example
```typescript theme={null}
if (Signature.is(value)) {
console.log(value.algorithm);
}
```
***
### isCanonical()
> **isCanonical**(`signature`): `boolean`
Defined in: [src/primitives/Signature/isCanonical.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/isCanonical.js#L19)
Check if ECDSA signature has canonical s-value (s is less than or equal to n/2)
For secp256k1 and p256, a signature is canonical if s is at most curve\_order / 2
This prevents signature malleability.
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to check
#### Returns
`boolean`
True if signature is canonical or Ed25519
#### Example
```typescript theme={null}
if (!Signature.isCanonical(sig)) {
sig = Signature.normalize(sig);
}
```
***
### normalize()
> **normalize**(`signature`): [`SignatureType`](#signaturetype)
Defined in: [src/primitives/Signature/normalize.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/normalize.js#L19)
Normalize ECDSA signature to canonical form (s = n - s if s > n/2)
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to normalize
#### Returns
[`SignatureType`](#signaturetype)
Normalized signature
#### Example
```typescript theme={null}
const normalized = Signature.normalize(sig);
```
***
### toBytes()
> **toBytes**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Signature/toBytes.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toBytes.js#L13)
Convert Signature to raw bytes (without metadata)
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Raw signature bytes
#### Example
```typescript theme={null}
const bytes = Signature.toBytes(sig);
// Returns r + s (64 bytes) for ECDSA or signature (64 bytes) for Ed25519
```
***
### toCompact()
> **toCompact**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Signature/toCompact.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toCompact.js#L13)
Convert Signature to compact format (EIP-2098: yParity encoded in bit 255 of s)
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Compact signature (64 bytes with yParity in bit 255 of s)
#### Example
```typescript theme={null}
const compact = Signature.toCompact(sig);
// Returns r + s (64 bytes) with yParity encoded in bit 255 of s (EIP-2098)
```
***
### toDER()
> **toDER**(`signature`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Signature/toDER.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toDER.js#L17)
Convert ECDSA signature to DER encoding
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
DER-encoded signature
#### Throws
If signature is not ECDSA (secp256k1 or p256)
#### Example
```typescript theme={null}
const der = Signature.toDER(sig);
// Returns DER-encoded SEQUENCE of r and s integers
```
***
### toHex()
> **toHex**(`signature`, `includeV?`): `string`
Defined in: [src/primitives/Signature/toHex.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toHex.js#L23)
Convert Signature to hex string
Formats:
* ECDSA without v: 128 hex chars (64 bytes: r + s)
* ECDSA with v: 130 hex chars (65 bytes: r + s + v)
* Ed25519: 128 hex chars (64 bytes)
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
##### includeV?
`boolean` = `true`
Include v byte for secp256k1 (if present)
#### Returns
`string`
Hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = Signature.toHex(sig);
// Returns "0x..." (130 chars with v, 128 chars without)
// Exclude v even if present
const hexNoV = Signature.toHex(sig, false);
// Returns "0x..." (128 chars)
```
***
### toRpc()
> **toRpc**(`signature`): `object`
Defined in: [src/primitives/Signature/toRpc.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toRpc.js#L20)
Convert Signature to RPC format (r, s, yParity as hex strings)
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
#### Returns
`object`
RPC format signature
##### r
> **r**: `string`
##### s
> **s**: `string`
##### v?
> `optional` **v**: `string`
##### yParity
> **yParity**: `string`
#### Throws
If signature is not secp256k1
#### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromSecp256k1(r, s, 27);
const rpc = Signature.toRpc(sig);
// { r: '0x...', s: '0x...', yParity: '0x0', v: '0x1b' }
```
***
### toTuple()
> **toTuple**(`signature`): \[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Defined in: [src/primitives/Signature/toTuple.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/toTuple.js#L19)
Convert Signature to tuple format \[yParity, r, s] for transaction envelopes
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to convert
#### Returns
\[`number`, `Uint8Array`\<`ArrayBufferLike`>, `Uint8Array`\<`ArrayBufferLike`>]
Tuple \[yParity, r, s]
#### Throws
If signature is not secp256k1 or has no v value
#### Example
```javascript theme={null}
import * as Signature from './primitives/Signature/index.js';
const sig = Signature.fromSecp256k1(r, s, 27);
const [yParity, r, s] = Signature.toTuple(sig);
```
***
### verify()
> **verify**(`signature`, `_message`, `_publicKey`): `boolean`
Defined in: [src/primitives/Signature/verify.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Signature/verify.js#L20)
Verify signature against message and public key
Note: This is a placeholder. Actual verification requires crypto implementations.
Use this in conjunction with crypto library functions.
#### Parameters
##### signature
[`SignatureType`](#signaturetype)
Signature to verify
##### \_message
`Uint8Array`\<`ArrayBufferLike`>
Message that was signed
##### \_publicKey
`Uint8Array`\<`ArrayBufferLike`>
Public key to verify against
#### Returns
`boolean`
True if signature is valid
#### Throws
If algorithm-specific verification is not available
#### Example
```typescript theme={null}
const isValid = Signature.verify(sig, message, publicKey);
```
## References
### default
Renames and re-exports [Signature](#signature)
# primitives/SignedData
Source: https://voltaire.tevm.sh/generated-api/primitives/SignedData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/SignedData
# primitives/SignedData
## Classes
### InvalidSignedDataFormatError
Defined in: [src/primitives/SignedData/errors.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L17)
Error thrown when signed data has invalid format
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidSignedDataFormatError**(`message`, `context?`): [`InvalidSignedDataFormatError`](#invalidsigneddataformaterror)
Defined in: [src/primitives/SignedData/errors.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L18)
###### Parameters
###### message
`string`
###### context?
`unknown`
###### Returns
[`InvalidSignedDataFormatError`](#invalidsigneddataformaterror)
###### Overrides
`Error.constructor`
#### Properties
##### context?
> `optional` **context**: `unknown`
Defined in: [src/primitives/SignedData/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L24)
***
### InvalidSignedDataVersionError
Defined in: [src/primitives/SignedData/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L4)
Error thrown when signed data has invalid version byte
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidSignedDataVersionError**(`message`, `context?`): [`InvalidSignedDataVersionError`](#invalidsigneddataversionerror)
Defined in: [src/primitives/SignedData/errors.ts:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L5)
###### Parameters
###### message
`string`
###### context?
`unknown`
###### Returns
[`InvalidSignedDataVersionError`](#invalidsigneddataversionerror)
###### Overrides
`Error.constructor`
#### Properties
##### context?
> `optional` **context**: `unknown`
Defined in: [src/primitives/SignedData/errors.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L11)
***
### SignatureVerificationError
Defined in: [src/primitives/SignedData/errors.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L30)
Error thrown when signature verification fails
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new SignatureVerificationError**(`message`, `context?`): [`SignatureVerificationError`](#signatureverificationerror)
Defined in: [src/primitives/SignedData/errors.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L31)
###### Parameters
###### message
`string`
###### context?
`unknown`
###### Returns
[`SignatureVerificationError`](#signatureverificationerror)
###### Overrides
`Error.constructor`
#### Properties
##### context?
> `optional` **context**: `unknown`
Defined in: [src/primitives/SignedData/errors.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/errors.ts#L37)
## Type Aliases
### SignedDataType
> **SignedDataType** = `Uint8Array` & `object`
Defined in: [src/primitives/SignedData/SignedDataType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/SignedDataType.ts#L12)
EIP-191 signed data type
Represents signed data according to EIP-191 specification.
The version byte determines the signature format:
* 0x00: Data with validator address
* 0x01: Structured data (EIP-712)
* 0x45: Personal message ("E" for Ethereum Signed Message)
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"SignedData"`
#### See
[https://eips.ethereum.org/EIPS/eip-191](https://eips.ethereum.org/EIPS/eip-191)
***
### SignedDataVersion
> **SignedDataVersion** = `0` | `1` | `69`
Defined in: [src/primitives/SignedData/SignedDataType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/SignedDataType.ts#L24)
EIP-191 version byte
Determines the format and validation rules for signed data:
* 0x00: Data with intended validator (contract address)
* 0x01: Structured data following EIP-712
* 0x45: Personal message with "\x19Ethereum Signed Message:\n" prefix
## Variables
### EIP191\_PREFIX
> `const` **EIP191\_PREFIX**: `25` = `0x19`
Defined in: [src/primitives/SignedData/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/constants.js#L15)
EIP-191 prefix byte
***
### PERSONAL\_MESSAGE\_PREFIX
> `const` **PERSONAL\_MESSAGE\_PREFIX**: "\u0019Ethereum Signed Message:\n" = `"\x19Ethereum Signed Message:\n"`
Defined in: [src/primitives/SignedData/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/constants.js#L18)
Personal message prefix string
***
### VERSION\_DATA\_WITH\_VALIDATOR
> `const` **VERSION\_DATA\_WITH\_VALIDATOR**: `0` = `0x00`
Defined in: [src/primitives/SignedData/constants.js:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/constants.js#L6)
Version 0x00: Data with validator
***
### VERSION\_PERSONAL\_MESSAGE
> `const` **VERSION\_PERSONAL\_MESSAGE**: `69` = `0x45`
Defined in: [src/primitives/SignedData/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/constants.js#L12)
Version 0x45: Personal message
***
### VERSION\_STRUCTURED\_DATA
> `const` **VERSION\_STRUCTURED\_DATA**: `1` = `0x01`
Defined in: [src/primitives/SignedData/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/constants.js#L9)
Version 0x01: Structured data (EIP-712)
## Functions
### from()
> **from**(`version`, `versionData`, `data`): [`SignedDataType`](#signeddatatype)
Defined in: [src/primitives/SignedData/from.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/from.js#L35)
Create EIP-191 signed data from components
Format: `0x19 `
* Version 0x00: `0x19 0x00 `
* Version 0x01: `0x19 0x01 `
* Version 0x45: `0x19 0x45 `
#### Parameters
##### version
`number`
Version byte (0x00, 0x01, or 0x45)
##### versionData
`Uint8Array`\<`ArrayBufferLike`>
Version-specific data (validator address or domain separator)
##### data
`Uint8Array`\<`ArrayBufferLike`>
Message data
#### Returns
[`SignedDataType`](#signeddatatype)
EIP-191 formatted signed data
#### Throws
If version is not valid
#### Example
```javascript theme={null}
import { from } from './primitives/SignedData/from.js';
// Personal message (0x45)
const signedData = from(0x45, new Uint8Array(), message);
// Data with validator (0x00)
const signedData = from(0x00, validatorAddress, data);
```
***
### Hash()
> **Hash**(`deps`): (`message`) => [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/SignedData/hash.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/hash.js#L10)
Factory: Create EIP-191 personal message hash function
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
> (`message`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
##### Parameters
###### message
`string` | `Uint8Array`\<`ArrayBufferLike`>
##### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### Verify()
> **Verify**(`deps`): (`message`, `signature`, `expectedAddress`) => `boolean`
Defined in: [src/primitives/SignedData/verify.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SignedData/verify.js#L12)
Factory: Create signature verification function for EIP-191 personal messages
#### Parameters
##### deps
Crypto dependencies
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
Address derivation from public key
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### recoverPublicKey
(`signature`, `messageHash`) => `Uint8Array`
secp256k1 public key recovery
#### Returns
> (`message`, `signature`, `expectedAddress`): `boolean`
##### Parameters
###### message
`string` | `Uint8Array`\<`ArrayBufferLike`>
###### signature
###### r
`Uint8Array`
###### s
`Uint8Array`
###### v
`number`
###### expectedAddress
[`AddressType`](Address.mdx#addresstype)
##### Returns
`boolean`
# primitives/Siwe
Source: https://voltaire.tevm.sh/generated-api/primitives/Siwe
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Siwe
# primitives/Siwe
## Classes
### InvalidFieldError
Defined in: [src/primitives/Siwe/errors.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L59)
SIWE message field has invalid value
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidFieldError**(`field`, `reason`, `options?`): [`InvalidFieldError`](#invalidfielderror)
Defined in: [src/primitives/Siwe/errors.js:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L67)
###### Parameters
###### field
`string`
Name of the invalid field
###### reason
`string`
Why the field is invalid
###### options?
###### cause?
`Error`
###### value?
`unknown`
###### Returns
[`InvalidFieldError`](#invalidfielderror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Siwe/errors.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L75)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### InvalidNonceLengthError
Defined in: [src/primitives/Siwe/errors.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L84)
SIWE nonce length is invalid
#### Throws
#### Extends
* [`InvalidLengthError`](../index/index.mdx#invalidlengtherror)
#### Constructors
##### Constructor
> **new InvalidNonceLengthError**(`length`, `options?`): [`InvalidNonceLengthError`](#invalidnoncelengtherror)
Defined in: [src/primitives/Siwe/errors.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L90)
###### Parameters
###### length
`number`
Requested nonce length
###### options?
###### cause?
`Error`
###### Returns
[`InvalidNonceLengthError`](#invalidnoncelengtherror)
###### Overrides
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`constructor`](../index/index.mdx#constructor-8)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`cause`](../index/index.mdx#cause-8)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`code`](../index/index.mdx#code-8)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`context`](../index/index.mdx#context-8)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`docsPath`](../index/index.mdx#docspath-8)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`expected`](../index/index.mdx#expected-4)
##### name
> **name**: `string`
Defined in: [src/primitives/Siwe/errors.js:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L98)
###### Inherited from
`InvalidLengthError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`value`](../index/index.mdx#value-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`getErrorChain`](../index/index.mdx#geterrorchain-16)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidLengthError`](../index/index.mdx#invalidlengtherror).[`toJSON`](../index/index.mdx#tojson-16)
***
### InvalidSiweMessageError
Defined in: [src/primitives/Siwe/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L12)
SIWE message format is invalid
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new InvalidSiweMessageError**(`message`, `options?`): [`InvalidSiweMessageError`](#invalidsiwemessageerror)
Defined in: [src/primitives/Siwe/errors.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L19)
###### Parameters
###### message
`string`
Description of the format issue
###### options?
###### cause?
`Error`
###### value?
`unknown`
###### Returns
[`InvalidSiweMessageError`](#invalidsiwemessageerror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Siwe/errors.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L27)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### MissingFieldError
Defined in: [src/primitives/Siwe/errors.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L36)
SIWE message missing required field
#### Throws
#### Extends
* [`InvalidFormatError`](../index/index.mdx#invalidformaterror)
#### Constructors
##### Constructor
> **new MissingFieldError**(`field`, `options?`): [`MissingFieldError`](#missingfielderror)
Defined in: [src/primitives/Siwe/errors.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L42)
###### Parameters
###### field
`string`
Name of the missing field
###### options?
###### cause?
`Error`
###### Returns
[`MissingFieldError`](#missingfielderror)
###### Overrides
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`constructor`](../index/index.mdx#constructor-7)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`cause`](../index/index.mdx#cause-7)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`code`](../index/index.mdx#code-7)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`context`](../index/index.mdx#context-7)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`docsPath`](../index/index.mdx#docspath-7)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`expected`](../index/index.mdx#expected-3)
##### name
> **name**: `string`
Defined in: [src/primitives/Siwe/errors.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L50)
###### Inherited from
`InvalidFormatError.name`
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`value`](../index/index.mdx#value-3)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`getErrorChain`](../index/index.mdx#geterrorchain-14)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`InvalidFormatError`](../index/index.mdx#invalidformaterror).[`toJSON`](../index/index.mdx#tojson-14)
***
### SiweParseError
Defined in: [src/primitives/Siwe/errors.js:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L107)
SIWE message parsing failed
#### Throws
#### Extends
* [`DecodingError`](../index/index.mdx#decodingerror)
#### Constructors
##### Constructor
> **new SiweParseError**(`message`, `options?`): [`SiweParseError`](#siweparseerror)
Defined in: [src/primitives/Siwe/errors.js:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L114)
###### Parameters
###### message
`string`
Description of the parse error
###### options?
###### cause?
`Error`
###### value?
`unknown`
###### Returns
[`SiweParseError`](#siweparseerror)
###### Overrides
[`DecodingError`](../index/index.mdx#decodingerror).[`constructor`](../index/index.mdx#constructor-2)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`cause`](../index/index.mdx#cause-2)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`code`](../index/index.mdx#code-2)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`context`](../index/index.mdx#context-2)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`docsPath`](../index/index.mdx#docspath-2)
##### name
> **name**: `string`
Defined in: [src/primitives/Siwe/errors.js:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/errors.js#L121)
###### Inherited from
`DecodingError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`getErrorChain`](../index/index.mdx#geterrorchain-4)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`DecodingError`](../index/index.mdx#decodingerror).[`toJSON`](../index/index.mdx#tojson-4)
## Type Aliases
### ~~BrandedMessage~~
> **BrandedMessage**\<`TDomain`, `TAddress`, `TUri`, `TVersion`, `TChainId`> = [`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `TVersion`, `TChainId`>
Defined in: [src/primitives/Siwe/SiweMessageType.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L74)
Branded SIWE Message type (for backwards compatibility)
#### Type Parameters
##### TDomain
`TDomain` *extends* `string` = `string`
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TUri
`TUri` *extends* `string` = `string`
##### TVersion
`TVersion` *extends* `string` = `string`
##### TChainId
`TChainId` *extends* `number` = `number`
#### Deprecated
Use SiweMessageType instead
***
### Signature
> **Signature** = `Uint8Array`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L46)
Signature type for SIWE verification
65 bytes: r (32) + s (32) + v (1)
***
### SiweMessageType
> **SiweMessageType**\<`TDomain`, `TAddress`, `TUri`, `TVersion`, `TChainId`> = `object`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L9)
Sign-In with Ethereum Message (EIP-4361)
A structured message format for authentication using Ethereum accounts.
Supports domains, URIs, nonces, timestamps, and optional resources.
#### Type Parameters
##### TDomain
`TDomain` *extends* `string` = `string`
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TUri
`TUri` *extends* `string` = `string`
##### TVersion
`TVersion` *extends* `string` = `string`
##### TChainId
`TChainId` *extends* `number` = `number`
#### Properties
##### address
> **address**: `TAddress`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L19)
Ethereum address performing the signing
##### chainId
> **chainId**: `TChainId`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L27)
EIP-155 Chain ID to which the session is bound
##### domain
> **domain**: `TDomain`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L17)
RFC 4501 dns authority that is requesting the signing
##### expirationTime?
> `optional` **expirationTime**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L33)
ISO 8601 datetime string after which the message is no longer valid (optional)
##### issuedAt
> **issuedAt**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L31)
ISO 8601 datetime string of the current time
##### nonce
> **nonce**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L29)
Randomized token to prevent replay attacks, at least 8 alphanumeric characters
##### notBefore?
> `optional` **notBefore**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L35)
ISO 8601 datetime string before which the message is invalid (optional)
##### requestId?
> `optional` **requestId**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L37)
System-specific identifier that may be used to uniquely refer to the sign-in request (optional)
##### resources?
> `optional` **resources**: `string`\[]
Defined in: [src/primitives/Siwe/SiweMessageType.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L39)
List of information or references to information the user wishes to have resolved (optional)
##### statement?
> `optional` **statement**: `string`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L21)
Human-readable ASCII assertion that the user will sign (optional)
##### uri
> **uri**: `TUri`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L23)
RFC 3986 URI referring to the resource that is the subject of the signing
##### version
> **version**: `TVersion`
Defined in: [src/primitives/Siwe/SiweMessageType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L25)
Current version of the message (must be "1")
***
### ValidationError
> **ValidationError** = \{ `message`: `string`; `type`: `"invalid_domain"`; } | \{ `message`: `string`; `type`: `"invalid_address"`; } | \{ `message`: `string`; `type`: `"invalid_uri"`; } | \{ `message`: `string`; `type`: `"invalid_version"`; } | \{ `message`: `string`; `type`: `"invalid_chain_id"`; } | \{ `message`: `string`; `type`: `"invalid_nonce"`; } | \{ `message`: `string`; `type`: `"invalid_timestamp"`; } | \{ `message`: `string`; `type`: `"expired"`; } | \{ `message`: `string`; `type`: `"not_yet_valid"`; } | \{ `message`: `string`; `type`: `"signature_mismatch"`; }
Defined in: [src/primitives/Siwe/SiweMessageType.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L58)
Validation error types
***
### ValidationResult
> **ValidationResult** = \{ `valid`: `true`; } | \{ `error`: [`ValidationError`](#validationerror); `valid`: `false`; }
Defined in: [src/primitives/Siwe/SiweMessageType.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/SiweMessageType.ts#L51)
Validation result with detailed error information
## Variables
### \_getMessageHash
> `const` **\_getMessageHash**: `GetMessageHashFn`
Defined in: [src/primitives/Siwe/index.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L78)
***
### \_verify
> `const` **\_verify**: `VerifyFn`
Defined in: [src/primitives/Siwe/index.ts:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L79)
***
### \_verifyMessage
> `const` **\_verifyMessage**: `VerifyMessageFn`
Defined in: [src/primitives/Siwe/index.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L84)
***
### BrandedSiwe
> `const` **BrandedSiwe**: `object`
Defined in: [src/primitives/Siwe/index.ts:156](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L156)
#### Type Declaration
##### create()
> **create**: \<`TDomain`, `TAddress`, `TUri`, `TChainId`>(`params`) => [`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
###### Type Parameters
###### TDomain
`TDomain` *extends* `string` = `string`
###### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
###### TUri
`TUri` *extends* `string` = `string`
###### TChainId
`TChainId` *extends* `number` = `number`
###### Parameters
###### params
`CreateParams`\<`TDomain`, `TAddress`, `TUri`, `TChainId`>
###### Returns
[`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
##### format()
> **format**: (`message`) => `string`
###### Parameters
###### message
[`SiweMessageType`](#siwemessagetype)
###### Returns
`string`
##### generateNonce()
> **generateNonce**: (`length?`) => `string`
###### Parameters
###### length?
`number`
###### Returns
`string`
##### getMessageHash
> **getMessageHash**: `GetMessageHashFn`
##### parse()
> **parse**: (`text`) => [`SiweMessageType`](#siwemessagetype)
###### Parameters
###### text
`string`
###### Returns
[`SiweMessageType`](#siwemessagetype)
##### validate()
> **validate**: (`message`, `options?`) => [`ValidationResult`](#validationresult)
###### Parameters
###### message
[`SiweMessageType`](#siwemessagetype)
###### options?
###### now?
`Date`
###### Returns
[`ValidationResult`](#validationresult)
##### verify
> **verify**: `VerifyFn`
##### verifyMessage
> **verifyMessage**: `VerifyMessageFn`
***
### GetMessageHash()
> `const` **GetMessageHash**: (`deps`) => `GetMessageHashFn`
Defined in: [src/primitives/Siwe/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L46)
#### Parameters
##### deps
###### keccak256
(`data`) => `Uint8Array`
#### Returns
`GetMessageHashFn`
***
### Verify()
> `const` **Verify**: (`deps`) => `VerifyFn`
Defined in: [src/primitives/Siwe/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L50)
#### Parameters
##### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### secp256k1RecoverPublicKey
(`signature`, `hash`) => [`Secp256k1PublicKeyType`](../crypto/Secp256k1.mdx#secp256k1publickeytype)
#### Returns
`VerifyFn`
***
### VerifyMessage()
> `const` **VerifyMessage**: (`deps`) => `VerifyMessageFn`
Defined in: [src/primitives/Siwe/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L59)
#### Parameters
##### deps
###### addressFromPublicKey
(`x`, `y`) => [`AddressType`](Address.mdx#addresstype)
###### keccak256
(`data`) => `Uint8Array`
###### secp256k1RecoverPublicKey
(`signature`, `hash`) => [`Secp256k1PublicKeyType`](../crypto/Secp256k1.mdx#secp256k1publickeytype)
#### Returns
`VerifyMessageFn`
## Functions
### \_create()
> **\_create**\<`TDomain`, `TAddress`, `TUri`, `TChainId`>(`params`): [`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
Defined in: [src/primitives/Siwe/create.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/create.js#L40)
Create a new SIWE message with default values
#### Type Parameters
##### TDomain
`TDomain` *extends* `string`
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype)
##### TUri
`TUri` *extends* `string`
##### TChainId
`TChainId` *extends* `number`
#### Parameters
##### params
Message parameters (domain, address, uri, chainId are required)
###### address
`TAddress`
Ethereum address performing the signing
###### chainId
`TChainId`
EIP-155 Chain ID
###### domain
`TDomain`
RFC 4501 dns authority requesting the signing
###### expirationTime?
`string`
ISO 8601 datetime string for expiration
###### issuedAt?
`string`
Custom issued at (current time if not provided)
###### nonce?
`string`
Custom nonce (auto-generated if not provided)
###### notBefore?
`string`
ISO 8601 datetime string for not before
###### requestId?
`string`
System-specific identifier
###### resources?
`string`\[]
List of resources
###### statement?
`string`
Human-readable ASCII assertion
###### uri
`TUri`
RFC 3986 URI referring to the subject of signing
#### Returns
[`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
New SIWE message with defaults
#### See
[https://voltaire.tevm.sh/primitives/siwe](https://voltaire.tevm.sh/primitives/siwe) for SIWE documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Siwe from './primitives/Siwe/index.js';
import * as Address from './primitives/Address/index.js';
const message = Siwe.create({
domain: "example.com",
address: Address.fromHex("0x..."),
uri: "https://example.com",
chainId: 1,
});
// Automatically generates nonce, issuedAt, and sets version to "1"
```
***
### \_format()
> **\_format**(`message`): `string`
Defined in: [src/primitives/Siwe/format.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/format.js#L26)
Format a SIWE message into a string for signing (EIP-4361)
#### Parameters
##### message
[`SiweMessageType`](#siwemessagetype)\<`string`, [`AddressType`](Address.mdx#addresstype), `string`, `string`, `number`>
Message to format
#### Returns
`string`
Formatted string according to EIP-4361 specification
#### See
[https://voltaire.tevm.sh/primitives/siwe](https://voltaire.tevm.sh/primitives/siwe) for SIWE documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Siwe from './primitives/Siwe/index.js';
import * as Address from './primitives/Address/index.js';
const message = {
domain: "example.com",
address: Address.fromHex("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
uri: "https://example.com",
version: "1",
chainId: 1,
nonce: "32891756",
issuedAt: "2021-09-30T16:25:24Z",
};
const text = Siwe.format(message);
```
***
### \_generateNonce()
> **\_generateNonce**(`length?`): `string`
Defined in: [src/primitives/Siwe/generateNonce.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/generateNonce.js#L22)
Generate a cryptographically secure random nonce for SIWE messages
#### Parameters
##### length?
`number` = `11`
Length of nonce (minimum 8)
#### Returns
`string`
Random alphanumeric nonce string
#### See
[https://voltaire.tevm.sh/primitives/siwe](https://voltaire.tevm.sh/primitives/siwe) for SIWE documentation
#### Since
0.0.0
#### Throws
if length is less than 8
#### Example
```javascript theme={null}
import * as Siwe from './primitives/Siwe/index.js';
const nonce = Siwe.generateNonce();
// Returns something like "a7b9c2d4e6f"
const longNonce = Siwe.generateNonce(16);
// Returns something like "a7b9c2d4e6f8g0h1"
```
***
### \_parse()
> **\_parse**(`text`): [`SiweMessageType`](#siwemessagetype)\<`string`, [`AddressType`](Address.mdx#addresstype), `string`, `string`, `number`>
Defined in: [src/primitives/Siwe/parse.js:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/parse.js#L39)
Parse a SIWE message from a formatted string
#### Parameters
##### text
`string`
Formatted SIWE message string
#### Returns
[`SiweMessageType`](#siwemessagetype)\<`string`, [`AddressType`](Address.mdx#addresstype), `string`, `string`, `number`>
Parsed Message object
#### See
[https://voltaire.tevm.sh/primitives/siwe](https://voltaire.tevm.sh/primitives/siwe) for SIWE documentation
#### Since
0.0.0
#### Throws
if message format is invalid
#### Throws
if required field is missing
#### Throws
if field value is invalid
#### Throws
if parsing fails
#### Example
```javascript theme={null}
import * as Siwe from './primitives/Siwe/index.js';
const text = `example.com wants you to sign in with your Ethereum account:
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Sign in to Example
URI: https://example.com
Version: 1
Chain ID: 1
Nonce: 32891756
Issued At: 2021-09-30T16:25:24Z`;
const message = Siwe.parse(text);
```
***
### \_validate()
> **\_validate**(`message`, `options?`): [`ValidationResult`](#validationresult)
Defined in: [src/primitives/Siwe/validate.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/validate.js#L20)
Validate a SIWE message structure and timestamps
#### Parameters
##### message
[`SiweMessageType`](#siwemessagetype)\<`string`, [`AddressType`](Address.mdx#addresstype), `string`, `string`, `number`>
Message to validate
##### options?
Validation options
###### now?
`Date`
Current time for timestamp checks (defaults to now)
#### Returns
[`ValidationResult`](#validationresult)
Validation result with error details if invalid
#### See
[https://voltaire.tevm.sh/primitives/siwe](https://voltaire.tevm.sh/primitives/siwe) for SIWE documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Siwe from './primitives/Siwe/index.js';
const result = Siwe.validate(message);
if (!result.valid) {
console.error(result.error.message);
}
```
***
### create()
> **create**\<`TDomain`, `TAddress`, `TUri`, `TChainId`>(`params`): [`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
Defined in: [src/primitives/Siwe/index.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L110)
#### Type Parameters
##### TDomain
`TDomain` *extends* `string` = `string`
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TUri
`TUri` *extends* `string` = `string`
##### TChainId
`TChainId` *extends* `number` = `number`
#### Parameters
##### params
`CreateParams`\<`TDomain`, `TAddress`, `TUri`, `TChainId`>
#### Returns
[`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
***
### format()
> **format**(`message`): `string`
Defined in: [src/primitives/Siwe/index.ts:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L121)
#### Parameters
##### message
[`SiweMessageType`](#siwemessagetype)
#### Returns
`string`
***
### generateNonce()
> **generateNonce**(`length?`): `string`
Defined in: [src/primitives/Siwe/index.ts:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L125)
#### Parameters
##### length?
`number`
#### Returns
`string`
***
### parse()
> **parse**(`text`): [`SiweMessageType`](#siwemessagetype)
Defined in: [src/primitives/Siwe/index.ts:129](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L129)
#### Parameters
##### text
`string`
#### Returns
[`SiweMessageType`](#siwemessagetype)
***
### Siwe()
> **Siwe**\<`TDomain`, `TAddress`, `TUri`, `TChainId`>(`params`): [`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
Defined in: [src/primitives/Siwe/index.ts:170](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L170)
Factory function for creating SIWE Message instances
#### Type Parameters
##### TDomain
`TDomain` *extends* `string` = `string`
##### TAddress
`TAddress` *extends* [`AddressType`](Address.mdx#addresstype) = [`AddressType`](Address.mdx#addresstype)
##### TUri
`TUri` *extends* `string` = `string`
##### TChainId
`TChainId` *extends* `number` = `number`
#### Parameters
##### params
`CreateParams`\<`TDomain`, `TAddress`, `TUri`, `TChainId`>
#### Returns
[`SiweMessageType`](#siwemessagetype)\<`TDomain`, `TAddress`, `TUri`, `"1"`, `TChainId`>
***
### validate()
> **validate**(`message`, `options?`): [`ValidationResult`](#validationresult)
Defined in: [src/primitives/Siwe/index.ts:133](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Siwe/index.ts#L133)
#### Parameters
##### message
[`SiweMessageType`](#siwemessagetype)
##### options?
###### now?
`Date`
#### Returns
[`ValidationResult`](#validationresult)
## References
### getMessageHash
Renames and re-exports [\_getMessageHash](#_getmessagehash)
***
### verify
Renames and re-exports [\_verify](#_verify)
***
### verifyMessage
Renames and re-exports [\_verifyMessage](#_verifymessage)
# primitives/Slot
Source: https://voltaire.tevm.sh/generated-api/primitives/Slot
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Slot
# primitives/Slot
## Type Aliases
### SlotType
> **SlotType** = `bigint` & `object`
Defined in: [src/primitives/Slot/SlotType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/SlotType.ts#L13)
Slot type
Represents a consensus layer slot number (12 seconds per slot).
Slots are the fundamental unit of time in Ethereum's proof-of-stake consensus.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Slot"`
#### See
* [https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
* [https://github.com/ethereum/consensus-specs](https://github.com/ethereum/consensus-specs) for Consensus specifications
#### Since
0.0.0
## Variables
### Slot
> `const` **Slot**: `object`
Defined in: [src/primitives/Slot/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/index.ts#L11)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if Slot values are equal
###### Parameters
###### a
[`SlotType`](#slottype)
First slot
###### b
[`SlotType`](#slottype)
Second slot
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const a = Slot.from(1000000n);
const b = Slot.from(1000000n);
const result = Slot.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`SlotType`](#slottype)
Create Slot from number, bigint, or string
###### Parameters
###### value
Slot number (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
###### Returns
[`SlotType`](#slottype)
Slot value
###### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
###### Since
0.0.0
###### Throws
If value is negative or invalid
###### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot1 = Slot.from(1000000n);
const slot2 = Slot.from(1000000);
const slot3 = Slot.from("0xf4240");
```
##### toBigInt()
> **toBigInt**: (`slot`) => `bigint`
Convert Slot to bigint
###### Parameters
###### slot
[`SlotType`](#slottype)
Slot value
###### Returns
`bigint`
BigInt representation
###### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(1000000);
const big = Slot.toBigInt(slot); // 1000000n
```
##### toEpoch()
> **toEpoch**: (`slot`) => [`EpochType`](Epoch.mdx#epochtype)
Convert Slot to its corresponding Epoch
Each epoch contains 32 slots. This function performs integer division: epoch = slot / 32.
###### Parameters
###### slot
[`SlotType`](#slottype)
Slot value
###### Returns
[`EpochType`](Epoch.mdx#epochtype)
Epoch value
###### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(96n); // slot 96
const epoch = Slot.toEpoch(slot); // epoch 3 (96 / 32)
```
##### toNumber()
> **toNumber**: (`slot`) => `number`
Convert Slot to number
###### Parameters
###### slot
[`SlotType`](#slottype)
Slot value
###### Returns
`number`
Number representation
###### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
###### Since
0.0.0
###### Throws
If slot exceeds safe integer range
###### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(1000000n);
const num = Slot.toNumber(slot); // 1000000
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Slot/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/equals.js#L18)
Check if Slot values are equal
#### Parameters
##### a
[`SlotType`](#slottype)
First slot
##### b
[`SlotType`](#slottype)
Second slot
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const a = Slot.from(1000000n);
const b = Slot.from(1000000n);
const result = Slot.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`SlotType`](#slottype)
Defined in: [src/primitives/Slot/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/from.js#L17)
Create Slot from number, bigint, or string
#### Parameters
##### value
Slot number (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
#### Returns
[`SlotType`](#slottype)
Slot value
#### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
#### Since
0.0.0
#### Throws
If value is negative or invalid
#### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot1 = Slot.from(1000000n);
const slot2 = Slot.from(1000000);
const slot3 = Slot.from("0xf4240");
```
***
### toBigInt()
> **toBigInt**(`slot`): `bigint`
Defined in: [src/primitives/Slot/toBigInt.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/toBigInt.js#L16)
Convert Slot to bigint
#### Parameters
##### slot
[`SlotType`](#slottype)
Slot value
#### Returns
`bigint`
BigInt representation
#### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(1000000);
const big = Slot.toBigInt(slot); // 1000000n
```
***
### toEpoch()
> **toEpoch**(`slot`): [`EpochType`](Epoch.mdx#epochtype)
Defined in: [src/primitives/Slot/toEpoch.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/toEpoch.js#L20)
Convert Slot to its corresponding Epoch
Each epoch contains 32 slots. This function performs integer division: epoch = slot / 32.
#### Parameters
##### slot
[`SlotType`](#slottype)
Slot value
#### Returns
[`EpochType`](Epoch.mdx#epochtype)
Epoch value
#### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(96n); // slot 96
const epoch = Slot.toEpoch(slot); // epoch 3 (96 / 32)
```
***
### toNumber()
> **toNumber**(`slot`): `number`
Defined in: [src/primitives/Slot/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Slot/toNumber.js#L16)
Convert Slot to number
#### Parameters
##### slot
[`SlotType`](#slottype)
Slot value
#### Returns
`number`
Number representation
#### See
[https://voltaire.tevm.sh/primitives/slot](https://voltaire.tevm.sh/primitives/slot) for Slot documentation
#### Since
0.0.0
#### Throws
If slot exceeds safe integer range
#### Example
```javascript theme={null}
import * as Slot from './primitives/Slot/index.js';
const slot = Slot.from(1000000n);
const num = Slot.toNumber(slot); // 1000000
```
# primitives/SourceMap
Source: https://voltaire.tevm.sh/generated-api/primitives/SourceMap
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/SourceMap
# primitives/SourceMap
## Type Aliases
### SourceMap
> **SourceMap** = `object`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L26)
Solidity source map
Semicolon-separated entries mapping bytecode to source locations.
Format: "s:l:f:j:m;s:l:f:j:m;..."
#### Properties
##### entries
> `readonly` **entries**: readonly [`SourceMapEntry`](#sourcemapentry)\[]
Defined in: [src/primitives/SourceMap/SourceMapType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L30)
Parsed entries
##### raw
> `readonly` **raw**: `string`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L28)
Raw source map string
***
### SourceMapEntry
> **SourceMapEntry** = `object`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L7)
Solidity source map entry
Maps bytecode positions to source code locations.
Format: s:l:f:j:m (start:length:fileIndex:jump:modifierDepth)
#### Properties
##### fileIndex
> `readonly` **fileIndex**: `number`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L13)
Source file index
##### jump
> `readonly` **jump**: `"i"` | `"o"` | `"-"`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L15)
Jump type: 'i' (into), 'o' (out), '-' (regular)
##### length
> `readonly` **length**: `number`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L11)
Length in source code
##### modifierDepth?
> `readonly` `optional` **modifierDepth**: `number`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L17)
Modifier depth (optional)
##### start
> `readonly` **start**: `number`
Defined in: [src/primitives/SourceMap/SourceMapType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/SourceMapType.ts#L9)
Byte offset in source code
## Functions
### from()
> **from**(`raw`): [`SourceMap`](#sourcemap)
Defined in: [src/primitives/SourceMap/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/from.js#L17)
Create SourceMap from source map string
#### Parameters
##### raw
`string`
Source map string (semicolon-separated entries)
#### Returns
[`SourceMap`](#sourcemap)
SourceMap
#### See
* [https://voltaire.tevm.sh/primitives/source-map](https://voltaire.tevm.sh/primitives/source-map) for SourceMap documentation
* [https://docs.soliditylang.org/en/latest/internals/source\_mappings.html](https://docs.soliditylang.org/en/latest/internals/source_mappings.html)
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as SourceMap from './primitives/SourceMap/index.js';
const map = SourceMap.from("0:50:0:-;51:100:0:-;");
```
***
### getEntryAt()
> **getEntryAt**(`sourceMap`, `pc`): [`SourceMapEntry`](#sourcemapentry) | `undefined`
Defined in: [src/primitives/SourceMap/getEntryAt.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/getEntryAt.js#L14)
Get source map entry for specific bytecode position
#### Parameters
##### sourceMap
[`SourceMap`](#sourcemap)
SourceMap
##### pc
`number`
Program counter (bytecode offset)
#### Returns
[`SourceMapEntry`](#sourcemapentry) | `undefined`
Entry at position
#### Example
```javascript theme={null}
import * as SourceMap from './primitives/SourceMap/index.js';
const map = SourceMap.from("0:50:0:-;51:100:0:-;");
const entry = SourceMap.getEntryAt(map, 1);
```
***
### parse()
> **parse**(`raw`): [`SourceMap`](#sourcemap)
Defined in: [src/primitives/SourceMap/parse.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/parse.js#L17)
Parse source map string into entries
Solidity source map format: "s:l:f:j:m;s:l:f:j:m;..."
Fields can be omitted to inherit from previous entry (compression).
#### Parameters
##### raw
`string`
Source map string
#### Returns
[`SourceMap`](#sourcemap)
Parsed source map
#### Example
```javascript theme={null}
import * as SourceMap from './primitives/SourceMap/index.js';
const map = SourceMap.parse("0:50:0:-;51:100:0:-;151:25:0:o");
console.log(map.entries.length); // 3
```
***
### toEntries()
> **toEntries**(`raw`): readonly [`SourceMapEntry`](#sourcemapentry)\[]
Defined in: [src/primitives/SourceMap/toEntries.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/toEntries.js#L15)
Convert source map string to array of entries
#### Parameters
##### raw
`string`
Source map string
#### Returns
readonly [`SourceMapEntry`](#sourcemapentry)\[]
Parsed entries
#### Example
```javascript theme={null}
import * as SourceMap from './primitives/SourceMap/index.js';
const entries = SourceMap.toEntries("0:50:0:-;51:100:0:-;");
console.log(entries[0].start); // 0
```
***
### toString()
> **toString**(`sourceMap`): `string`
Defined in: [src/primitives/SourceMap/toString.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SourceMap/toString.js#L16)
Convert source map to compressed string format
Applies compression: omits fields that match previous entry.
#### Parameters
##### sourceMap
[`SourceMap`](#sourcemap)
SourceMap
#### Returns
`string`
Compressed source map string
#### Example
```javascript theme={null}
import * as SourceMap from './primitives/SourceMap/index.js';
const map = SourceMap.from("0:50:0:-;51:100:0:-;");
const str = SourceMap.toString(map);
```
# primitives/State
Source: https://voltaire.tevm.sh/generated-api/primitives/State
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/State
# primitives/State
## Type Aliases
### StorageKeyLike
> **StorageKeyLike** = [`StorageKeyType`](#storagekeytype) | \{ `address`: [`AddressType`](Address.mdx#addresstype); `slot`: `bigint`; }
Defined in: [src/primitives/State/StorageKeyType.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/StorageKeyType.ts#L57)
Inputs that can be converted to StorageKeyType
***
### StorageKeyType
> **StorageKeyType** = `object`
Defined in: [src/primitives/State/StorageKeyType.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/StorageKeyType.ts#L35)
Composite key for EVM storage operations combining address and slot.
The StorageKey uniquely identifies a storage location within the EVM by
combining a contract address with a 256-bit storage slot number. This is
fundamental to how the EVM organizes persistent contract storage.
## Design Rationale
Each smart contract has its own isolated storage space addressed by 256-bit
slots. To track storage across multiple contracts in a single VM instance,
we need a composite key that includes both the contract address and the
slot number.
## Storage Model
In the EVM:
* Each contract has 2^256 storage slots
* Each slot can store a 256-bit value
* Slots are initially zero and only consume gas when first written
#### Example
```typescript theme={null}
const key: StorageKeyType = {
address: myContractAddress,
slot: 0n, // First storage slot
};
// Use in maps for storage tracking
const storage = new Map();
const keyStr = StorageKey.toString(key);
storage.set(keyStr, value);
```
#### Properties
##### address
> `readonly` **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/State/StorageKeyType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/StorageKeyType.ts#L40)
The contract address that owns this storage slot.
Standard 20-byte Ethereum address.
##### slot
> `readonly` **slot**: `bigint`
Defined in: [src/primitives/State/StorageKeyType.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/StorageKeyType.ts#L46)
The 256-bit storage slot number within the contract's storage space.
Slots are sparsely allocated - most remain at zero value.
## Variables
### create()
> `const` **create**: (`address`, `slot`) => [`StorageKeyType`](#storagekeytype)
Defined in: [src/primitives/State/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L15)
#### Parameters
##### address
[`AddressType`](Address.mdx#addresstype)
##### slot
`bigint`
#### Returns
[`StorageKeyType`](#storagekeytype)
***
### EMPTY\_CODE\_HASH
> `const` **EMPTY\_CODE\_HASH**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/State/constants.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/constants.js#L21)
Hash of empty EVM bytecode (Keccak256 of empty bytes).
This is a well-known constant in Ethereum representing the Keccak256 hash
of an empty byte array. It's used to identify accounts with no associated
contract code.
Value: Keccak256("") = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { EMPTY_CODE_HASH } from './primitives/State/index.js';
if (codeHash.equals(EMPTY_CODE_HASH)) {
// Account has no code
}
```
***
### EMPTY\_TRIE\_ROOT
> `const` **EMPTY\_TRIE\_ROOT**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/State/constants.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/constants.js#L50)
Root hash of an empty Merkle Patricia Trie.
This is the root hash of an empty trie structure in Ethereum, used as
the initial value for account storage roots and state roots when they
contain no data.
Value: Keccak256(RLP(null)) = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { EMPTY_TRIE_ROOT } from './primitives/State/index.js';
if (storageRoot.equals(EMPTY_TRIE_ROOT)) {
// Account has no storage
}
```
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean`
Defined in: [src/primitives/State/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L24)
#### Parameters
##### a
[`StorageKeyLike`](#storagekeylike)
##### b
[`StorageKeyLike`](#storagekeylike)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`StorageKeyType`](#storagekeytype)
Defined in: [src/primitives/State/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L20)
#### Parameters
##### value
[`StorageKeyLike`](#storagekeylike)
#### Returns
[`StorageKeyType`](#storagekeytype)
***
### fromString()
> `const` **fromString**: (`str`) => [`StorageKeyType`](#storagekeytype) | `undefined`
Defined in: [src/primitives/State/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L32)
#### Parameters
##### str
`string`
#### Returns
[`StorageKeyType`](#storagekeytype) | `undefined`
***
### hashCode()
> `const` **hashCode**: (`key`) => `number`
Defined in: [src/primitives/State/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L36)
#### Parameters
##### key
[`StorageKeyLike`](#storagekeylike)
#### Returns
`number`
***
### is()
> `const` **is**: (`value`) => `value is StorageKeyType`
Defined in: [src/primitives/State/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L22)
#### Parameters
##### value
`unknown`
#### Returns
`value is StorageKeyType`
***
### StorageKey
> `const` **StorageKey**: `object`
Defined in: [src/primitives/State/index.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L50)
#### Type Declaration
##### create()
> **create**: (`address`, `slot`) => [`StorageKeyType`](#storagekeytype)
###### Parameters
###### address
[`AddressType`](Address.mdx#addresstype)
###### slot
`bigint`
###### Returns
[`StorageKeyType`](#storagekeytype)
##### equals()
> **equals**: (`a`, `b`) => `boolean`
###### Parameters
###### a
[`StorageKeyLike`](#storagekeylike)
###### b
[`StorageKeyLike`](#storagekeylike)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`StorageKeyType`](#storagekeytype)
###### Parameters
###### value
[`StorageKeyLike`](#storagekeylike)
###### Returns
[`StorageKeyType`](#storagekeytype)
##### fromString()
> **fromString**: (`str`) => [`StorageKeyType`](#storagekeytype) | `undefined`
###### Parameters
###### str
`string`
###### Returns
[`StorageKeyType`](#storagekeytype) | `undefined`
##### hashCode()
> **hashCode**: (`key`) => `number`
###### Parameters
###### key
[`StorageKeyLike`](#storagekeylike)
###### Returns
`number`
##### is()
> **is**: (`value`) => `value is StorageKeyType`
###### Parameters
###### value
`unknown`
###### Returns
`value is StorageKeyType`
##### toString()
> **toString**: (`key`) => `string`
###### Parameters
###### key
[`StorageKeyLike`](#storagekeylike)
###### Returns
`string`
***
### toString()
> `const` **toString**: (`key`) => `string`
Defined in: [src/primitives/State/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L30)
#### Parameters
##### key
[`StorageKeyLike`](#storagekeylike)
#### Returns
`string`
## Functions
### \_create()
> **\_create**(`address`, `slot`): [`StorageKeyType`](#storagekeytype)
Defined in: [src/primitives/State/create.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/create.js#L18)
Create a new StorageKey
#### Parameters
##### address
[`AddressType`](Address.mdx#addresstype)
Contract address
##### slot
`bigint`
Storage slot number
#### Returns
[`StorageKeyType`](#storagekeytype)
A new StorageKey
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
import * as Address from './primitives/Address/index.js';
const contractAddr = Address.fromHex('0x...');
const key = State.create(contractAddr, 0n);
```
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/State/equals.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/equals.js#L23)
Check equality between two storage keys.
Two storage keys are equal if and only if both their address and
slot number match exactly.
#### Parameters
##### a
[`StorageKeyLike`](#storagekeylike)
First storage key
##### b
[`StorageKeyLike`](#storagekeylike)
Second storage key
#### Returns
`boolean`
True if both address and slot match
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const key1 = { address: addr, slot: 0n };
const key2 = { address: addr, slot: 0n };
State.equals(key1, key2); // true
```
***
### \_from()
> **\_from**(`value`): [`StorageKeyType`](#storagekeytype)
Defined in: [src/primitives/State/from.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/from.js#L15)
Convert StorageKeyLike to StorageKey
#### Parameters
##### value
[`StorageKeyLike`](#storagekeylike)
Value to convert
#### Returns
[`StorageKeyType`](#storagekeytype)
StorageKey
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const key = State.from({ address: addr, slot: 0n });
```
***
### \_fromString()
> **\_fromString**(`str`): [`StorageKeyType`](#storagekeytype) | `undefined`
Defined in: [src/primitives/State/fromString.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/fromString.js#L18)
Parse a StorageKey from its string representation
#### Parameters
##### str
`string`
String representation from toString()
#### Returns
[`StorageKeyType`](#storagekeytype) | `undefined`
Parsed StorageKey or undefined if invalid
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const key = State.fromString(str);
if (key) {
// Use key
}
```
***
### \_hashCode()
> **\_hashCode**(`key`): `number`
Defined in: [src/primitives/State/hashCode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/hashCode.js#L17)
Compute a hash code for the storage key for use in hash-based collections
#### Parameters
##### key
[`StorageKeyLike`](#storagekeylike)
Storage key to hash
#### Returns
`number`
Hash code as a number
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const hash = State.hashCode(key);
```
***
### \_is()
> **\_is**(`value`): `value is StorageKeyType`
Defined in: [src/primitives/State/is.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/is.js#L18)
Type guard to check if a value is a valid StorageKey
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is StorageKeyType`
True if value is a valid StorageKey
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const key = { address: addr, slot: 0n };
if (State.is(key)) {
// key is StorageKey
}
```
***
### \_toString()
> **\_toString**(`key`): `string`
Defined in: [src/primitives/State/toString.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/toString.js#L23)
Convert StorageKey to a string representation for use as Map key
The string format is: address\_hex + "\_" + slot\_hex
#### Parameters
##### key
[`StorageKeyLike`](#storagekeylike)
Storage key to convert
#### Returns
`string`
String representation (address\_hex + "\_" + slot\_hex)
#### See
[https://voltaire.tevm.sh/primitives/state](https://voltaire.tevm.sh/primitives/state) for State documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as State from './primitives/State/index.js';
const key = { address: addr, slot: 42n };
const str = State.toString(key);
// Use as Map key
map.set(str, value);
```
***
### StorageKeyFactory()
> **StorageKeyFactory**(`address`, `slot`): [`StorageKeyType`](#storagekeytype)
Defined in: [src/primitives/State/index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/State/index.ts#L63)
Factory function for creating StorageKey instances
#### Parameters
##### address
[`AddressType`](Address.mdx#addresstype)
##### slot
`bigint`
#### Returns
[`StorageKeyType`](#storagekeytype)
## References
### default
Renames and re-exports [StorageKeyFactory](#storagekeyfactory)
# primitives/StateDiff
Source: https://voltaire.tevm.sh/generated-api/primitives/StateDiff
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StateDiff
# primitives/StateDiff
## Type Aliases
### AccountDiff
> **AccountDiff** = `object`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L37)
Account state changes during transaction execution
Captures all state modifications for a single account.
Used extensively by debug\_traceTransaction with prestateTracer.
#### Properties
##### balance?
> `readonly` `optional` **balance**: [`BalanceChange`](#balancechange)
Defined in: [src/primitives/StateDiff/StateDiffType.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L38)
##### code?
> `readonly` `optional` **code**: [`CodeChange`](#codechange)
Defined in: [src/primitives/StateDiff/StateDiffType.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L40)
##### nonce?
> `readonly` `optional` **nonce**: [`NonceChange`](#noncechange)
Defined in: [src/primitives/StateDiff/StateDiffType.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L39)
##### storage?
> `readonly` `optional` **storage**: `ReadonlyMap`\<[`StorageKeyType`](State.mdx#storagekeytype), \{ `from`: [`StorageValueType`](StorageValue.mdx#storagevaluetype) | `null`; `to`: [`StorageValueType`](StorageValue.mdx#storagevaluetype) | `null`; }>
Defined in: [src/primitives/StateDiff/StateDiffType.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L41)
***
### BalanceChange
> **BalanceChange** = `object`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L10)
Balance change (before/after)
#### Properties
##### from
> `readonly` **from**: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype) | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L11)
##### to
> `readonly` **to**: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype) | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L12)
***
### CodeChange
> **CodeChange** = `object`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L26)
Code change (before/after)
#### Properties
##### from
> `readonly` **from**: `Uint8Array` | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L27)
##### to
> `readonly` **to**: `Uint8Array` | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L28)
***
### NonceChange
> **NonceChange** = `object`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L18)
Nonce change (before/after)
#### Properties
##### from
> `readonly` **from**: [`NonceType`](Nonce.mdx#noncetype) | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L19)
##### to
> `readonly` **to**: [`NonceType`](Nonce.mdx#noncetype) | `null`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L20)
***
### StateDiffType
> **StateDiffType** = `object`
Defined in: [src/primitives/StateDiff/StateDiffType.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L71)
Complete state changes across all accounts
Represents full state diff from debug\_traceTransaction prestateTracer.
Maps addresses to their account-level changes.
#### Example
```typescript theme={null}
const stateDiff: StateDiffType = {
accounts: new Map([
[address1, {
balance: { from: oldBalance, to: newBalance },
nonce: { from: 0n, to: 1n },
storage: new Map([
[key, { from: null, to: value }]
])
}]
])
};
```
#### Properties
##### accounts
> `readonly` **accounts**: `ReadonlyMap`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
Defined in: [src/primitives/StateDiff/StateDiffType.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/StateDiffType.ts#L75)
Map of account addresses to their state changes
## Variables
### StateDiff
> `const` **StateDiff**: `object`
Defined in: [src/primitives/StateDiff/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/index.ts#L59)
#### Type Declaration
##### from()
> **from**: (`value`) => [`StateDiffType`](#statedifftype) = `_from`
Create StateDiff from account changes
###### Parameters
###### value
Account changes map, array, or object
`Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)> | \[[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)]\[] | \{ `accounts`: `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>; }
###### Returns
[`StateDiffType`](#statedifftype)
StateDiff
###### Example
```typescript theme={null}
const diff = StateDiff.from(new Map([[address, { balance: { from: 0n, to: 100n } }]]));
const diff2 = StateDiff.from([[address, { nonce: { from: 0n, to: 1n } }]]);
const diff3 = StateDiff.from({ accounts: accountsMap });
```
##### getAccount()
> **getAccount**: (`diff`, `address`) => [`AccountDiff`](#accountdiff) | `undefined`
###### Parameters
###### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
###### address
[`AddressType`](Address.mdx#addresstype)
###### Returns
[`AccountDiff`](#accountdiff) | `undefined`
##### getAddresses()
> **getAddresses**: (`diff`) => [`AddressType`](Address.mdx#addresstype)\[]
###### Parameters
###### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
###### Returns
[`AddressType`](Address.mdx#addresstype)\[]
##### isEmpty()
> **isEmpty**: (`diff`) => `boolean`
###### Parameters
###### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
###### Returns
`boolean`
## Functions
### \_getAccount()
> **\_getAccount**(`diff`, `address`): [`AccountDiff`](#accountdiff) | `undefined`
Defined in: [src/primitives/StateDiff/getAccount.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/getAccount.js#L16)
Get account diff for a specific address
#### Parameters
##### diff
[`StateDiffType`](#statedifftype)
State diff
##### address
[`AddressType`](Address.mdx#addresstype)
Address to look up
#### Returns
[`AccountDiff`](#accountdiff) | `undefined`
Account diff or undefined
#### Example
```typescript theme={null}
const accountDiff = StateDiff.getAccount(diff, address);
if (accountDiff?.balance) {
console.log(`Balance: ${accountDiff.balance.from} -> ${accountDiff.balance.to}`);
}
```
***
### \_getAddresses()
> **\_getAddresses**(`diff`): [`AddressType`](Address.mdx#addresstype)\[]
Defined in: [src/primitives/StateDiff/getAddresses.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/getAddresses.js#L15)
Get all addresses with state changes
#### Parameters
##### diff
[`StateDiffType`](#statedifftype)
State diff
#### Returns
[`AddressType`](Address.mdx#addresstype)\[]
Array of addresses
#### Example
```typescript theme={null}
const addresses = StateDiff.getAddresses(diff);
for (const addr of addresses) {
console.log(`Account ${Address.toHex(addr)} changed`);
}
```
***
### \_isEmpty()
> **\_isEmpty**(`diff`): `boolean`
Defined in: [src/primitives/StateDiff/isEmpty.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/isEmpty.js#L14)
Check if state diff has any changes
#### Parameters
##### diff
[`StateDiffType`](#statedifftype)
State diff
#### Returns
`boolean`
True if no accounts have changes
#### Example
```typescript theme={null}
if (!StateDiff.isEmpty(diff)) {
console.log("State was modified");
}
```
***
### from()
> **from**(`value`): [`StateDiffType`](#statedifftype)
Defined in: [src/primitives/StateDiff/from.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/from.js#L14)
Create StateDiff from account changes
#### Parameters
##### value
Account changes map, array, or object
`Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)> | \[[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)]\[] | \{ `accounts`: `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>; }
#### Returns
[`StateDiffType`](#statedifftype)
StateDiff
#### Example
```typescript theme={null}
const diff = StateDiff.from(new Map([[address, { balance: { from: 0n, to: 100n } }]]));
const diff2 = StateDiff.from([[address, { nonce: { from: 0n, to: 1n } }]]);
const diff3 = StateDiff.from({ accounts: accountsMap });
```
***
### getAccount()
> **getAccount**(`diff`, `address`): [`AccountDiff`](#accountdiff) | `undefined`
Defined in: [src/primitives/StateDiff/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/index.ts#L18)
#### Parameters
##### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
##### address
[`AddressType`](Address.mdx#addresstype)
#### Returns
[`AccountDiff`](#accountdiff) | `undefined`
***
### getAddresses()
> **getAddresses**(`diff`): [`AddressType`](Address.mdx#addresstype)\[]
Defined in: [src/primitives/StateDiff/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/index.ts#L31)
#### Parameters
##### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
#### Returns
[`AddressType`](Address.mdx#addresstype)\[]
***
### isEmpty()
> **isEmpty**(`diff`): `boolean`
Defined in: [src/primitives/StateDiff/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateDiff/index.ts#L43)
#### Parameters
##### diff
[`StateDiffType`](#statedifftype) | `Map`\<[`AddressType`](Address.mdx#addresstype), [`AccountDiff`](#accountdiff)>
#### Returns
`boolean`
# primitives/StateProof
Source: https://voltaire.tevm.sh/generated-api/primitives/StateProof
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StateProof
# primitives/StateProof
## Type Aliases
### StateProofLike
> **StateProofLike** = [`StateProofType`](#stateprooftype) | \{ `accountProof`: readonly `Uint8Array`\[]; `address`: [`AddressType`](Address.mdx#addresstype); `balance`: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype); `codeHash`: [`HashType`](../index/namespaces/HashType.mdx#hashtype); `nonce`: [`NonceType`](Nonce.mdx#noncetype); `storageHash`: [`StateRootType`](StateRoot.mdx#stateroottype); `storageProof`: readonly [`StorageProofType`](StorageProof.mdx#storageprooftype)\[]; }
Defined in: [src/primitives/StateProof/StateProofType.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L73)
Inputs that can be converted to StateProof
***
### StateProofType
> **StateProofType** = `object`
Defined in: [src/primitives/StateProof/StateProofType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L28)
StateProof represents an EIP-1186 account proof with storage proofs.
EIP-1186 defines a standard for providing Merkle proofs of account state and
storage values. This enables light clients and trustless systems to verify
account data without executing transactions or trusting external providers.
The proof structure includes:
* Account proof: RLP-encoded Merkle Patricia Trie nodes from state root to account
* Account fields: nonce, balance, codeHash, storageHash from the proven block
* Storage proofs: Optional array of proofs for specific storage slots
Verification process:
1. Verify account proof against known state root
2. Reconstruct account state from proof
3. Verify each storage proof against account's storage root
#### See
* EIP-1186: [https://eips.ethereum.org/EIPS/eip-1186](https://eips.ethereum.org/EIPS/eip-1186)
* JSON-RPC eth\_getProof method
#### Properties
##### accountProof
> `readonly` **accountProof**: readonly `Uint8Array`\[]
Defined in: [src/primitives/StateProof/StateProofType.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L39)
Array of RLP-encoded Merkle Patricia Trie nodes.
Forms the path from the state root to this account's leaf node.
Nodes are ordered from root to leaf.
##### address
> `readonly` **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/StateProof/StateProofType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L32)
The address of the account being proven.
##### balance
> `readonly` **balance**: [`WeiType`](../index/namespaces/BrandedWei.mdx#weitype)
Defined in: [src/primitives/StateProof/StateProofType.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L44)
Account balance in Wei at the proven block.
##### codeHash
> `readonly` **codeHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/StateProof/StateProofType.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L50)
Keccak256 hash of the account's bytecode.
For EOAs, this is the empty code hash.
##### nonce
> `readonly` **nonce**: [`NonceType`](Nonce.mdx#noncetype)
Defined in: [src/primitives/StateProof/StateProofType.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L55)
Transaction count (EOA) or contract creation count.
##### storageHash
> `readonly` **storageHash**: [`StateRootType`](StateRoot.mdx#stateroottype)
Defined in: [src/primitives/StateProof/StateProofType.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L61)
Root hash of the account's storage trie.
Storage proofs must verify against this root.
##### storageProof
> `readonly` **storageProof**: readonly [`StorageProofType`](StorageProof.mdx#storageprooftype)\[]
Defined in: [src/primitives/StateProof/StateProofType.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/StateProofType.ts#L67)
Array of proofs for specific storage slots.
Each proof demonstrates a key-value pair in the account's storage.
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/StateProof/equals.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/equals.js#L26)
Compares two StateProofs for equality.
All fields must match including all storage proofs.
#### Parameters
##### a
[`StateProofType`](#stateprooftype)
First StateProof
##### b
[`StateProofType`](#stateprooftype)
Second StateProof
#### Returns
`boolean`
* True if equal
#### Example
```typescript theme={null}
const isEqual = StateProof.equals(proof1, proof2);
```
***
### from()
> **from**(`proof`): [`StateProofType`](#stateprooftype)
Defined in: [src/primitives/StateProof/from.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateProof/from.js#L28)
Creates a StateProof from an object with all required fields.
#### Parameters
##### proof
[`StateProofLike`](#stateprooflike)
Object containing all StateProof fields
#### Returns
[`StateProofType`](#stateprooftype)
* A validated StateProof
#### Example
```typescript theme={null}
const proof = StateProof.from({
address: Address.from("0x..."),
accountProof: [node1, node2, node3],
balance: Wei.from(1000000000000000000n),
codeHash: Hash.from("0x..."),
nonce: Nonce.from(5n),
storageHash: StateRoot.from("0x..."),
storageProof: [storageProof1, storageProof2],
});
```
# primitives/StateRoot
Source: https://voltaire.tevm.sh/generated-api/primitives/StateRoot
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StateRoot
# primitives/StateRoot
## Type Aliases
### StateRootLike
> **StateRootLike** = [`StateRootType`](#stateroottype) | `string` | `Uint8Array`
Defined in: [src/primitives/StateRoot/StateRootType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/StateRootType.ts#L23)
Inputs that can be converted to StateRoot
***
### StateRootType
> **StateRootType** = `Uint8Array` & `object`
Defined in: [src/primitives/StateRoot/StateRootType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/StateRootType.ts#L15)
Branded StateRoot type - represents a 32-byte Merkle Patricia Trie root hash
of the global Ethereum state.
The state root is the root hash of the state trie, which contains mappings
from addresses to account states. It uniquely identifies the entire global
state at a given block.
Per the Yellow Paper, the state trie encodes mappings between addresses
(160-bit identifiers) and account states. The state root is included in
every block header.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"StateRoot"`
##### length
> `readonly` **length**: `32`
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/StateRoot/StateRootType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/StateRootType.ts#L25)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/StateRoot/equals.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/equals.js#L20)
Compares two StateRoots for equality.
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### a
[`StateRootType`](#stateroottype)
First StateRoot
##### b
[`StateRootType`](#stateroottype)
Second StateRoot
#### Returns
`boolean`
* True if equal
#### Example
```typescript theme={null}
const isEqual = StateRoot.equals(root1, root2);
```
***
### from()
> **from**(`value`): [`StateRootType`](#stateroottype)
Defined in: [src/primitives/StateRoot/from.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/from.js#L21)
Creates a StateRoot from various input types.
Accepts hex strings, Uint8Array, or existing StateRoot instances.
#### Parameters
##### value
[`StateRootLike`](#staterootlike)
The value to convert
#### Returns
[`StateRootType`](#stateroottype)
* A branded StateRoot
#### Example
```typescript theme={null}
const root = StateRoot.from("0x1234...");
const root2 = StateRoot.from(new Uint8Array(32));
```
***
### fromHex()
> **fromHex**(`hex`): [`StateRootType`](#stateroottype)
Defined in: [src/primitives/StateRoot/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/fromHex.js#L18)
Creates a StateRoot from a hex string.
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`StateRootType`](#stateroottype)
* A branded StateRoot
#### Example
```typescript theme={null}
const root = StateRoot.fromHex("0x1234...");
```
***
### toHex()
> **toHex**(`stateRoot`): `string`
Defined in: [src/primitives/StateRoot/toHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StateRoot/toHex.js#L19)
Converts a StateRoot to a hex string.
#### Parameters
##### stateRoot
[`StateRootType`](#stateroottype)
The StateRoot to convert
#### Returns
`string`
* Hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = StateRoot.toHex(root);
// "0x1234..."
```
# primitives/StealthAddress
Source: https://voltaire.tevm.sh/generated-api/primitives/StealthAddress
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StealthAddress
# primitives/StealthAddress
## Classes
### InvalidAnnouncementError
Defined in: [src/primitives/StealthAddress/errors.js:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L60)
Invalid announcement format
#### Extends
* [`StealthAddressError`](#stealthaddresserror)
#### Constructors
##### Constructor
> **new InvalidAnnouncementError**(`message`, `options`): [`InvalidAnnouncementError`](#invalidannouncementerror)
Defined in: [src/primitives/StealthAddress/errors.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L61)
###### Parameters
###### message
`any`
###### options
###### Returns
[`InvalidAnnouncementError`](#invalidannouncementerror)
###### Overrides
[`StealthAddressError`](#stealthaddresserror).[`constructor`](#constructor-4)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`cause`](#cause-4)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`code`](#code-4)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`context`](#context-4)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`docsPath`](#docspath-4)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L66)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`name`](#name-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`getErrorChain`](#geterrorchain-8)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`toJSON`](#tojson-8)
***
### InvalidEphemeralPublicKeyError
Defined in: [src/primitives/StealthAddress/errors.js:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L47)
Invalid ephemeral public key
#### Extends
* [`StealthAddressError`](#stealthaddresserror)
#### Constructors
##### Constructor
> **new InvalidEphemeralPublicKeyError**(`message`, `options`): [`InvalidEphemeralPublicKeyError`](#invalidephemeralpublickeyerror)
Defined in: [src/primitives/StealthAddress/errors.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L48)
###### Parameters
###### message
`any`
###### options
###### Returns
[`InvalidEphemeralPublicKeyError`](#invalidephemeralpublickeyerror)
###### Overrides
[`StealthAddressError`](#stealthaddresserror).[`constructor`](#constructor-4)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`cause`](#cause-4)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`code`](#code-4)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`context`](#context-4)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`docsPath`](#docspath-4)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L53)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`name`](#name-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`getErrorChain`](#geterrorchain-8)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`toJSON`](#tojson-8)
***
### InvalidPublicKeyError
Defined in: [src/primitives/StealthAddress/errors.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L34)
Invalid public key format or length
#### Extends
* [`StealthAddressError`](#stealthaddresserror)
#### Constructors
##### Constructor
> **new InvalidPublicKeyError**(`message`, `options`): [`InvalidPublicKeyError`](#invalidpublickeyerror)
Defined in: [src/primitives/StealthAddress/errors.js:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L35)
###### Parameters
###### message
`any`
###### options
###### Returns
[`InvalidPublicKeyError`](#invalidpublickeyerror)
###### Overrides
[`StealthAddressError`](#stealthaddresserror).[`constructor`](#constructor-4)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`cause`](#cause-4)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`code`](#code-4)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`context`](#context-4)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`docsPath`](#docspath-4)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L40)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`name`](#name-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`getErrorChain`](#geterrorchain-8)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`toJSON`](#tojson-8)
***
### InvalidStealthMetaAddressError
Defined in: [src/primitives/StealthAddress/errors.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L21)
Invalid stealth meta-address format or length
#### Extends
* [`StealthAddressError`](#stealthaddresserror)
#### Constructors
##### Constructor
> **new InvalidStealthMetaAddressError**(`message`, `options`): [`InvalidStealthMetaAddressError`](#invalidstealthmetaaddresserror)
Defined in: [src/primitives/StealthAddress/errors.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L22)
###### Parameters
###### message
`any`
###### options
###### Returns
[`InvalidStealthMetaAddressError`](#invalidstealthmetaaddresserror)
###### Overrides
[`StealthAddressError`](#stealthaddresserror).[`constructor`](#constructor-4)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`cause`](#cause-4)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`code`](#code-4)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`context`](#context-4)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`docsPath`](#docspath-4)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L27)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`name`](#name-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`getErrorChain`](#geterrorchain-8)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`toJSON`](#tojson-8)
***
### StealthAddressError
Defined in: [src/primitives/StealthAddress/errors.js:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L7)
Base error for StealthAddress operations
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Extended by
* [`InvalidStealthMetaAddressError`](#invalidstealthmetaaddresserror)
* [`InvalidPublicKeyError`](#invalidpublickeyerror)
* [`InvalidEphemeralPublicKeyError`](#invalidephemeralpublickeyerror)
* [`InvalidAnnouncementError`](#invalidannouncementerror)
* [`StealthAddressGenerationError`](#stealthaddressgenerationerror)
#### Constructors
##### Constructor
> **new StealthAddressError**(`message`, `options`): [`StealthAddressError`](#stealthaddresserror)
Defined in: [src/primitives/StealthAddress/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L8)
###### Parameters
###### message
`any`
###### options
###### Returns
[`StealthAddressError`](#stealthaddresserror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L14)
###### Inherited from
`PrimitiveError.name`
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
***
### StealthAddressGenerationError
Defined in: [src/primitives/StealthAddress/errors.js:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L73)
Stealth address generation failed
#### Extends
* [`StealthAddressError`](#stealthaddresserror)
#### Constructors
##### Constructor
> **new StealthAddressGenerationError**(`message`, `options`): [`StealthAddressGenerationError`](#stealthaddressgenerationerror)
Defined in: [src/primitives/StealthAddress/errors.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L74)
###### Parameters
###### message
`any`
###### options
###### Returns
[`StealthAddressGenerationError`](#stealthaddressgenerationerror)
###### Overrides
[`StealthAddressError`](#stealthaddresserror).[`constructor`](#constructor-4)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`cause`](#cause-4)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`code`](#code-4)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`context`](#context-4)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`docsPath`](#docspath-4)
##### name
> **name**: `string`
Defined in: [src/primitives/StealthAddress/errors.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/errors.js#L79)
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`name`](#name-4)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`getErrorChain`](#geterrorchain-8)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`StealthAddressError`](#stealthaddresserror).[`toJSON`](#tojson-8)
## Interfaces
### CheckStealthAddressResult
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L92)
Result of stealth address checking
#### Properties
##### isForRecipient
> **isForRecipient**: `boolean`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L93)
##### stealthPrivateKey?
> `optional` **stealthPrivateKey**: `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L94)
***
### GenerateStealthAddressResult
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L83)
Result of stealth address generation
#### Properties
##### ephemeralPublicKey
> **ephemeralPublicKey**: [`EphemeralPublicKey`](#ephemeralpublickey-2)
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L85)
##### stealthAddress
> **stealthAddress**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L84)
##### viewTag
> **viewTag**: `number`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L86)
***
### StealthAnnouncement
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L74)
Stealth address announcement
On-chain data published by sender containing ephemeral public key
and view tag. Enables recipient to scan for stealth addresses.
#### Properties
##### ephemeralPublicKey
> **ephemeralPublicKey**: [`EphemeralPublicKey`](#ephemeralpublickey-2)
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L75)
##### stealthAddress
> **stealthAddress**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L77)
##### viewTag
> **viewTag**: `number`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L76)
## Type Aliases
### EphemeralPublicKey
> **EphemeralPublicKey** = `Uint8Array` & `object`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L55)
Ephemeral public key (33 bytes compressed)
One-time public key generated by sender and announced on-chain.
Used by recipient to derive shared secret for stealth address detection.
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"EphemeralPublicKey"`
***
### SpendingPublicKey
> **SpendingPublicKey** = `Uint8Array` & `object`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L35)
Spending public key (33 bytes compressed)
Compressed secp256k1 public key used for deriving stealth addresses.
Recipient uses corresponding private key to spend from stealth addresses.
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"SpendingPublicKey"`
***
### StealthMetaAddress
> **StealthMetaAddress** = `Uint8Array` & `object`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L25)
Stealth meta-address (66 bytes)
Concatenation of spending public key (33 bytes compressed) and
viewing public key (33 bytes compressed). Published by recipient
to enable non-interactive stealth address generation.
Format: spendingPubKey (33) || viewingPubKey (33)
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"StealthMetaAddress"`
#### See
[https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format](https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format)
***
### ViewingPublicKey
> **ViewingPublicKey** = `Uint8Array` & `object`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L45)
Viewing public key (33 bytes compressed)
Compressed secp256k1 public key used for scanning blockchain.
Recipient uses corresponding private key to detect stealth addresses.
#### Type Declaration
##### \_\_tag
> `readonly` **\_\_tag**: `"ViewingPublicKey"`
***
### ViewTag
> **ViewTag** = `number`
Defined in: [src/primitives/StealthAddress/StealthAddressType.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/StealthAddressType.ts#L66)
View tag (1 byte)
First byte of hashed shared secret. Enables fast rejection
of non-matching stealth addresses (\~255/256 probability).
Reduces scanning overhead by \~6x.
## Variables
### COMPRESSED\_PUBLIC\_KEY\_SIZE
> `const` **COMPRESSED\_PUBLIC\_KEY\_SIZE**: `33` = `33`
Defined in: [src/primitives/StealthAddress/constants.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L19)
Compressed public key length (33 bytes)
Format: 0x02/0x03 prefix + x-coordinate (32 bytes)
***
### PRIVATE\_KEY\_SIZE
> `const` **PRIVATE\_KEY\_SIZE**: `32` = `32`
Defined in: [src/primitives/StealthAddress/constants.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L30)
Private key length (32 bytes)
***
### SCHEME\_ID
> `const` **SCHEME\_ID**: `1` = `1`
Defined in: [src/primitives/StealthAddress/constants.js:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L41)
ERC-5564 scheme ID for SECP256k1 with view tags
***
### STEALTH\_META\_ADDRESS\_SIZE
> `const` **STEALTH\_META\_ADDRESS\_SIZE**: `66` = `66`
Defined in: [src/primitives/StealthAddress/constants.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L13)
Stealth meta-address length (66 bytes)
Format: spendingPubKey (33) || viewingPubKey (33)
***
### UNCOMPRESSED\_PUBLIC\_KEY\_SIZE
> `const` **UNCOMPRESSED\_PUBLIC\_KEY\_SIZE**: `64` = `64`
Defined in: [src/primitives/StealthAddress/constants.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L25)
Uncompressed public key length (64 bytes)
Format: x-coordinate (32) || y-coordinate (32)
***
### VIEW\_TAG\_SIZE
> `const` **VIEW\_TAG\_SIZE**: `1` = `1`
Defined in: [src/primitives/StealthAddress/constants.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/constants.js#L36)
View tag size (1 byte)
First byte of hashed shared secret
## Functions
### checkStealthAddress()
> **checkStealthAddress**(`viewingPrivateKey`, `ephemeralPublicKey`, `viewTag`, `spendingPublicKey`, `stealthAddress`): [`CheckStealthAddressResult`](#checkstealthaddressresult)
Defined in: [src/primitives/StealthAddress/checkStealthAddress.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/checkStealthAddress.js#L48)
Check if stealth address belongs to recipient
Implements ERC-5564 stealth address checking:
1. Compute shared secret: ECDH(viewingPrivKey, ephemeralPubKey)
2. Hash shared secret
3. Check view tag matches (fast rejection)
4. If matches, compute stealth private key
5. Derive address and verify match
#### Parameters
##### viewingPrivateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte viewing private key
##### ephemeralPublicKey
[`EphemeralPublicKey`](#ephemeralpublickey-2)
33-byte compressed ephemeral public key
##### viewTag
`number`
View tag from announcement
##### spendingPublicKey
[`SpendingPublicKey`](#spendingpublickey)
33-byte compressed spending public key
##### stealthAddress
[`AddressType`](Address.mdx#addresstype)
Announced stealth address
#### Returns
[`CheckStealthAddressResult`](#checkstealthaddressresult)
Match result with optional stealth private key
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#stealth-address-checking](https://eips.ethereum.org/EIPS/eip-5564#stealth-address-checking)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
// Recipient scans announcements
const result = StealthAddress.checkStealthAddress(
viewingPrivateKey,
announcement.ephemeralPublicKey,
announcement.viewTag,
spendingPublicKey,
announcement.stealthAddress
);
if (result.isForRecipient) {
console.log('Found stealth payment!');
// Use result.stealthPrivateKey to spend
}
```
***
### compressPublicKey()
> **compressPublicKey**(`uncompressed`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/StealthAddress/compressPublicKey.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/compressPublicKey.js#L27)
Compress uncompressed secp256k1 public key
Converts 64-byte uncompressed format (x, y) to 33-byte compressed format.
Uses 0x02 prefix if y is even, 0x03 if y is odd.
#### Parameters
##### uncompressed
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
33-byte compressed public key
#### See
[https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If input length is invalid
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
const uncompressed = new Uint8Array(64); // x || y
const compressed = StealthAddress.compressPublicKey(uncompressed);
console.log(compressed.length); // 33
```
***
### computeStealthPrivateKey()
> **computeStealthPrivateKey**(`spendingPrivateKey`, `hashedSharedSecret`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/StealthAddress/computeStealthPrivateKey.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/computeStealthPrivateKey.js#L32)
Compute stealth private key from spending private key and shared secret hash
Implements ERC-5564 private key derivation:
stealthPrivateKey = (spendingPrivateKey + hashedSharedSecret) mod n
Where n is the secp256k1 curve order.
#### Parameters
##### spendingPrivateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte spending private key
##### hashedSharedSecret
`Uint8Array`\<`ArrayBufferLike`>
32-byte hashed shared secret
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte stealth private key
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#stealth-private-key](https://eips.ethereum.org/EIPS/eip-5564#stealth-private-key)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If computation fails
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
// After finding matching stealth address
const stealthPrivKey = StealthAddress.computeStealthPrivateKey(
spendingPrivateKey,
hashedSharedSecret
);
// Use stealthPrivKey to spend from stealth address
```
***
### computeViewTag()
> **computeViewTag**(`hashedSharedSecret`): `number`
Defined in: [src/primitives/StealthAddress/computeViewTag.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/computeViewTag.js#L26)
Compute view tag from hashed shared secret
Extracts first byte of hashed shared secret as view tag.
Enables fast rejection of non-matching stealth addresses.
#### Parameters
##### hashedSharedSecret
`Uint8Array`\<`ArrayBufferLike`>
32-byte keccak256 hash of shared secret
#### Returns
`number`
View tag (first byte as number)
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#view-tags](https://eips.ethereum.org/EIPS/eip-5564#view-tags)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
import * as Keccak256 from './crypto/Keccak256/index.js';
const sharedSecret = new Uint8Array(32);
const hash = Keccak256.hash(sharedSecret);
const viewTag = StealthAddress.computeViewTag(hash);
console.log(typeof viewTag); // 'number'
console.log(viewTag >= 0 && viewTag <= 255); // true
```
***
### decompressPublicKey()
> **decompressPublicKey**(`compressed`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/StealthAddress/decompressPublicKey.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/decompressPublicKey.js#L26)
Decompress compressed secp256k1 public key
Converts 33-byte compressed format to 64-byte uncompressed format.
Decompresses by reconstructing y-coordinate from x and prefix.
#### Parameters
##### compressed
`Uint8Array`\<`ArrayBufferLike`>
33-byte compressed public key
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
64-byte uncompressed public key
#### See
[https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If input length is invalid or decompression fails
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
const compressed = new Uint8Array(33);
compressed[0] = 0x02; // even y
const uncompressed = StealthAddress.decompressPublicKey(compressed);
console.log(uncompressed.length); // 64
```
***
### generateMetaAddress()
> **generateMetaAddress**(`spendingPubKey`, `viewingPubKey`): [`StealthMetaAddress`](#stealthmetaaddress)
Defined in: [src/primitives/StealthAddress/generateMetaAddress.js:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/generateMetaAddress.js#L36)
Generate stealth meta-address from spending and viewing public keys
Concatenates 33-byte compressed spending and viewing public keys
into 66-byte stealth meta-address for ERC-5564.
#### Parameters
##### spendingPubKey
[`SpendingPublicKey`](#spendingpublickey)
33-byte compressed spending public key
##### viewingPubKey
[`ViewingPublicKey`](#viewingpublickey)
33-byte compressed viewing public key
#### Returns
[`StealthMetaAddress`](#stealthmetaaddress)
66-byte stealth meta-address
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format](https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If either public key has invalid length
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
import * as Secp256k1 from './crypto/Secp256k1/index.js';
const spendingPubKey = StealthAddress.compressPublicKey(
Secp256k1.derivePublicKey(spendingPrivateKey)
);
const viewingPubKey = StealthAddress.compressPublicKey(
Secp256k1.derivePublicKey(viewingPrivateKey)
);
const metaAddress = StealthAddress.generateMetaAddress(spendingPubKey, viewingPubKey);
console.log(metaAddress.length); // 66
```
***
### generateStealthAddress()
> **generateStealthAddress**(`metaAddress`, `ephemeralPrivateKey`): [`GenerateStealthAddressResult`](#generatestealthaddressresult)
Defined in: [src/primitives/StealthAddress/generateStealthAddress.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/generateStealthAddress.js#L48)
Generate stealth address from meta-address
Implements ERC-5564 stealth address generation:
1. Parse meta-address → spending + viewing public keys
2. Compute shared secret: ECDH(ephemeralPrivKey, viewingPubKey)
3. Hash shared secret: keccak256(sharedSecret)
4. Derive view tag: first byte of hash
5. Compute stealth pubkey: spendingPubKey + hash \* G
6. Derive stealth address from pubkey
#### Parameters
##### metaAddress
[`StealthMetaAddress`](#stealthmetaaddress)
66-byte stealth meta-address
##### ephemeralPrivateKey
`Uint8Array`\<`ArrayBufferLike`>
32-byte ephemeral private key
#### Returns
[`GenerateStealthAddressResult`](#generatestealthaddressresult)
Stealth address, ephemeral pubkey, view tag
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#stealth-address-generation](https://eips.ethereum.org/EIPS/eip-5564#stealth-address-generation)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If generation fails
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
import * as Secp256k1 from './crypto/Secp256k1/index.js';
// Recipient publishes meta-address
const metaAddress = StealthAddress.generateMetaAddress(spendingPubKey, viewingPubKey);
// Sender generates stealth address
const ephemeralPrivKey = new Uint8Array(32);
crypto.getRandomValues(ephemeralPrivKey);
const result = StealthAddress.generateStealthAddress(metaAddress, ephemeralPrivKey);
console.log(result.stealthAddress); // 20-byte address
console.log(result.ephemeralPublicKey); // 33-byte compressed pubkey
console.log(result.viewTag); // 0-255
```
***
### parseAnnouncement()
> **parseAnnouncement**(`announcement`): `object`
Defined in: [src/primitives/StealthAddress/parseAnnouncement.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/parseAnnouncement.js#L26)
Parse stealth address announcement
Extracts ephemeral public key (33 bytes) and view tag (1 byte)
from announcement data.
#### Parameters
##### announcement
`Uint8Array`\<`ArrayBufferLike`>
Announcement bytes (ephemeralPubKey + viewTag)
#### Returns
`object`
Parsed announcement
##### ephemeralPublicKey
> **ephemeralPublicKey**: [`EphemeralPublicKey`](#ephemeralpublickey-2)
##### viewTag
> **viewTag**: `number`
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#announcement-format](https://eips.ethereum.org/EIPS/eip-5564#announcement-format)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If announcement length is invalid
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
const announcement = new Uint8Array(34); // 33 + 1
const { ephemeralPublicKey, viewTag } = StealthAddress.parseAnnouncement(announcement);
console.log(ephemeralPublicKey.length); // 33
console.log(typeof viewTag); // 'number'
```
***
### parseMetaAddress()
> **parseMetaAddress**(`metaAddress`): `object`
Defined in: [src/primitives/StealthAddress/parseMetaAddress.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StealthAddress/parseMetaAddress.js#L28)
Parse stealth meta-address into spending and viewing public keys
Splits 66-byte meta-address into 33-byte compressed public keys.
#### Parameters
##### metaAddress
[`StealthMetaAddress`](#stealthmetaaddress)
66-byte stealth meta-address
#### Returns
`object`
Parsed public keys
##### spendingPubKey
> **spendingPubKey**: [`SpendingPublicKey`](#spendingpublickey)
##### viewingPubKey
> **viewingPubKey**: [`ViewingPublicKey`](#viewingpublickey)
#### See
* [https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format](https://eips.ethereum.org/EIPS/eip-5564#stealth-meta-address-format)
* [https://voltaire.tevm.sh/primitives/stealth-address](https://voltaire.tevm.sh/primitives/stealth-address) for StealthAddress documentation
#### Since
0.0.0
#### Throws
If meta-address length is invalid
#### Example
```javascript theme={null}
import * as StealthAddress from './primitives/StealthAddress/index.js';
const metaAddress = new Uint8Array(66);
const { spendingPubKey, viewingPubKey } = StealthAddress.parseMetaAddress(metaAddress);
console.log(spendingPubKey.length); // 33
console.log(viewingPubKey.length); // 33
```
# primitives/StorageDiff
Source: https://voltaire.tevm.sh/generated-api/primitives/StorageDiff
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StorageDiff
# primitives/StorageDiff
## Type Aliases
### StorageChange
> **StorageChange** = `object`
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L11)
Storage slot change for a single account
Tracks before/after values for storage slots.
null indicates slot didn't exist (before) or was deleted (after).
#### Properties
##### from
> `readonly` **from**: [`StorageValueType`](StorageValue.mdx#storagevaluetype) | `null`
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L12)
##### to
> `readonly` **to**: [`StorageValueType`](StorageValue.mdx#storagevaluetype) | `null`
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L13)
***
### StorageDiffType
> **StorageDiffType** = `object`
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L32)
Storage changes for an account during transaction execution
Maps storage slots to their before/after values.
Used for state diff analysis, particularly with debug\_traceTransaction.
#### Example
```typescript theme={null}
const diff: StorageDiffType = {
address: myAddress,
changes: new Map([
[{ address: myAddress, slot: 0n }, { from: oldValue, to: newValue }],
]),
};
```
#### Properties
##### address
> `readonly` **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L36)
Contract address for these storage changes
##### changes
> `readonly` **changes**: `ReadonlyMap`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>
Defined in: [src/primitives/StorageDiff/StorageDiffType.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/StorageDiffType.ts#L43)
Map of storage slot changes
Key: StorageKey (address + slot)
Value: Before/after storage values
## Variables
### StorageDiff
> `const` **StorageDiff**: `object`
Defined in: [src/primitives/StorageDiff/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/index.ts#L65)
#### Type Declaration
##### from()
> **from**: (`address`, `changes`) => [`StorageDiffType`](#storagedifftype) = `_from`
Create StorageDiff from address and changes
###### Parameters
###### address
[`AddressType`](Address.mdx#addresstype)
Contract address
###### changes
Storage changes
`Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)> | \[[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)]\[]
###### Returns
[`StorageDiffType`](#storagedifftype)
StorageDiff
###### Example
```typescript theme={null}
const diff = StorageDiff.from(address, new Map([[key, { from: null, to: value }]]));
const diff2 = StorageDiff.from(address, [[key, { from: oldVal, to: newVal }]]);
```
##### getChange()
> **getChange**: (`diff`, `key`) => [`StorageChange`](#storagechange) | `undefined`
###### Parameters
###### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
###### key
[`StorageKeyType`](State.mdx#storagekeytype)
###### Returns
[`StorageChange`](#storagechange) | `undefined`
##### getKeys()
> **getKeys**: (`diff`) => [`StorageKeyType`](State.mdx#storagekeytype)\[]
###### Parameters
###### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
###### Returns
[`StorageKeyType`](State.mdx#storagekeytype)\[]
##### size()
> **size**: (`diff`) => `number`
###### Parameters
###### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
###### Returns
`number`
## Functions
### \_getChange()
> **\_getChange**(`diff`, `key`): [`StorageChange`](#storagechange) | `undefined`
Defined in: [src/primitives/StorageDiff/getChange.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/getChange.js#L16)
Get change for a specific storage slot
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype)
Storage diff
##### key
[`StorageKeyType`](State.mdx#storagekeytype)
Storage key to look up
#### Returns
[`StorageChange`](#storagechange) | `undefined`
Storage change or undefined
#### Example
```typescript theme={null}
const change = StorageDiff.getChange(diff, storageKey);
if (change) {
console.log(`${change.from} -> ${change.to}`);
}
```
***
### \_getKeys()
> **\_getKeys**(`diff`): [`StorageKeyType`](State.mdx#storagekeytype)\[]
Defined in: [src/primitives/StorageDiff/getKeys.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/getKeys.js#L15)
Get all storage keys that changed
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype)
Storage diff
#### Returns
[`StorageKeyType`](State.mdx#storagekeytype)\[]
Array of storage keys
#### Example
```typescript theme={null}
const keys = StorageDiff.getKeys(diff);
for (const key of keys) {
console.log(`Slot ${key.slot} changed`);
}
```
***
### \_size()
> **\_size**(`diff`): `number`
Defined in: [src/primitives/StorageDiff/size.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/size.js#L13)
Get number of storage slots that changed
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype)
Storage diff
#### Returns
`number`
Number of changed slots
#### Example
```typescript theme={null}
const count = StorageDiff.size(diff);
console.log(`${count} storage slots changed`);
```
***
### from()
> **from**(`address`, `changes`): [`StorageDiffType`](#storagedifftype)
Defined in: [src/primitives/StorageDiff/from.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/from.js#L14)
Create StorageDiff from address and changes
#### Parameters
##### address
[`AddressType`](Address.mdx#addresstype)
Contract address
##### changes
Storage changes
`Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)> | \[[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)]\[]
#### Returns
[`StorageDiffType`](#storagedifftype)
StorageDiff
#### Example
```typescript theme={null}
const diff = StorageDiff.from(address, new Map([[key, { from: null, to: value }]]));
const diff2 = StorageDiff.from(address, [[key, { from: oldVal, to: newVal }]]);
```
***
### getChange()
> **getChange**(`diff`, `key`): [`StorageChange`](#storagechange) | `undefined`
Defined in: [src/primitives/StorageDiff/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/index.ts#L15)
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
##### key
[`StorageKeyType`](State.mdx#storagekeytype)
#### Returns
[`StorageChange`](#storagechange) | `undefined`
***
### getKeys()
> **getKeys**(`diff`): [`StorageKeyType`](State.mdx#storagekeytype)\[]
Defined in: [src/primitives/StorageDiff/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/index.ts#L31)
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
#### Returns
[`StorageKeyType`](State.mdx#storagekeytype)\[]
***
### size()
> **size**(`diff`): `number`
Defined in: [src/primitives/StorageDiff/index.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageDiff/index.ts#L46)
#### Parameters
##### diff
[`StorageDiffType`](#storagedifftype) | \[[`AddressType`](Address.mdx#addresstype), `Map`\<[`StorageKeyType`](State.mdx#storagekeytype), [`StorageChange`](#storagechange)>]
#### Returns
`number`
# primitives/StorageProof
Source: https://voltaire.tevm.sh/generated-api/primitives/StorageProof
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StorageProof
# primitives/StorageProof
## Type Aliases
### StorageProofLike
> **StorageProofLike** = [`StorageProofType`](#storageprooftype) | \{ `key`: [`StorageKeyType`](State.mdx#storagekeytype); `proof`: readonly `Uint8Array`\[]; `value`: [`StorageValueType`](StorageValue.mdx#storagevaluetype); }
Defined in: [src/primitives/StorageProof/StorageProofType.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/StorageProofType.ts#L42)
Inputs that can be converted to StorageProof
***
### StorageProofType
> **StorageProofType** = `object`
Defined in: [src/primitives/StorageProof/StorageProofType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/StorageProofType.ts#L18)
StorageProof represents an EIP-1186 storage proof for a single storage slot.
Each storage proof demonstrates that a specific storage key-value pair exists
(or doesn't exist) in a contract's storage trie at a given block. The proof
consists of RLP-encoded Merkle Patricia Trie nodes forming a path from the
storage root to the leaf containing the value.
Storage proofs are part of the StateProof structure and enable trustless
verification of contract storage without executing transactions or trusting
external data providers.
#### See
EIP-1186: [https://eips.ethereum.org/EIPS/eip-1186](https://eips.ethereum.org/EIPS/eip-1186)
#### Properties
##### key
> `readonly` **key**: [`StorageKeyType`](State.mdx#storagekeytype)
Defined in: [src/primitives/StorageProof/StorageProofType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/StorageProofType.ts#L23)
The storage slot being proven.
Combines contract address and 256-bit slot number.
##### proof
> `readonly` **proof**: readonly `Uint8Array`\[]
Defined in: [src/primitives/StorageProof/StorageProofType.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/StorageProofType.ts#L36)
Array of RLP-encoded Merkle Patricia Trie nodes.
Forms the path from the storage root hash to this storage slot.
Nodes are ordered from root to leaf.
##### value
> `readonly` **value**: [`StorageValueType`](StorageValue.mdx#storagevaluetype)
Defined in: [src/primitives/StorageProof/StorageProofType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/StorageProofType.ts#L29)
The value stored at this slot.
Zero if the slot is uninitialized or was cleared.
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/StorageProof/equals.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/equals.js#L22)
Compares two StorageProofs for equality.
All fields (key, value, and proof elements) must match.
#### Parameters
##### a
[`StorageProofType`](#storageprooftype)
First StorageProof
##### b
[`StorageProofType`](#storageprooftype)
Second StorageProof
#### Returns
`boolean`
* True if equal
#### Example
```typescript theme={null}
const isEqual = StorageProof.equals(proof1, proof2);
```
***
### from()
> **from**(`storageProof`): [`StorageProofType`](#storageprooftype)
Defined in: [src/primitives/StorageProof/from.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageProof/from.js#L23)
Creates a StorageProof from an object with key, value, and proof array.
#### Parameters
##### storageProof
[`StorageProofLike`](#storageprooflike)
Object containing key, value, and proof
#### Returns
[`StorageProofType`](#storageprooftype)
* A validated StorageProof
#### Example
```typescript theme={null}
const proof = StorageProof.from({
key: storageKey,
value: storageValue,
proof: [node1, node2, node3],
});
```
# primitives/StorageValue
Source: https://voltaire.tevm.sh/generated-api/primitives/StorageValue
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StorageValue
# primitives/StorageValue
## Type Aliases
### StorageValueLike
> **StorageValueLike** = [`StorageValueType`](#storagevaluetype) | `bigint` | `string` | `Uint8Array`
Defined in: [src/primitives/StorageValue/StorageValueType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/StorageValueType.ts#L22)
Inputs that can be converted to StorageValue
***
### StorageValueType
> **StorageValueType** = `Uint8Array` & `object`
Defined in: [src/primitives/StorageValue/StorageValueType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/StorageValueType.ts#L14)
Branded StorageValue type - represents a 32-byte EVM storage slot value.
In the EVM, each contract has 2^256 storage slots, and each slot stores
a 32-byte (256-bit) value. Storage is the persistent key-value store
used by smart contracts to maintain state between transactions.
Storage slots start at zero and are lazily allocated - reading an
uninitialized slot returns zero, and writing zero to a slot can
trigger a gas refund.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"StorageValue"`
##### length
> `readonly` **length**: `32`
## Variables
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/StorageValue/StorageValueType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/StorageValueType.ts#L24)
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/StorageValue/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/equals.js#L18)
Compares two StorageValues for equality.
Uses constant-time comparison to prevent timing attacks.
#### Parameters
##### a
[`StorageValueType`](#storagevaluetype)
First StorageValue
##### b
[`StorageValueType`](#storagevaluetype)
Second StorageValue
#### Returns
`boolean`
* True if equal
#### Example
```typescript theme={null}
const isEqual = StorageValue.equals(val1, val2);
```
***
### from()
> **from**(`value`): [`StorageValueType`](#storagevaluetype)
Defined in: [src/primitives/StorageValue/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/from.js#L22)
Creates a StorageValue from various input types.
Accepts bigint, hex strings, Uint8Array, or existing StorageValue instances.
#### Parameters
##### value
[`StorageValueLike`](#storagevaluelike)
The value to convert
#### Returns
[`StorageValueType`](#storagevaluetype)
* A branded StorageValue
#### Example
```typescript theme={null}
const val = StorageValue.from(123n);
const val2 = StorageValue.from("0x1234...");
const val3 = StorageValue.from(new Uint8Array(32));
```
***
### fromHex()
> **fromHex**(`hex`): [`StorageValueType`](#storagevaluetype)
Defined in: [src/primitives/StorageValue/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/fromHex.js#L18)
Creates a StorageValue from a hex string.
#### Parameters
##### hex
`string`
Hex string (with or without 0x prefix)
#### Returns
[`StorageValueType`](#storagevaluetype)
* A branded StorageValue
#### Example
```typescript theme={null}
const val = StorageValue.fromHex("0x1234...");
```
***
### toHex()
> **toHex**(`value`): `string`
Defined in: [src/primitives/StorageValue/toHex.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/toHex.js#L19)
Converts a StorageValue to a hex string.
#### Parameters
##### value
[`StorageValueType`](#storagevaluetype)
The StorageValue to convert
#### Returns
`string`
* Hex string with 0x prefix
#### Example
```typescript theme={null}
const hex = StorageValue.toHex(val);
// "0x0000000000000000000000000000000000000000000000000000000000000123"
```
***
### toUint256()
> **toUint256**(`value`): `bigint`
Defined in: [src/primitives/StorageValue/toUint256.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StorageValue/toUint256.js#L18)
Converts a StorageValue to a bigint (Uint256).
#### Parameters
##### value
[`StorageValueType`](#storagevaluetype)
The StorageValue to convert
#### Returns
`bigint`
* The numeric value as bigint
#### Example
```typescript theme={null}
const val = StorageValue.from(123n);
const num = StorageValue.toUint256(val);
// 123n
```
# primitives/StructLog
Source: https://voltaire.tevm.sh/generated-api/primitives/StructLog
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/StructLog
# primitives/StructLog
## Type Aliases
### StructLogType
> **StructLogType** = `object`
Defined in: [src/primitives/StructLog/StructLogType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L11)
Geth-style structured execution log entry
Each entry represents one opcode execution with human-readable formatting
#### See
[https://voltaire.tevm.sh/primitives/struct-log](https://voltaire.tevm.sh/primitives/struct-log) for StructLog documentation
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"StructLog"`
Defined in: [src/primitives/StructLog/StructLogType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L12)
##### depth
> `readonly` **depth**: `number`
Defined in: [src/primitives/StructLog/StructLogType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L22)
Call depth (0 for top-level call)
##### error?
> `readonly` `optional` **error**: `string`
Defined in: [src/primitives/StructLog/StructLogType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L32)
Error message if operation failed
##### gas
> `readonly` **gas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/StructLog/StructLogType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L18)
Remaining gas before this operation
##### gasCost
> `readonly` **gasCost**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/StructLog/StructLogType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L20)
Gas cost for this operation
##### memory?
> `readonly` `optional` **memory**: readonly `string`\[]
Defined in: [src/primitives/StructLog/StructLogType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L26)
Memory contents as 32-byte hex chunks
##### op
> `readonly` **op**: `string`
Defined in: [src/primitives/StructLog/StructLogType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L16)
Opcode name (e.g., "PUSH1", "ADD", "SSTORE")
##### pc
> `readonly` **pc**: `number`
Defined in: [src/primitives/StructLog/StructLogType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L14)
Program counter
##### refund?
> `readonly` `optional` **refund**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/StructLog/StructLogType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L30)
Gas refund counter
##### stack
> `readonly` **stack**: readonly `string`\[]
Defined in: [src/primitives/StructLog/StructLogType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L24)
Stack contents as hex strings (top to bottom)
##### storage?
> `readonly` `optional` **storage**: `Record`\<`string`, `string`>
Defined in: [src/primitives/StructLog/StructLogType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/StructLogType.ts#L28)
Storage changes (hex key -> hex value)
## Functions
### \_from()
> **\_from**(`data`): [`StructLogType`](#structlogtype)
Defined in: [src/primitives/StructLog/from.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/from.js#L29)
Creates a StructLog from raw data
#### Parameters
##### data
StructLog data
###### depth
`number`
Call depth
###### error?
`string`
Error message
###### gas
[`Type`](Uint.mdx#type)
Remaining gas
###### gasCost
[`Type`](Uint.mdx#type)
Gas cost
###### memory?
readonly `string`\[]
Memory as hex chunks
###### op
`string`
Opcode name
###### pc
`number`
Program counter
###### refund?
[`Type`](Uint.mdx#type)
Gas refund
###### stack
readonly `string`\[]
Stack as hex strings
###### storage?
`Record`\<`string`, `string`>
Storage changes
#### Returns
[`StructLogType`](#structlogtype)
StructLog instance
#### Example
```javascript theme={null}
import { from } from './from.js';
const log = from({
pc: 0,
op: "PUSH1",
gas: 1000000n,
gasCost: 3n,
depth: 0,
stack: ["0x60"]
});
```
***
### \_toOpStep()
> **\_toOpStep**(`log`): [`OpStepType`](OpStep.mdx#opsteptype)
Defined in: [src/primitives/StructLog/toOpStep.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/toOpStep.js#L13)
Converts a StructLog to an OpStep
Parses hex strings back to typed values
#### Parameters
##### log
[`StructLogType`](#structlogtype)
StructLog to convert
#### Returns
[`OpStepType`](OpStep.mdx#opsteptype)
OpStep instance
#### Example
```javascript theme={null}
import { toOpStep } from './toOpStep.js';
const step = toOpStep(structLog);
```
***
### from()
> **from**(`data`): [`StructLogType`](#structlogtype)
Defined in: [src/primitives/StructLog/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/index.ts#L23)
Creates a StructLog from raw data
#### Parameters
##### data
`Omit`\<[`StructLogType`](#structlogtype), `brand`>
StructLog data
#### Returns
[`StructLogType`](#structlogtype)
StructLog instance
#### See
[https://voltaire.tevm.sh/primitives/struct-log](https://voltaire.tevm.sh/primitives/struct-log) for StructLog documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import { StructLog } from './primitives/StructLog/index.js';
const log = StructLog.from({ pc: 0, op: "PUSH1", gas: 1000000n, gasCost: 3n, depth: 0, stack: [] });
```
***
### toOpStep()
> **toOpStep**(`log`): [`OpStepType`](OpStep.mdx#opsteptype)
Defined in: [src/primitives/StructLog/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/StructLog/index.ts#L40)
Converts a StructLog to an OpStep
#### Parameters
##### log
[`StructLogType`](#structlogtype)
StructLog to convert
#### Returns
[`OpStepType`](OpStep.mdx#opsteptype)
OpStep instance
#### Example
```typescript theme={null}
import { StructLog } from './primitives/StructLog/index.js';
const step = StructLog.toOpStep(log);
```
# primitives/SyncStatus
Source: https://voltaire.tevm.sh/generated-api/primitives/SyncStatus
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/SyncStatus
# primitives/SyncStatus
## Type Aliases
### SyncProgress
> **SyncProgress** = `object`
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L7)
Active sync progress information
#### Properties
##### currentBlock
> `readonly` **currentBlock**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L9)
##### highestBlock
> `readonly` **highestBlock**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L10)
##### knownStates?
> `readonly` `optional` **knownStates**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L12)
##### pulledStates?
> `readonly` `optional` **pulledStates**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L11)
##### startingBlock
> `readonly` **startingBlock**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L8)
***
### SyncStatusType
> **SyncStatusType** = `false` | [`SyncProgress`](#syncprogress)
Defined in: [src/primitives/SyncStatus/SyncStatusType.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/SyncStatusType.ts#L34)
Sync status from eth\_syncing
false = not syncing (node is fully synced)
object = actively syncing with progress information
#### Example
```typescript theme={null}
// Not syncing
const notSyncing: SyncStatusType = false;
// Actively syncing
const syncing: SyncStatusType = {
startingBlock: 0n,
currentBlock: 1000n,
highestBlock: 2000n,
};
```
## Variables
### SyncStatus
> `const` **SyncStatus**: `object`
Defined in: [src/primitives/SyncStatus/index.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/index.ts#L44)
#### Type Declaration
##### from()
> **from**: (`value`) => [`SyncStatusType`](#syncstatustype) = `_from`
Create SyncStatus from RPC response
###### Parameters
###### value
RPC sync status
`boolean` | \{ `currentBlock`: `string` | `number` | `bigint`; `highestBlock`: `string` | `number` | `bigint`; `knownStates?`: `string` | `number` | `bigint`; `pulledStates?`: `string` | `number` | `bigint`; `startingBlock`: `string` | `number` | `bigint`; }
###### Returns
[`SyncStatusType`](#syncstatustype)
SyncStatus
###### Example
```typescript theme={null}
const notSyncing = SyncStatus.from(false);
const syncing = SyncStatus.from({
startingBlock: 0n,
currentBlock: 1000n,
highestBlock: 2000n,
});
```
##### getProgress()
> **getProgress**: (`status`) => `number`
###### Parameters
###### status
`true` | [`SyncStatusType`](#syncstatustype) | \{ `currentBlock`: `bigint`; `highestBlock`: `bigint`; `startingBlock`: `bigint`; }
###### Returns
`number`
##### isSyncing()
> **isSyncing**: (`status`) => `boolean`
###### Parameters
###### status
`true` | [`SyncStatusType`](#syncstatustype) | \{ `currentBlock`: `bigint`; `highestBlock`: `bigint`; `startingBlock`: `bigint`; }
###### Returns
`boolean`
## Functions
### \_getProgress()
> **\_getProgress**(`status`): `number`
Defined in: [src/primitives/SyncStatus/getProgress.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/getProgress.js#L14)
Calculate sync progress as percentage
#### Parameters
##### status
[`SyncStatusType`](#syncstatustype)
Sync status
#### Returns
`number`
Progress percentage (0-100), or 100 if not syncing
#### Throws
If status is syncing but has invalid block numbers
#### Example
```typescript theme={null}
const progress = SyncStatus.getProgress(status);
console.log(`Syncing: ${progress.toFixed(2)}%`);
```
***
### \_isSyncing()
> **\_isSyncing**(`status`): `boolean`
Defined in: [src/primitives/SyncStatus/isSyncing.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/isSyncing.js#L16)
Check if node is actively syncing
#### Parameters
##### status
[`SyncStatusType`](#syncstatustype)
Sync status
#### Returns
`boolean`
True if syncing
#### Example
```typescript theme={null}
if (SyncStatus.isSyncing(status)) {
console.log("Node is syncing");
} else {
console.log("Node is synced");
}
```
***
### from()
> **from**(`value`): [`SyncStatusType`](#syncstatustype)
Defined in: [src/primitives/SyncStatus/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/from.js#L17)
Create SyncStatus from RPC response
#### Parameters
##### value
RPC sync status
`boolean` | \{ `currentBlock`: `string` | `number` | `bigint`; `highestBlock`: `string` | `number` | `bigint`; `knownStates?`: `string` | `number` | `bigint`; `pulledStates?`: `string` | `number` | `bigint`; `startingBlock`: `string` | `number` | `bigint`; }
#### Returns
[`SyncStatusType`](#syncstatustype)
SyncStatus
#### Example
```typescript theme={null}
const notSyncing = SyncStatus.from(false);
const syncing = SyncStatus.from({
startingBlock: 0n,
currentBlock: 1000n,
highestBlock: 2000n,
});
```
***
### getProgress()
> **getProgress**(`status`): `number`
Defined in: [src/primitives/SyncStatus/index.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/index.ts#L27)
#### Parameters
##### status
`true` | [`SyncStatusType`](#syncstatustype) | \{ `currentBlock`: `bigint`; `highestBlock`: `bigint`; `startingBlock`: `bigint`; }
#### Returns
`number`
***
### isSyncing()
> **isSyncing**(`status`): `boolean`
Defined in: [src/primitives/SyncStatus/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/SyncStatus/index.ts#L14)
#### Parameters
##### status
`true` | [`SyncStatusType`](#syncstatustype) | \{ `currentBlock`: `bigint`; `highestBlock`: `bigint`; `startingBlock`: `bigint`; }
#### Returns
`boolean`
# primitives/TokenBalance
Source: https://voltaire.tevm.sh/generated-api/primitives/TokenBalance
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TokenBalance
# primitives/TokenBalance
## Classes
### InvalidTokenBalanceError
Defined in: [src/primitives/TokenBalance/errors.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L23)
Base validation error
#### Example
```typescript theme={null}
throw new ValidationError('Invalid value', {
value: '0x123',
expected: '20 bytes',
code: 'VALIDATION_ERROR',
docsPath: '/primitives/address/from-hex#error-handling',
cause: originalError
})
```
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidTokenBalanceError**(`message`, `options?`): [`InvalidTokenBalanceError`](#invalidtokenbalanceerror)
Defined in: [src/primitives/TokenBalance/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L24)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidTokenBalanceError`](#invalidtokenbalanceerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### TokenBalanceError
Defined in: [src/primitives/TokenBalance/errors.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L3)
Base error for all primitive-related errors
#### Example
```typescript theme={null}
throw new PrimitiveError('Invalid primitive value', {
code: 'INVALID_PRIMITIVE',
context: { value: '0x123' },
docsPath: '/primitives/overview#errors'
})
```
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new TokenBalanceError**(`message`, `options?`): [`TokenBalanceError`](#tokenbalanceerror)
Defined in: [src/primitives/TokenBalance/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L4)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`TokenBalanceError`](#tokenbalanceerror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
***
### TokenBalanceOverflowError
Defined in: [src/primitives/TokenBalance/errors.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L47)
Base validation error
#### Example
```typescript theme={null}
throw new ValidationError('Invalid value', {
value: '0x123',
expected: '20 bytes',
code: 'VALIDATION_ERROR',
docsPath: '/primitives/address/from-hex#error-handling',
cause: originalError
})
```
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new TokenBalanceOverflowError**(`message`, `options?`): [`TokenBalanceOverflowError`](#tokenbalanceoverflowerror)
Defined in: [src/primitives/TokenBalance/errors.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/errors.ts#L48)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`TokenBalanceOverflowError`](#tokenbalanceoverflowerror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
## Type Aliases
### TokenBalanceType
> **TokenBalanceType** = `bigint` & `object`
Defined in: [src/primitives/TokenBalance/TokenBalanceType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/TokenBalanceType.ts#L10)
TokenBalance type - ERC-20 token balance
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TokenBalance"`
#### See
* [https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
* [https://eips.ethereum.org/EIPS/eip-20](https://eips.ethereum.org/EIPS/eip-20) for ERC-20 specification
#### Since
0.0.0
## Variables
### compare()
> `const` **compare**: (`a`, `b`) => `number` = `_compare`
Defined in: [src/primitives/TokenBalance/index.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L34)
Compare two TokenBalance values
#### Parameters
##### a
[`TokenBalanceType`](#tokenbalancetype)
First TokenBalance
##### b
[`TokenBalanceType`](#tokenbalancetype)
Second TokenBalance
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const a = TokenBalance.from(100n);
const b = TokenBalance.from(200n);
const result = TokenBalance.compare(a, b); // -1
```
***
### constants
> `const` **constants**: `object`
Defined in: [src/primitives/TokenBalance/index.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L40)
#### Type Declaration
##### DECIMALS
> **DECIMALS**: `object`
Common decimal counts for ERC-20 tokens
###### DECIMALS.DAI
> **DAI**: `number` = `18`
###### DECIMALS.ETH
> **ETH**: `number` = `18`
###### DECIMALS.USDC
> **USDC**: `number` = `6`
###### DECIMALS.USDT
> **USDT**: `number` = `6`
###### DECIMALS.WBTC
> **WBTC**: `number` = `8`
###### DECIMALS.WETH
> **WETH**: `number` = `18`
##### MAX
> **MAX**: `bigint`
Maximum TokenBalance value (2^256 - 1)
##### MIN
> **MIN**: `bigint`
Minimum TokenBalance value (0)
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/TokenBalance/index.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L33)
Check if two TokenBalance values are equal
#### Parameters
##### a
[`TokenBalanceType`](#tokenbalancetype)
First TokenBalance
##### b
[`TokenBalanceType`](#tokenbalancetype)
Second TokenBalance
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const a = TokenBalance.from(100n);
const b = TokenBalance.from(100n);
const result = TokenBalance.equals(a, b); // true
```
***
### ERC20\_SELECTORS
> `const` **ERC20\_SELECTORS**: `object`
Defined in: [src/primitives/TokenBalance/index.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L47)
#### Type Declaration
##### allowance
> `readonly` **allowance**: `"0xdd62ed3e"` = `"0xdd62ed3e"`
##### approve
> `readonly` **approve**: `"0x095ea7b3"` = `"0x095ea7b3"`
##### balanceOf
> `readonly` **balanceOf**: `"0x70a08231"` = `"0x70a08231"`
##### totalSupply
> `readonly` **totalSupply**: `"0x18160ddd"` = `"0x18160ddd"`
##### transfer
> `readonly` **transfer**: `"0xa9059cbb"` = `"0xa9059cbb"`
##### transferFrom
> `readonly` **transferFrom**: `"0x23b872dd"` = `"0x23b872dd"`
***
### format()
> `const` **format**: (`balance`, `decimals`, `maxDecimals?`) => `string` = `_format`
Defined in: [src/primitives/TokenBalance/index.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L35)
Format TokenBalance for display with decimals
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
##### decimals
`number`
Number of decimal places (e.g., 18 for ETH, 6 for USDC)
##### maxDecimals?
`number`
Maximum decimal places to display (for rounding)
#### Returns
`string`
Formatted string (e.g., "1.234567")
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1234567890123456789n);
const formatted = TokenBalance.format(balance, 18); // "1.234567890123456789"
const rounded = TokenBalance.format(balance, 18, 6); // "1.234568"
```
***
### from()
> `const` **from**: (`value`) => [`TokenBalanceType`](#tokenbalancetype) = `_from`
Defined in: [src/primitives/TokenBalance/index.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L29)
Create TokenBalance from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1000000000000000000n); // 1 token with 18 decimals
const fromNumber = TokenBalance.from(100);
const fromHex = TokenBalance.from("0xff");
```
***
### fromBaseUnit()
> `const` **fromBaseUnit**: (`amount`, `decimals`) => [`TokenBalanceType`](#tokenbalancetype) = `_fromBaseUnit`
Defined in: [src/primitives/TokenBalance/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L36)
Convert from human-readable base unit to raw TokenBalance
#### Parameters
##### amount
`string`
Human-readable amount (e.g., "1.5" for 1.5 tokens)
##### decimals
`number`
Number of decimal places (e.g., 18 for ETH, 6 for USDC)
#### Returns
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If amount format is invalid
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.fromBaseUnit("1.5", 18); // 1500000000000000000n
const usdc = TokenBalance.fromBaseUnit("100.5", 6); // 100500000n
```
***
### toBaseUnit()
> `const` **toBaseUnit**: (`balance`) => `bigint` = `_toBaseUnit`
Defined in: [src/primitives/TokenBalance/index.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L37)
Convert TokenBalance to base unit bigint (raw value)
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### Returns
`bigint`
Raw bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1500000000000000000n);
const raw = TokenBalance.toBaseUnit(balance); // 1500000000000000000n
```
***
### toBigInt()
> `const` **toBigInt**: (`balance`) => `bigint` = `_toBigInt`
Defined in: [src/primitives/TokenBalance/index.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L31)
Convert TokenBalance to bigint
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1000000n);
const bigint = TokenBalance.toBigInt(balance); // 1000000n
```
***
### toHex()
> `const` **toHex**: (`balance`) => `string` = `_toHex`
Defined in: [src/primitives/TokenBalance/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L32)
Convert TokenBalance to hex string
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(255n);
const hex = TokenBalance.toHex(balance); // "0xff"
```
***
### toNumber()
> `const` **toNumber**: (`balance`) => `number` = `_toNumber`
Defined in: [src/primitives/TokenBalance/index.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/index.ts#L30)
Convert TokenBalance to number (unsafe for large values)
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(100n);
const num = TokenBalance.toNumber(balance); // 100
```
## Functions
### \_compare()
> **\_compare**(`a`, `b`): `number`
Defined in: [src/primitives/TokenBalance/compare.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/compare.js#L17)
Compare two TokenBalance values
#### Parameters
##### a
[`TokenBalanceType`](#tokenbalancetype)
First TokenBalance
##### b
[`TokenBalanceType`](#tokenbalancetype)
Second TokenBalance
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const a = TokenBalance.from(100n);
const b = TokenBalance.from(200n);
const result = TokenBalance.compare(a, b); // -1
```
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/TokenBalance/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/equals.js#L17)
Check if two TokenBalance values are equal
#### Parameters
##### a
[`TokenBalanceType`](#tokenbalancetype)
First TokenBalance
##### b
[`TokenBalanceType`](#tokenbalancetype)
Second TokenBalance
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const a = TokenBalance.from(100n);
const b = TokenBalance.from(100n);
const result = TokenBalance.equals(a, b); // true
```
***
### \_format()
> **\_format**(`balance`, `decimals`, `maxDecimals?`): `string`
Defined in: [src/primitives/TokenBalance/format.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/format.js#L18)
Format TokenBalance for display with decimals
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
##### decimals
`number`
Number of decimal places (e.g., 18 for ETH, 6 for USDC)
##### maxDecimals?
`number`
Maximum decimal places to display (for rounding)
#### Returns
`string`
Formatted string (e.g., "1.234567")
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1234567890123456789n);
const formatted = TokenBalance.format(balance, 18); // "1.234567890123456789"
const rounded = TokenBalance.format(balance, 18, 6); // "1.234568"
```
***
### \_from()
> **\_from**(`value`): [`TokenBalanceType`](#tokenbalancetype)
Defined in: [src/primitives/TokenBalance/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/from.js#L20)
Create TokenBalance from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1000000000000000000n); // 1 token with 18 decimals
const fromNumber = TokenBalance.from(100);
const fromHex = TokenBalance.from("0xff");
```
***
### \_fromBaseUnit()
> **\_fromBaseUnit**(`amount`, `decimals`): [`TokenBalanceType`](#tokenbalancetype)
Defined in: [src/primitives/TokenBalance/fromBaseUnit.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/fromBaseUnit.js#L19)
Convert from human-readable base unit to raw TokenBalance
#### Parameters
##### amount
`string`
Human-readable amount (e.g., "1.5" for 1.5 tokens)
##### decimals
`number`
Number of decimal places (e.g., 18 for ETH, 6 for USDC)
#### Returns
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If amount format is invalid
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.fromBaseUnit("1.5", 18); // 1500000000000000000n
const usdc = TokenBalance.fromBaseUnit("100.5", 6); // 100500000n
```
***
### \_toBaseUnit()
> **\_toBaseUnit**(`balance`): `bigint`
Defined in: [src/primitives/TokenBalance/toBaseUnit.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/toBaseUnit.js#L15)
Convert TokenBalance to base unit bigint (raw value)
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value
#### Returns
`bigint`
Raw bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1500000000000000000n);
const raw = TokenBalance.toBaseUnit(balance); // 1500000000000000000n
```
***
### \_toBigInt()
> **\_toBigInt**(`balance`): `bigint`
Defined in: [src/primitives/TokenBalance/toBigInt.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/toBigInt.js#L15)
Convert TokenBalance to bigint
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(1000000n);
const bigint = TokenBalance.toBigInt(balance); // 1000000n
```
***
### \_toHex()
> **\_toHex**(`balance`): `string`
Defined in: [src/primitives/TokenBalance/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/toHex.js#L15)
Convert TokenBalance to hex string
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(255n);
const hex = TokenBalance.toHex(balance); // "0xff"
```
***
### \_toNumber()
> **\_toNumber**(`balance`): `number`
Defined in: [src/primitives/TokenBalance/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenBalance/toNumber.js#L16)
Convert TokenBalance to number (unsafe for large values)
#### Parameters
##### balance
[`TokenBalanceType`](#tokenbalancetype)
TokenBalance value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/token-balance](https://voltaire.tevm.sh/primitives/token-balance) for TokenBalance documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as TokenBalance from './primitives/TokenBalance/index.js';
const balance = TokenBalance.from(100n);
const num = TokenBalance.toNumber(balance); // 100
```
# primitives/TokenId
Source: https://voltaire.tevm.sh/generated-api/primitives/TokenId
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TokenId
# primitives/TokenId
## Classes
### InvalidTokenIdError
Defined in: [src/primitives/TokenId/errors.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/errors.ts#L23)
Base validation error
#### Example
```typescript theme={null}
throw new ValidationError('Invalid value', {
value: '0x123',
expected: '20 bytes',
code: 'VALIDATION_ERROR',
docsPath: '/primitives/address/from-hex#error-handling',
cause: originalError
})
```
#### Extends
* [`ValidationError`](../index/index.mdx#validationerror)
#### Constructors
##### Constructor
> **new InvalidTokenIdError**(`message`, `options?`): [`InvalidTokenIdError`](#invalidtokeniderror)
Defined in: [src/primitives/TokenId/errors.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/errors.ts#L24)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidTokenIdError`](#invalidtokeniderror)
###### Overrides
[`ValidationError`](../index/index.mdx#validationerror).[`constructor`](../index/index.mdx#constructor-20)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`cause`](../index/index.mdx#cause-19)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`code`](../index/index.mdx#code-19)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`context`](../index/index.mdx#context-19)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`docsPath`](../index/index.mdx#docspath-19)
##### expected
> **expected**: `string`
Defined in: [src/primitives/errors/ValidationError.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L19)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`expected`](../index/index.mdx#expected-7)
##### value
> **value**: `unknown`
Defined in: [src/primitives/errors/ValidationError.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/ValidationError.ts#L18)
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`value`](../index/index.mdx#value-7)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`getErrorChain`](../index/index.mdx#geterrorchain-38)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`ValidationError`](../index/index.mdx#validationerror).[`toJSON`](../index/index.mdx#tojson-38)
***
### TokenIdError
Defined in: [src/primitives/TokenId/errors.ts:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/errors.ts#L3)
Base error for all primitive-related errors
#### Example
```typescript theme={null}
throw new PrimitiveError('Invalid primitive value', {
code: 'INVALID_PRIMITIVE',
context: { value: '0x123' },
docsPath: '/primitives/overview#errors'
})
```
#### Extends
* [`PrimitiveError`](../index/index.mdx#primitiveerror)
#### Constructors
##### Constructor
> **new TokenIdError**(`message`, `options?`): [`TokenIdError`](#tokeniderror)
Defined in: [src/primitives/TokenId/errors.ts:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/errors.ts#L4)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`TokenIdError`](#tokeniderror)
###### Overrides
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`constructor`](../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`cause`](../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`code`](../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`context`](../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`docsPath`](../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`getErrorChain`](../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../index/index.mdx#primitiveerror).[`toJSON`](../index/index.mdx#tojson-32)
## Type Aliases
### TokenIdType
> **TokenIdType** = `bigint` & `object`
Defined in: [src/primitives/TokenId/TokenIdType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/TokenIdType.ts#L10)
TokenId type - ERC-721 NFT token identifier
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TokenId"`
#### See
* [https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
* [https://eips.ethereum.org/EIPS/eip-721](https://eips.ethereum.org/EIPS/eip-721) for ERC-721 specification
#### Since
0.0.0
## Variables
### compare()
> `const` **compare**: (`a`, `b`) => `number` = `_compare`
Defined in: [src/primitives/TokenId/index.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L22)
Compare two TokenId values
#### Parameters
##### a
[`TokenIdType`](#tokenidtype)
First TokenId
##### b
[`TokenIdType`](#tokenidtype)
Second TokenId
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const a = TokenId.from(42n);
const b = TokenId.from(100n);
const result = TokenId.compare(a, b); // -1
```
***
### constants
> `const` **constants**: `object`
Defined in: [src/primitives/TokenId/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L26)
#### Type Declaration
##### MAX
> **MAX**: `bigint`
Maximum TokenId value (2^256 - 1)
##### MIN
> **MIN**: `bigint`
Minimum TokenId value (0)
***
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/TokenId/index.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L21)
Check if two TokenId values are equal
#### Parameters
##### a
[`TokenIdType`](#tokenidtype)
First TokenId
##### b
[`TokenIdType`](#tokenidtype)
Second TokenId
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const a = TokenId.from(42n);
const b = TokenId.from(42n);
const result = TokenId.equals(a, b); // true
```
***
### ERC721\_SELECTORS
> `const` **ERC721\_SELECTORS**: `object`
Defined in: [src/primitives/TokenId/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L32)
#### Type Declaration
##### approve
> `readonly` **approve**: `"0x095ea7b3"` = `"0x095ea7b3"`
##### balanceOf
> `readonly` **balanceOf**: `"0x70a08231"` = `"0x70a08231"`
##### getApproved
> `readonly` **getApproved**: `"0x081812fc"` = `"0x081812fc"`
##### isApprovedForAll
> `readonly` **isApprovedForAll**: `"0xe985e9c5"` = `"0xe985e9c5"`
##### ownerOf
> `readonly` **ownerOf**: `"0x6352211e"` = `"0x6352211e"`
##### safeTransferFrom
> `readonly` **safeTransferFrom**: `"0x42842e0e"` = `"0x42842e0e"`
##### setApprovalForAll
> `readonly` **setApprovalForAll**: `"0xa22cb465"` = `"0xa22cb465"`
##### transferFrom
> `readonly` **transferFrom**: `"0x23b872dd"` = `"0x23b872dd"`
***
### from()
> `const` **from**: (`value`) => [`TokenIdType`](#tokenidtype) = `_from`
Defined in: [src/primitives/TokenId/index.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L17)
Create TokenId from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`TokenIdType`](#tokenidtype)
TokenId value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const fromNumber = TokenId.from(100);
const fromHex = TokenId.from("0xff");
```
***
### isValid()
> `const` **isValid**: (`tokenId`) => `boolean` = `_isValid`
Defined in: [src/primitives/TokenId/index.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L23)
Check if TokenId is valid (non-zero)
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to check
#### Returns
`boolean`
true if valid (non-zero)
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const valid = TokenId.isValid(tokenId); // true
const zero = TokenId.from(0n);
const invalid = TokenId.isValid(zero); // false
```
***
### toBigInt()
> `const` **toBigInt**: (`tokenId`) => `bigint` = `_toBigInt`
Defined in: [src/primitives/TokenId/index.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L19)
Convert TokenId to bigint
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const bigint = TokenId.toBigInt(tokenId); // 42n
```
***
### toHex()
> `const` **toHex**: (`tokenId`) => `string` = `_toHex`
Defined in: [src/primitives/TokenId/index.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L20)
Convert TokenId to hex string
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const hex = TokenId.toHex(tokenId); // "0x2a"
```
***
### toNumber()
> `const` **toNumber**: (`tokenId`) => `number` = `_toNumber`
Defined in: [src/primitives/TokenId/index.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/index.ts#L18)
Convert TokenId to number (unsafe for large values)
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const num = TokenId.toNumber(tokenId); // 42
```
## Functions
### \_compare()
> **\_compare**(`a`, `b`): `number`
Defined in: [src/primitives/TokenId/compare.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/compare.js#L17)
Compare two TokenId values
#### Parameters
##### a
[`TokenIdType`](#tokenidtype)
First TokenId
##### b
[`TokenIdType`](#tokenidtype)
Second TokenId
#### Returns
`number`
-1 if a \< b, 0 if a === b, 1 if a > b
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const a = TokenId.from(42n);
const b = TokenId.from(100n);
const result = TokenId.compare(a, b); // -1
```
***
### \_equals()
> **\_equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/TokenId/equals.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/equals.js#L17)
Check if two TokenId values are equal
#### Parameters
##### a
[`TokenIdType`](#tokenidtype)
First TokenId
##### b
[`TokenIdType`](#tokenidtype)
Second TokenId
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const a = TokenId.from(42n);
const b = TokenId.from(42n);
const result = TokenId.equals(a, b); // true
```
***
### \_from()
> **\_from**(`value`): [`TokenIdType`](#tokenidtype)
Defined in: [src/primitives/TokenId/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/from.js#L20)
Create TokenId from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`TokenIdType`](#tokenidtype)
TokenId value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const fromNumber = TokenId.from(100);
const fromHex = TokenId.from("0xff");
```
***
### \_isValid()
> **\_isValid**(`tokenId`): `boolean`
Defined in: [src/primitives/TokenId/isValid.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/isValid.js#L17)
Check if TokenId is valid (non-zero)
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to check
#### Returns
`boolean`
true if valid (non-zero)
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const valid = TokenId.isValid(tokenId); // true
const zero = TokenId.from(0n);
const invalid = TokenId.isValid(zero); // false
```
***
### \_toBigInt()
> **\_toBigInt**(`tokenId`): `bigint`
Defined in: [src/primitives/TokenId/toBigInt.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/toBigInt.js#L15)
Convert TokenId to bigint
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const bigint = TokenId.toBigInt(tokenId); // 42n
```
***
### \_toHex()
> **\_toHex**(`tokenId`): `string`
Defined in: [src/primitives/TokenId/toHex.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/toHex.js#L15)
Convert TokenId to hex string
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const hex = TokenId.toHex(tokenId); // "0x2a"
```
***
### \_toNumber()
> **\_toNumber**(`tokenId`): `number`
Defined in: [src/primitives/TokenId/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TokenId/toNumber.js#L16)
Convert TokenId to number (unsafe for large values)
#### Parameters
##### tokenId
[`TokenIdType`](#tokenidtype)
TokenId value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/token-id](https://voltaire.tevm.sh/primitives/token-id) for TokenId documentation
#### Since
0.0.0
#### Throws
If value exceeds Number.MAX\_SAFE\_INTEGER
#### Example
```javascript theme={null}
import * as TokenId from './primitives/TokenId/index.js';
const tokenId = TokenId.from(42n);
const num = TokenId.toNumber(tokenId); // 42
```
# primitives/TopicFilter
Source: https://voltaire.tevm.sh/generated-api/primitives/TopicFilter
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TopicFilter
# primitives/TopicFilter
## Classes
### InvalidTopicFilterError
Defined in: [src/primitives/TopicFilter/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/errors.js#L4)
Error thrown when TopicFilter is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTopicFilterError**(`message`, `details?`): [`InvalidTopicFilterError`](#invalidtopicfiltererror)
Defined in: [src/primitives/TopicFilter/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/errors.js#L9)
###### Parameters
###### message
`string`
###### details?
`object`
###### Returns
[`InvalidTopicFilterError`](#invalidtopicfiltererror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: `object` | `undefined`
Defined in: [src/primitives/TopicFilter/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/errors.js#L13)
##### name
> **name**: `string`
Defined in: [src/primitives/TopicFilter/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### TopicEntry
> **TopicEntry** = [`HashType`](../index/namespaces/HashType.mdx#hashtype) | readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[] | `null`
Defined in: [src/primitives/TopicFilter/TopicFilterType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/TopicFilterType.ts#L7)
Single topic filter entry - either a specific hash, array of hashes (OR), or null (wildcard)
***
### TopicFilterType
> **TopicFilterType** = readonly \[[`TopicEntry`](#topicentry)?, [`TopicEntry`](#topicentry)?, [`TopicEntry`](#topicentry)?, [`TopicEntry`](#topicentry)?] & `object`
Defined in: [src/primitives/TopicFilter/TopicFilterType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/TopicFilterType.ts#L30)
Topic filter array for event filtering
* Up to 4 indexed event parameters (topic0, topic1, topic2, topic3)
* topic0 is typically the event signature hash
* null entries match any value (wildcard)
* Array entries match any of the values (OR logic)
* Positions use AND logic: all non-null positions must match
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TopicFilter"`
#### Example
```typescript theme={null}
// Match specific event with any sender
[eventSig, null, recipientAddr]
// Match any of multiple events
[[eventSig1, eventSig2], null, null]
// Match specific sender OR specific recipient
[eventSig, [addr1, addr2], null]
```
## Functions
### from()
> **from**(`topics`): [`TopicFilterType`](#topicfiltertype)
Defined in: [src/primitives/TopicFilter/from.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/from.js#L25)
Create TopicFilter from array
#### Parameters
##### topics
readonly \[[`TopicEntry`](#topicentry) | `undefined`, [`TopicEntry`](#topicentry) | `undefined`, [`TopicEntry`](#topicentry) | `undefined`, [`TopicEntry`](#topicentry) | `undefined`]
Topic filter array (up to 4 entries)
#### Returns
[`TopicFilterType`](#topicfiltertype)
#### Throws
#### Example
```javascript theme={null}
import * as TopicFilter from './primitives/TopicFilter/index.js';
import * as Hash from './primitives/Hash/index.js';
// Match specific event signature with any parameters
const filter1 = TopicFilter.from([Hash.from("0x...")]);
// Match specific event with specific recipient
const filter2 = TopicFilter.from([eventSig, null, recipientHash]);
// Match any of multiple events
const filter3 = TopicFilter.from([[eventSig1, eventSig2]]);
```
***
### isEmpty()
> **isEmpty**(`filter`): `boolean`
Defined in: [src/primitives/TopicFilter/isEmpty.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/isEmpty.js#L12)
Check if topic filter is empty (all wildcards)
#### Parameters
##### filter
[`TopicFilterType`](#topicfiltertype)
#### Returns
`boolean`
#### Example
```javascript theme={null}
import * as TopicFilter from './primitives/TopicFilter/index.js';
const empty = TopicFilter.isEmpty(filter); // true if all null/undefined
```
***
### matches()
> **matches**(`filter`, `logTopics`): `boolean`
Defined in: [src/primitives/TopicFilter/matches.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TopicFilter/matches.js#L19)
Check if a topic array matches this filter
Uses AND logic across positions and OR logic within arrays:
* All non-null filter positions must match the corresponding log topic
* Array entries match if ANY of the hashes match (OR)
* null entries always match (wildcard)
#### Parameters
##### filter
[`TopicFilterType`](#topicfiltertype)
##### logTopics
readonly [`HashType`](../index/namespaces/HashType.mdx#hashtype)\[]
Topics from a log entry
#### Returns
`boolean`
#### Example
```javascript theme={null}
import * as TopicFilter from './primitives/TopicFilter/index.js';
const matches = TopicFilter.matches(filter, log.topics);
```
# primitives/TraceConfig
Source: https://voltaire.tevm.sh/generated-api/primitives/TraceConfig
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TraceConfig
# primitives/TraceConfig
## Type Aliases
### TraceConfigType
> **TraceConfigType** = `object`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L9)
Configuration options for debug\_traceTransaction and debug\_traceCall
#### See
[https://voltaire.tevm.sh/primitives/trace-config](https://voltaire.tevm.sh/primitives/trace-config) for TraceConfig documentation
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TraceConfig"`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L10)
##### disableMemory?
> `readonly` `optional` **disableMemory**: `boolean`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L16)
Don't track memory (reduces overhead)
##### disableStack?
> `readonly` `optional` **disableStack**: `boolean`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L14)
Don't track stack (reduces overhead)
##### disableStorage?
> `readonly` `optional` **disableStorage**: `boolean`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L12)
Don't track storage changes (reduces overhead)
##### enableMemory?
> `readonly` `optional` **enableMemory**: `boolean`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L18)
Track memory (conflicts with disableMemory)
##### enableReturnData?
> `readonly` `optional` **enableReturnData**: `boolean`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L20)
Track return data
##### timeout?
> `readonly` `optional` **timeout**: `string`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L24)
Timeout for trace execution (e.g., "5s", "30s")
##### tracer?
> `readonly` `optional` **tracer**: `string`
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L22)
Tracer name: "callTracer", "prestateTracer", "4byteTracer", etc
##### tracerConfig?
> `readonly` `optional` **tracerConfig**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/TraceConfig/TraceConfigType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/TraceConfigType.ts#L26)
Tracer-specific configuration
## Functions
### \_disableAll()
> **\_disableAll**(`config?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/disableAll.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/disableAll.js#L13)
Creates a minimal TraceConfig with all tracking disabled
Useful for maximum performance when only basic execution info is needed
#### Parameters
##### config?
[`TraceConfigType`](#traceconfigtype) = `...`
Base config
#### Returns
[`TraceConfigType`](#traceconfigtype)
Config with all tracking disabled
#### Example
```javascript theme={null}
import { disableAll } from './disableAll.js';
const config = disableAll();
```
***
### \_from()
> **\_from**(`config?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/from.js#L20)
Creates a TraceConfig from configuration options
#### Parameters
##### config?
Trace configuration options
###### disableMemory?
`boolean`
Don't track memory
###### disableStack?
`boolean`
Don't track stack
###### disableStorage?
`boolean`
Don't track storage changes
###### enableMemory?
`boolean`
Track memory
###### enableReturnData?
`boolean`
Track return data
###### timeout?
`string`
Timeout (e.g., "5s")
###### tracer?
`string`
Tracer name
###### tracerConfig?
`Record`\<`string`, `unknown`>
Tracer-specific config
#### Returns
[`TraceConfigType`](#traceconfigtype)
TraceConfig instance
#### Example
```javascript theme={null}
import { from } from './from.js';
const config = from({ disableStorage: true, disableMemory: true });
```
***
### \_withTracer()
> **\_withTracer**(`config`, `tracer`, `tracerConfig?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/withTracer.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/withTracer.js#L14)
Creates a TraceConfig with a specific tracer
#### Parameters
##### config
[`TraceConfigType`](#traceconfigtype)
Base config
##### tracer
`string`
Tracer name ("callTracer", "prestateTracer", etc)
##### tracerConfig?
`Record`\<`string`, `unknown`>
Tracer-specific config
#### Returns
[`TraceConfigType`](#traceconfigtype)
Updated config
#### Example
```javascript theme={null}
import { withTracer } from './withTracer.js';
const config = withTracer({}, "callTracer", { onlyTopCall: true });
```
***
### disableAll()
> **disableAll**(`config?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/index.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/index.ts#L60)
Creates a minimal TraceConfig with all tracking disabled
#### Parameters
##### config?
[`TraceConfigType`](#traceconfigtype)
Base config
#### Returns
[`TraceConfigType`](#traceconfigtype)
Config with all tracking disabled
#### Example
```typescript theme={null}
import { TraceConfig } from './primitives/TraceConfig/index.js';
const config = TraceConfig.disableAll();
```
***
### from()
> **from**(`config?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/index.ts#L24)
Creates a TraceConfig from configuration options
#### Parameters
##### config?
`Partial`\<[`TraceConfigType`](#traceconfigtype)>
Trace configuration options
#### Returns
[`TraceConfigType`](#traceconfigtype)
TraceConfig instance
#### See
[https://voltaire.tevm.sh/primitives/trace-config](https://voltaire.tevm.sh/primitives/trace-config) for TraceConfig documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import { TraceConfig } from './primitives/TraceConfig/index.js';
const config = TraceConfig.from({ disableStorage: true });
```
***
### withTracer()
> **withTracer**(`config`, `tracer`, `tracerConfig?`): [`TraceConfigType`](#traceconfigtype)
Defined in: [src/primitives/TraceConfig/index.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceConfig/index.ts#L41)
Creates a TraceConfig with a specific tracer
#### Parameters
##### config
[`TraceConfigType`](#traceconfigtype)
Base config
##### tracer
`string`
Tracer name ("callTracer", "prestateTracer", etc)
##### tracerConfig?
`Record`\<`string`, `unknown`>
Tracer-specific config
#### Returns
[`TraceConfigType`](#traceconfigtype)
Updated config
#### Example
```typescript theme={null}
import { TraceConfig } from './primitives/TraceConfig/index.js';
const config = TraceConfig.withTracer({}, "callTracer");
```
# primitives/TraceResult
Source: https://voltaire.tevm.sh/generated-api/primitives/TraceResult
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TraceResult
# primitives/TraceResult
## Type Aliases
### TraceResultType
> **TraceResultType** = `object`
Defined in: [src/primitives/TraceResult/TraceResultType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L13)
Complete execution trace result
Returned by debug\_traceTransaction and debug\_traceCall
#### See
[https://voltaire.tevm.sh/primitives/trace-result](https://voltaire.tevm.sh/primitives/trace-result) for TraceResult documentation
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TraceResult"`
Defined in: [src/primitives/TraceResult/TraceResultType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L14)
##### callTrace?
> `readonly` `optional` **callTrace**: [`CallTraceType`](CallTrace.mdx#calltracetype)
Defined in: [src/primitives/TraceResult/TraceResultType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L24)
Call tree (when using callTracer)
##### failed
> `readonly` **failed**: `boolean`
Defined in: [src/primitives/TraceResult/TraceResultType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L18)
Whether execution failed
##### gas
> `readonly` **gas**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/TraceResult/TraceResultType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L16)
Total gas used by the execution
##### returnValue
> `readonly` **returnValue**: `Uint8Array`
Defined in: [src/primitives/TraceResult/TraceResultType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L20)
Return value or revert data
##### structLogs?
> `readonly` `optional` **structLogs**: readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Defined in: [src/primitives/TraceResult/TraceResultType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/TraceResultType.ts#L22)
Opcode-level execution trace (when using default tracer)
## Functions
### \_from()
> **\_from**(`data`): [`TraceResultType`](#traceresulttype)
Defined in: [src/primitives/TraceResult/from.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/from.js#L22)
Creates a TraceResult from raw data
#### Parameters
##### data
TraceResult data
###### callTrace?
[`CallTraceType`](CallTrace.mdx#calltracetype)
Call tree
###### failed
`boolean`
Whether execution failed
###### gas
[`Type`](Uint.mdx#type)
Total gas used
###### returnValue
`Uint8Array`\<`ArrayBufferLike`>
Return value
###### structLogs?
readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Opcode trace
#### Returns
[`TraceResultType`](#traceresulttype)
TraceResult instance
#### Example
```javascript theme={null}
import { from } from './from.js';
const result = from({
gas: 50000n,
failed: false,
returnValue: new Uint8Array(),
structLogs: []
});
```
***
### \_getCallTrace()
> **\_getCallTrace**(`result`): [`CallTraceType`](CallTrace.mdx#calltracetype) | `undefined`
Defined in: [src/primitives/TraceResult/getCallTrace.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/getCallTrace.js#L15)
Gets call trace from a TraceResult
#### Parameters
##### result
[`TraceResultType`](#traceresulttype)
TraceResult to extract call trace from
#### Returns
[`CallTraceType`](CallTrace.mdx#calltracetype) | `undefined`
Call trace (undefined if not using callTracer)
#### Example
```javascript theme={null}
import { getCallTrace } from './getCallTrace.js';
const callTrace = getCallTrace(result);
if (callTrace) {
console.log(`Root call: ${callTrace.type}`);
}
```
***
### \_getStructLogs()
> **\_getStructLogs**(`result`): readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Defined in: [src/primitives/TraceResult/getStructLogs.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/getStructLogs.js#L13)
Gets structured logs from a TraceResult
#### Parameters
##### result
[`TraceResultType`](#traceresulttype)
TraceResult to extract logs from
#### Returns
readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Structured logs (empty array if none)
#### Example
```javascript theme={null}
import { getStructLogs } from './getStructLogs.js';
const logs = getStructLogs(result);
console.log(`${logs.length} opcodes executed`);
```
***
### from()
> **from**(`data`): [`TraceResultType`](#traceresulttype)
Defined in: [src/primitives/TraceResult/index.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/index.ts#L26)
Creates a TraceResult from raw data
#### Parameters
##### data
`Omit`\<[`TraceResultType`](#traceresulttype), `brand`>
TraceResult data
#### Returns
[`TraceResultType`](#traceresulttype)
TraceResult instance
#### See
[https://voltaire.tevm.sh/primitives/trace-result](https://voltaire.tevm.sh/primitives/trace-result) for TraceResult documentation
#### Since
0.0.0
#### Example
```typescript theme={null}
import { TraceResult } from './primitives/TraceResult/index.js';
const result = TraceResult.from({ gas: 50000n, failed: false, returnValue: new Uint8Array() });
```
***
### getCallTrace()
> **getCallTrace**(`result`): [`CallTraceType`](CallTrace.mdx#calltracetype) | `undefined`
Defined in: [src/primitives/TraceResult/index.ts:60](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/index.ts#L60)
Gets call trace from a TraceResult
#### Parameters
##### result
[`TraceResultType`](#traceresulttype)
TraceResult to extract call trace from
#### Returns
[`CallTraceType`](CallTrace.mdx#calltracetype) | `undefined`
Call trace
#### Example
```typescript theme={null}
import { TraceResult } from './primitives/TraceResult/index.js';
const trace = TraceResult.getCallTrace(result);
```
***
### getStructLogs()
> **getStructLogs**(`result`): readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Defined in: [src/primitives/TraceResult/index.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TraceResult/index.ts#L43)
Gets structured logs from a TraceResult
#### Parameters
##### result
[`TraceResultType`](#traceresulttype)
TraceResult to extract logs from
#### Returns
readonly [`StructLogType`](StructLog.mdx#structlogtype)\[]
Structured logs
#### Example
```typescript theme={null}
import { TraceResult } from './primitives/TraceResult/index.js';
const logs = TraceResult.getStructLogs(result);
```
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../../index.mdx)
***
[@tevm/voltaire](../../index.mdx) / primitives/Transaction
# primitives/Transaction
## Namespaces
* [Authorization](namespaces/Authorization.mdx)
* [default](namespaces/default.mdx)
* [EIP1559](namespaces/EIP1559.mdx)
* [EIP2930](namespaces/EIP2930.mdx)
* [EIP4844](namespaces/EIP4844.mdx)
* [EIP7702](namespaces/EIP7702.mdx)
* [Legacy](namespaces/Legacy.mdx)
## Enumerations
### Type
Defined in: [src/primitives/Transaction/types.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L7)
Transaction type discriminator
#### Enumeration Members
##### EIP1559
> **EIP1559**: `2`
Defined in: [src/primitives/Transaction/types.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L10)
##### EIP2930
> **EIP2930**: `1`
Defined in: [src/primitives/Transaction/types.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L9)
##### EIP4844
> **EIP4844**: `3`
Defined in: [src/primitives/Transaction/types.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L11)
##### EIP7702
> **EIP7702**: `4`
Defined in: [src/primitives/Transaction/types.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L12)
##### Legacy
> **Legacy**: `0`
Defined in: [src/primitives/Transaction/types.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L8)
## Type Aliases
### AccessList
> **AccessList** = readonly [`AccessListItem`](#accesslistitem)\[]
Defined in: [src/primitives/Transaction/types.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L26)
Access list (array of items)
***
### AccessListItem
> **AccessListItem** = `object`
Defined in: [src/primitives/Transaction/types.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L18)
Access list item for EIP-2930 and later transactions
#### Properties
##### address
> **address**: [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/types.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L19)
##### storageKeys
> **storageKeys**: readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/Transaction/types.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L20)
***
### Any
> **Any** = `Legacy` | `EIP2930` | `EIP1559` | `EIP4844` | `EIP7702`
Defined in: [src/primitives/Transaction/types.ts:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L155)
Any transaction type
***
### AuthorizationList
> **AuthorizationList** = readonly `Authorization`\[]
Defined in: [src/primitives/Transaction/types.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L43)
Authorization list (array of authorizations)
***
### ReplaceOptions
> **ReplaceOptions** = `object`
Defined in: [src/primitives/Transaction/replaceWith.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L13)
Options for fee bump replacement
#### Properties
##### bumpPercentage?
> `optional` **bumpPercentage**: `number`
Defined in: [src/primitives/Transaction/replaceWith.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L15)
Increase gas price by percentage (e.g., 10 for 10% increase)
##### gasPrice?
> `optional` **gasPrice**: `bigint`
Defined in: [src/primitives/Transaction/replaceWith.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L17)
Explicit gas price to use (overrides bumpPercentage)
##### maxFeePerGas?
> `optional` **maxFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/replaceWith.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L19)
Explicit maxFeePerGas (EIP-1559+)
##### maxPriorityFeePerGas?
> `optional` **maxPriorityFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/replaceWith.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L21)
Explicit maxPriorityFeePerGas (EIP-1559+)
***
### Signature
> **Signature** = `object`
Defined in: [src/primitives/Transaction/types.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L53)
Signature components (ECDSA secp256k1)
#### Properties
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/types.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L54)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/types.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L55)
***
### Transaction
> **Transaction** = [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L138)
***
### VersionedHash
> **VersionedHash** = [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/types.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/types.ts#L48)
Versioned hash for EIP-4844 blob transactions
## Functions
### assertSigned()
> **assertSigned**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:232](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L232)
Assert transaction is signed
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### assertSigned\_internal()
> **assertSigned\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/assertSigned.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/assertSigned.ts#L17)
Assert transaction is signed (has non-zero signature).
#### Parameters
##### this
[`Any`](#any)
#### Returns
`void`
void
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction is not signed
#### Example
```javascript theme={null}
import { assertSigned } from './primitives/Transaction/assertSigned.js';
assertSigned.call(tx);
```
***
### deserialize()
> **deserialize**(`data`): [`Any`](#any)
Defined in: [src/primitives/Transaction/deserialize.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/deserialize.ts#L24)
Deserialize RLP encoded transaction.
#### Parameters
##### data
`Uint8Array`
RLP encoded transaction data
#### Returns
[`Any`](#any)
Deserialized transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/deserialize.js';
const tx = deserialize(bytes);
```
***
### detectType()
> **detectType**(`data`): [`Type`](#type)
Defined in: [src/primitives/Transaction/detectType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/detectType.ts#L13)
Detect transaction type from serialized data
#### Parameters
##### data
`Uint8Array`
#### Returns
[`Type`](#type)
#### Throws
If transaction data is empty
#### Throws
If transaction type byte is unknown
***
### format()
> **format**(`tx`): `string`
Defined in: [src/primitives/Transaction/Transaction.ts:197](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L197)
Format transaction to human-readable string
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`string`
***
### format\_internal()
> **format\_internal**(`this`): `string`
Defined in: [src/primitives/Transaction/format.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/format.ts#L6)
Format transaction to human-readable string
#### Parameters
##### this
[`Any`](#any)
#### Returns
`string`
***
### fromRpc()
> **fromRpc**(`rpc`): [`Any`](#any)
Defined in: [src/primitives/Transaction/fromRpc.js:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/fromRpc.js#L110)
Parse transaction from JSON-RPC format
#### Parameters
##### rpc
`RpcTransaction`
JSON-RPC formatted transaction
#### Returns
[`Any`](#any)
Parsed transaction
#### Example
```javascript theme={null}
import * as Transaction from './primitives/Transaction/index.js';
const tx = Transaction.fromRpc({
type: '0x2',
chainId: '0x1',
nonce: '0x0',
// ...
});
```
***
### getAccessList()
> **getAccessList**(`tx`): [`AccessList`](#accesslist)
Defined in: [src/primitives/Transaction/Transaction.ts:218](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L218)
Get access list (empty for legacy transactions)
#### Parameters
##### tx
[`Any`](#any)
#### Returns
[`AccessList`](#accesslist)
***
### getAccessList\_internal()
> **getAccessList\_internal**(`this`): [`AccessList`](#accesslist)
Defined in: [src/primitives/Transaction/getAccessList.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getAccessList.ts#L17)
Get access list (empty for legacy transactions).
#### Parameters
##### this
[`Any`](#any)
#### Returns
[`AccessList`](#accesslist)
Transaction access list
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getAccessList } from './primitives/Transaction/getAccessList.js';
const accessList = getAccessList.call(tx);
```
***
### getAuthorizationCount()
> **getAuthorizationCount**(`tx`): `number`
Defined in: [src/primitives/Transaction/Transaction.ts:353](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L353)
Get authorization count for EIP-7702 transaction
#### Parameters
##### tx
`EIP7702`
#### Returns
`number`
***
### getAuthorizationCount\_internal()
> **getAuthorizationCount\_internal**(`this`): `number`
Defined in: [src/primitives/Transaction/getAuthorizationCount.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getAuthorizationCount.ts#L8)
Get authorization count for EIP-7702 transaction
#### Parameters
##### this
`EIP7702`
EIP7702 transaction
#### Returns
`number`
Number of authorizations
***
### getAuthorizations()
> **getAuthorizations**(`tx`): [`AuthorizationList`](#authorizationlist)
Defined in: [src/primitives/Transaction/Transaction.ts:360](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L360)
Get authorization list for EIP-7702 transaction
#### Parameters
##### tx
`EIP7702`
#### Returns
[`AuthorizationList`](#authorizationlist)
***
### getAuthorizations\_internal()
> **getAuthorizations\_internal**(`this`): [`AuthorizationList`](#authorizationlist)
Defined in: [src/primitives/Transaction/getAuthorizations.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getAuthorizations.ts#L8)
Get authorization list for EIP-7702 transaction
#### Parameters
##### this
`EIP7702`
EIP7702 transaction
#### Returns
[`AuthorizationList`](#authorizationlist)
Array of authorizations
***
### getBlobCount()
> **getBlobCount**(`tx`): `number`
Defined in: [src/primitives/Transaction/Transaction.ts:339](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L339)
Get blob count for EIP-4844 transaction
#### Parameters
##### tx
`EIP4844`
#### Returns
`number`
***
### getBlobCount\_internal()
> **getBlobCount\_internal**(`this`): `number`
Defined in: [src/primitives/Transaction/getBlobCount.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getBlobCount.ts#L8)
Get blob count for EIP-4844 transaction
#### Parameters
##### this
`EIP4844`
EIP4844 transaction
#### Returns
`number`
Number of blobs
***
### getBlobVersionedHashes()
> **getBlobVersionedHashes**(`tx`): readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/Transaction/Transaction.ts:346](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L346)
Get blob versioned hashes for EIP-4844 transaction
#### Parameters
##### tx
`EIP4844`
#### Returns
readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
***
### getBlobVersionedHashes\_internal()
> **getBlobVersionedHashes\_internal**(`this`): readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Defined in: [src/primitives/Transaction/getBlobVersionedHashes.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getBlobVersionedHashes.ts#L8)
Get blob versioned hashes for EIP-4844 transaction
#### Parameters
##### this
`EIP4844`
EIP4844 transaction
#### Returns
readonly [`HashType`](../../index/namespaces/HashType.mdx#hashtype)\[]
Array of versioned hashes
***
### getChainId()
> **getChainId**(`tx`): `bigint` | `null`
Defined in: [src/primitives/Transaction/Transaction.ts:225](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L225)
Get chain ID from transaction
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`bigint` | `null`
***
### getChainId\_internal()
> **getChainId\_internal**(`this`): `bigint` | `null`
Defined in: [src/primitives/Transaction/getChainId.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getChainId.ts#L18)
Get chain ID (null for pre-EIP-155 legacy transactions).
#### Parameters
##### this
[`Any`](#any)
#### Returns
`bigint` | `null`
Chain ID or null for pre-EIP-155
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getChainId } from './primitives/Transaction/getChainId.js';
const chainId = getChainId.call(tx);
```
***
### getGasPrice()
> **getGasPrice**(`tx`, `baseFee?`): `bigint`
Defined in: [src/primitives/Transaction/Transaction.ts:204](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L204)
Get effective gas price for transaction
#### Parameters
##### tx
[`Any`](#any)
##### baseFee?
`bigint`
#### Returns
`bigint`
***
### getGasPrice\_internal()
> **getGasPrice\_internal**(`this`, `baseFee?`): `bigint`
Defined in: [src/primitives/Transaction/getGasPrice.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getGasPrice.ts#L32)
Get transaction gas price (handles different types).
#### Parameters
##### this
[`Any`](#any)
##### baseFee?
`bigint`
Optional base fee for EIP-1559 transactions
#### Returns
`bigint`
Gas price
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If baseFee is missing for EIP-1559+ transactions
#### Throws
If transaction type is unknown
#### Example
```javascript theme={null}
import { getGasPrice } from './primitives/Transaction/getGasPrice.js';
const gasPrice = getGasPrice.call(tx, 20n);
```
***
### getRecipient()
> **getRecipient**(`tx`): [`AddressType`](../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/Transaction.ts:246](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L246)
Get recipient address from transaction
#### Parameters
##### tx
[`Any`](#any)
#### Returns
[`AddressType`](../Address.mdx#addresstype) | `null`
***
### getRecipient\_internal()
> **getRecipient\_internal**(`this`): [`AddressType`](../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/getRecipient.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getRecipient.ts#L20)
Get recipient address from transaction.
Returns the `to` field of the transaction. For contract creation transactions
where `to` is null, this returns null.
#### Parameters
##### this
[`Any`](#any)
Transaction
#### Returns
[`AddressType`](../Address.mdx#addresstype) | `null`
Recipient address or null for contract creation
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { getRecipient } from './primitives/Transaction/getRecipient.js';
const recipient = getRecipient.call(tx);
```
***
### getSender()
> **getSender**(`tx`): [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Transaction.ts:183](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L183)
Get sender address from transaction signature
#### Parameters
##### tx
[`Any`](#any)
#### Returns
[`AddressType`](../Address.mdx#addresstype)
***
### getSender\_internal()
> **getSender\_internal**(`this`): [`AddressType`](../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/getSender.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getSender.ts#L23)
Get sender address from transaction signature.
#### Parameters
##### this
[`Any`](#any)
#### Returns
[`AddressType`](../Address.mdx#addresstype)
Sender address
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/getSender.js';
const sender = getSender.call(tx);
```
***
### getSigningHash()
> **getSigningHash**(`tx`): [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/Transaction.ts:176](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L176)
Get signing hash for transaction
#### Parameters
##### tx
[`Any`](#any)
#### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
***
### getSigningHash\_internal()
> **getSigningHash\_internal**(`this`): [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/getSigningHash.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/getSigningHash.ts#L23)
Get signing hash for transaction.
#### Parameters
##### this
[`Any`](#any)
#### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Signing hash
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { getSigningHash } from './primitives/Transaction/getSigningHash.js';
const signingHash = getSigningHash.call(tx);
```
***
### hasAccessList()
> **hasAccessList**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Transaction.ts:211](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L211)
Check if transaction has access list
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`boolean`
***
### hasAccessList\_internal()
> **hasAccessList\_internal**(`this`): `boolean`
Defined in: [src/primitives/Transaction/hasAccessList.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/hasAccessList.ts#L7)
Check if transaction has access list
#### Parameters
##### this
[`Any`](#any)
#### Returns
`boolean`
***
### hash()
> **hash**(`tx`): [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/Transaction.ts:169](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L169)
Compute transaction hash
#### Parameters
##### tx
[`Any`](#any)
#### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
***
### hash\_internal()
> **hash\_internal**(`this`): [`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/hash.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/hash.ts#L23)
Compute transaction hash.
#### Parameters
##### this
[`Any`](#any)
#### Returns
[`HashType`](../../index/namespaces/HashType.mdx#hashtype)
Transaction hash
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { hash } from './primitives/Transaction/hash.js';
const txHash = hash.call(tx);
```
***
### isContractCall()
> **isContractCall**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Transaction.ts:260](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L260)
Check if transaction is a contract call
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`boolean`
***
### isContractCall\_internal()
> **isContractCall\_internal**(`this`): `boolean`
Defined in: [src/primitives/Transaction/isContractCall.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/isContractCall.ts#L7)
Check if transaction is a contract call
#### Parameters
##### this
Transaction
###### data
`Uint8Array`
###### to
`any`
#### Returns
`boolean`
True if to exists and data is present
***
### isContractCreation()
> **isContractCreation**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Transaction.ts:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L253)
Check if transaction is a contract creation
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`boolean`
***
### isContractCreation\_internal()
> **isContractCreation\_internal**(`this`): `boolean`
Defined in: [src/primitives/Transaction/isContractCreation.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/isContractCreation.ts#L7)
Check if transaction is a contract creation
#### Parameters
##### this
Transaction
###### to
`any`
#### Returns
`boolean`
True if to field is null
***
### isEIP1559()
> **isEIP1559**(`tx`): `tx is EIP1559`
Defined in: [src/primitives/Transaction/typeGuards.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/typeGuards.ts#L32)
Check if transaction is EIP-1559 type
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`tx is EIP1559`
***
### isEIP2930()
> **isEIP2930**(`tx`): `tx is EIP2930`
Defined in: [src/primitives/Transaction/typeGuards.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/typeGuards.ts#L25)
Check if transaction is EIP-2930 type
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`tx is EIP2930`
***
### isEIP4844()
> **isEIP4844**(`tx`): `tx is EIP4844`
Defined in: [src/primitives/Transaction/typeGuards.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/typeGuards.ts#L39)
Check if transaction is EIP-4844 type
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`tx is EIP4844`
***
### isEIP7702()
> **isEIP7702**(`tx`): `tx is EIP7702`
Defined in: [src/primitives/Transaction/typeGuards.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/typeGuards.ts#L46)
Check if transaction is EIP-7702 type
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`tx is EIP7702`
***
### isLegacy()
> **isLegacy**(`tx`): `tx is Legacy`
Defined in: [src/primitives/Transaction/typeGuards.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/typeGuards.ts#L18)
Check if transaction is Legacy type
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`tx is Legacy`
***
### isSigned()
> **isSigned**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Transaction.ts:239](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L239)
Check if transaction is signed
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`boolean`
***
### isSigned\_internal()
> **isSigned\_internal**(`this`): `boolean`
Defined in: [src/primitives/Transaction/isSigned.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/isSigned.ts#L17)
Check if transaction is signed.
#### Parameters
##### this
[`Any`](#any)
#### Returns
`boolean`
True if transaction has valid signature
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { isSigned } from './primitives/Transaction/isSigned.js';
const signed = isSigned.call(tx);
```
***
### replaceWith()
> **replaceWith**(`tx`, `options?`): [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:332](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L332)
Return new transaction with fee bump for replacement
#### Parameters
##### tx
[`Any`](#any)
##### options?
[`ReplaceOptions`](#replaceoptions)
#### Returns
[`Any`](#any)
***
### replaceWith\_internal()
> **replaceWith\_internal**(`this`, `options`): [`Any`](#any)
Defined in: [src/primitives/Transaction/replaceWith.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/replaceWith.ts#L30)
Return new transaction with fee bump for replacement
#### Parameters
##### this
[`Any`](#any)
Transaction
##### options
[`ReplaceOptions`](#replaceoptions) = `{}`
Replacement options
#### Returns
[`Any`](#any)
New transaction with increased fees
***
### serialize()
> **serialize**(`tx`): `Uint8Array`
Defined in: [src/primitives/Transaction/Transaction.ts:162](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L162)
Serialize transaction to RLP encoded bytes
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`Uint8Array`
***
### serialize\_internal()
> **serialize\_internal**(`this`): `Uint8Array`
Defined in: [src/primitives/Transaction/serialize.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/serialize.ts#L22)
Serialize transaction to RLP encoded bytes.
#### Parameters
##### this
[`Any`](#any)
#### Returns
`Uint8Array`
RLP encoded transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/serialize.js';
const bytes = serialize.call(tx);
```
***
### toRpc()
> **toRpc**(`tx`): `object`
Defined in: [src/primitives/Transaction/toRpc.js:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/toRpc.js#L46)
Convert transaction to JSON-RPC format
#### Parameters
##### tx
[`Any`](#any)
Transaction to convert
#### Returns
`object`
JSON-RPC formatted transaction
#### Example
```javascript theme={null}
import * as Transaction from './primitives/Transaction/index.js';
const tx = Transaction.deserialize(serialized);
const rpc = Transaction.toRpc(tx);
// { type: '0x2', chainId: '0x1', nonce: '0x0', ... }
```
***
### validateChainId()
> **validateChainId**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:295](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L295)
Validate chain ID is present
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### validateChainId\_internal()
> **validateChainId\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/validateChainId.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/validateChainId.ts#L9)
Validate chain ID is present
#### Parameters
##### this
Transaction
`EIP2930` | `EIP1559` | `EIP4844` | `EIP7702`
#### Returns
`void`
#### Throws
If chainId is missing or invalid
***
### validateGasLimit()
> **validateGasLimit**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:274](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L274)
Validate gas limit is valid
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### validateGasLimit\_internal()
> **validateGasLimit\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/validateGasLimit.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/validateGasLimit.ts#L8)
Validate gas limit is valid
#### Parameters
##### this
Transaction
###### gasLimit
`bigint`
#### Returns
`void`
#### Throws
If gas limit is non-positive or exceeds maximum
***
### validateGasPrice()
> **validateGasPrice**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:267](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L267)
Validate gas price is reasonable
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### validateGasPrice\_internal()
> **validateGasPrice\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/validateGasPrice.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/validateGasPrice.ts#L9)
Validate gas price is reasonable
#### Parameters
##### this
Transaction
`Legacy` | `EIP2930` | `EIP1559` | `EIP4844` | `EIP7702`
#### Returns
`void`
#### Throws
If gas price or fee values are invalid
***
### validateNonce()
> **validateNonce**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:281](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L281)
Validate nonce format
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### validateNonce\_internal()
> **validateNonce\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/validateNonce.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/validateNonce.ts#L8)
Validate nonce format
#### Parameters
##### this
Transaction
###### nonce
`bigint`
#### Returns
`void`
#### Throws
If nonce is negative
***
### validateValue()
> **validateValue**(`tx`): `void`
Defined in: [src/primitives/Transaction/Transaction.ts:288](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L288)
Validate value is valid
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`void`
***
### validateValue\_internal()
> **validateValue\_internal**(`this`): `void`
Defined in: [src/primitives/Transaction/validateValue.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/validateValue.ts#L8)
Validate value is valid
#### Parameters
##### this
Transaction
###### value
`bigint`
#### Returns
`void`
#### Throws
If value is negative
***
### verifySignature()
> **verifySignature**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Transaction.ts:190](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L190)
Verify transaction signature
#### Parameters
##### tx
[`Any`](#any)
#### Returns
`boolean`
***
### verifySignature\_internal()
> **verifySignature\_internal**(`this`): `boolean`
Defined in: [src/primitives/Transaction/verifySignature.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/verifySignature.ts#L27)
Verify transaction signature.
#### Parameters
##### this
[`Any`](#any)
#### Returns
`boolean`
True if signature is valid
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction type is unknown or unsupported
#### Example
```javascript theme={null}
import { verifySignature } from './primitives/Transaction/verifySignature.js';
const isValid = verifySignature.call(tx);
```
***
### withData()
> **withData**(`tx`, `data`): [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:325](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L325)
Return new transaction with updated data
#### Parameters
##### tx
[`Any`](#any)
##### data
`Uint8Array`
#### Returns
[`Any`](#any)
***
### withData\_internal()
> **withData\_internal**(`this`, `data`): [`Any`](#any)
Defined in: [src/primitives/Transaction/withData.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/withData.ts#L9)
Return new transaction with updated data
#### Parameters
##### this
[`Any`](#any)
Transaction
##### data
`Uint8Array`
New data value
#### Returns
[`Any`](#any)
New transaction with updated data
***
### withGasLimit()
> **withGasLimit**(`tx`, `gasLimit`): [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:311](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L311)
Return new transaction with updated gas limit
#### Parameters
##### tx
[`Any`](#any)
##### gasLimit
`bigint`
#### Returns
[`Any`](#any)
***
### withGasLimit\_internal()
> **withGasLimit\_internal**(`this`, `gasLimit`): [`Any`](#any)
Defined in: [src/primitives/Transaction/withGasLimit.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/withGasLimit.ts#L9)
Return new transaction with updated gas limit
#### Parameters
##### this
[`Any`](#any)
Transaction
##### gasLimit
`bigint`
New gas limit value
#### Returns
[`Any`](#any)
New transaction with updated gas limit
***
### withGasPrice()
> **withGasPrice**(`tx`, `gasPrice`): [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:318](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L318)
Return new transaction with updated gas price
#### Parameters
##### tx
[`Any`](#any)
##### gasPrice
`bigint`
#### Returns
[`Any`](#any)
***
### withGasPrice\_internal()
> **withGasPrice\_internal**(`this`, `gasPrice`): [`Any`](#any)
Defined in: [src/primitives/Transaction/withGasPrice.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/withGasPrice.ts#L17)
Return new transaction with updated gas price
For EIP-1559+ transactions, updates maxFeePerGas
#### Parameters
##### this
[`Any`](#any)
Transaction
##### gasPrice
`bigint`
New gas price value
#### Returns
[`Any`](#any)
New transaction with updated gas price
***
### withNonce()
> **withNonce**(`tx`, `nonce`): [`Any`](#any)
Defined in: [src/primitives/Transaction/Transaction.ts:304](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Transaction.ts#L304)
Return new transaction with updated nonce
#### Parameters
##### tx
[`Any`](#any)
##### nonce
`bigint`
#### Returns
[`Any`](#any)
***
### withNonce\_internal()
> **withNonce\_internal**(`this`, `nonce`): [`Any`](#any)
Defined in: [src/primitives/Transaction/withNonce.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/withNonce.ts#L9)
Return new transaction with updated nonce
#### Parameters
##### this
[`Any`](#any)
Transaction
##### nonce
`bigint`
New nonce value
#### Returns
[`Any`](#any)
New transaction with updated nonce
# Authorization
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/Authorization
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / Authorization
# Authorization
## Classes
### Authorization
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L42)
Factory function for creating Authorization instances.
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Param
Authorization parameters
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Authorization } from './primitives/Transaction/Authorization/Authorization.js';
const auth = Authorization({
chainId: 1n,
address: addr,
nonce: 0n,
yParity: 0,
r: new Uint8Array(32),
s: new Uint8Array(32)
});
const hash = Authorization.getSigningHash(auth);
```
#### Constructors
##### Constructor
> **new Authorization**(`auth`): [`Authorization`](#authorization)
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L42)
Factory function for creating Authorization instances.
###### Parameters
###### auth
Authorization parameters
###### address
[`AddressType`](../../Address.mdx#addresstype)
###### chainId
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### yParity
`number`
###### Returns
[`Authorization`](#authorization)
Authorization instance
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { Authorization } from './primitives/Transaction/Authorization/Authorization.js';
const auth = Authorization({
chainId: 1n,
address: addr,
nonce: 0n,
yParity: 0,
r: new Uint8Array(32),
s: new Uint8Array(32)
});
const hash = Authorization.getSigningHash(auth);
```
#### Properties
##### getAuthorizer()
> **getAuthorizer**: (...`args`) => `any`
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L61)
###### Parameters
###### args
...\[`any`, `...argArray: any[]`]
###### Returns
`any`
##### getSigningHash()
> **getSigningHash**: (...`args`) => `any`
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L57)
###### Parameters
###### args
...\[`any`, `...argArray: any[]`]
###### Returns
`any`
##### verifySignature()
> **verifySignature**: (...`args`) => `any`
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L59)
###### Parameters
###### args
...\[`any`, `...argArray: any[]`]
###### Returns
`any`
##### getAuthorizer()
> `static` **getAuthorizer**: (`auth`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L55)
Get authorizing address from signature.
Recovers the Ethereum address that signed the authorization
using the signature components (r, s, yParity) and the signing hash.
###### Parameters
###### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to recover from
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered authorizer address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getAuthorizer } from './primitives/Transaction/Authorization/getAuthorizer.js';
const authorizerAddr = getAuthorizer(auth);
```
##### getSigningHash()
> `static` **getSigningHash**: (`auth`) => [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L53)
Get signing hash for authorization (EIP-7702).
Per EIP-7702: keccak256(MAGIC || rlp(\[chain\_id, address, nonce]))
MAGIC = 0x05
###### Parameters
###### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to hash
###### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Signing hash
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getSigningHash } from './primitives/Transaction/Authorization/getSigningHash.js';
const hash = getSigningHash(auth);
```
##### verifySignature()
> `static` **verifySignature**: (`auth`) => `boolean`
Defined in: [src/primitives/Transaction/Authorization/Authorization.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/Authorization.js#L54)
Verify authorization signature.
Validates that the signature (r, s, yParity) is valid for the
authorization's signing hash by recovering and verifying the public key.
###### Parameters
###### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to verify
###### Returns
`boolean`
True if signature is valid
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws - returns false on error
###### Example
```javascript theme={null}
import { verifySignature } from './primitives/Transaction/Authorization/verifySignature.js';
const isValid = verifySignature(auth);
```
## Type Aliases
### BrandedAuthorization
> **BrandedAuthorization** = `object`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L7)
Branded Authorization type for EIP-7702
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"Authorization"`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L8)
##### address
> **address**: [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L10)
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L9)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L11)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L13)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L14)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/BrandedAuthorization.d.ts#L12)
## Functions
### getAuthorizer()
> **getAuthorizer**(`auth`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Authorization/getAuthorizer.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/getAuthorizer.js#L21)
Get authorizing address from signature.
Recovers the Ethereum address that signed the authorization
using the signature components (r, s, yParity) and the signing hash.
#### Parameters
##### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to recover from
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered authorizer address
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getAuthorizer } from './primitives/Transaction/Authorization/getAuthorizer.js';
const authorizerAddr = getAuthorizer(auth);
```
***
### getSigningHash()
> **getSigningHash**(`auth`): [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Transaction/Authorization/getSigningHash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/getSigningHash.js#L22)
Get signing hash for authorization (EIP-7702).
Per EIP-7702: keccak256(MAGIC || rlp(\[chain\_id, address, nonce]))
MAGIC = 0x05
#### Parameters
##### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to hash
#### Returns
[`HashType`](../../../index/namespaces/HashType.mdx#hashtype)
Signing hash
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getSigningHash } from './primitives/Transaction/Authorization/getSigningHash.js';
const hash = getSigningHash(auth);
```
***
### verifySignature()
> **verifySignature**(`auth`): `boolean`
Defined in: [src/primitives/Transaction/Authorization/verifySignature.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Authorization/verifySignature.js#L22)
Verify authorization signature.
Validates that the signature (r, s, yParity) is valid for the
authorization's signing hash by recovering and verifying the public key.
#### Parameters
##### auth
[`BrandedAuthorization`](#brandedauthorization)
Authorization to verify
#### Returns
`boolean`
True if signature is valid
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { verifySignature } from './primitives/Transaction/Authorization/verifySignature.js';
const isValid = verifySignature(auth);
```
# EIP1559
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/EIP1559
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / EIP1559
# EIP1559
## Classes
### TransactionEIP1559
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L54)
Factory function for creating EIP-1559 Transaction instances
#### Constructors
##### Constructor
> **new TransactionEIP1559**(`tx`): `TransactionEIP1559`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L54)
Factory function for creating EIP-1559 Transaction instances
###### Parameters
###### tx
`any`
###### Returns
`TransactionEIP1559`
#### Properties
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L92)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction
###### baseFee
`bigint`
Block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP1559/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 20n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L88)
Get sender address from transaction signature (EIP-1559).
Recovers the sender address from transaction signature components (r, s, yParity).
Returns a BrandedAddress (20 bytes). Assumes transaction uses branded types
with validated signature components.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Signed transaction with BrandedAddress fields
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP1559/getSender.js';
const sender = getSender(tx); // Returns BrandedAddress
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L86)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L85)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L83)
Serialize EIP-1559 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type byte prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP1559/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L90)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`boolean`
##### deserialize()
> `static` **deserialize**: (`bytes`) => `TransactionEIP1559Prototype`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L73)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP1559Prototype`
##### getEffectiveGasPrice()
> `static` **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L79)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction
###### baseFee
`bigint`
Block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP1559/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 20n);
```
##### getSender()
> `static` **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L77)
Get sender address from transaction signature (EIP-1559).
Recovers the sender address from transaction signature components (r, s, yParity).
Returns a BrandedAddress (20 bytes). Assumes transaction uses branded types
with validated signature components.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Signed transaction with BrandedAddress fields
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP1559/getSender.js';
const sender = getSender(tx); // Returns BrandedAddress
```
##### getSigningHash()
> `static` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L76)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### hash()
> `static` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L75)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### prototype
> `static` **prototype**: `object`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L82)
##### serialize()
> `static` **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L74)
Serialize EIP-1559 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type byte prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP1559/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> `static` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L78)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`boolean`
## Interfaces
### TransactionEIP1559Constructor()
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L20)
> **TransactionEIP1559Constructor**(`tx`): `TransactionEIP1559Prototype`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L21)
#### Parameters
##### tx
###### accessList
[`AccessList`](../index.mdx#accesslist)
###### chainId
`bigint`
###### data
`Uint8Array`
###### gasLimit
`bigint`
###### maxFeePerGas
`bigint`
###### maxPriorityFeePerGas
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### to
[`AddressType`](../../Address.mdx#addresstype) | `null`
###### value
`bigint`
###### yParity
`number`
#### Returns
`TransactionEIP1559Prototype`
#### Properties
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L42)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction
###### baseFee
`bigint`
Block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP1559/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 20n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L40)
Get sender address from transaction signature (EIP-1559).
Recovers the sender address from transaction signature components (r, s, yParity).
Returns a BrandedAddress (20 bytes). Assumes transaction uses branded types
with validated signature components.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Signed transaction with BrandedAddress fields
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP1559/getSender.js';
const sender = getSender(tx); // Returns BrandedAddress
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L39)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L38)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`Uint8Array`
##### prototype
> **prototype**: `TransactionEIP1559Prototype`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L35)
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L37)
Serialize EIP-1559 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type byte prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP1559/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L41)
###### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
###### Returns
`boolean`
#### Methods
##### deserialize()
> **deserialize**(`bytes`): `TransactionEIP1559Prototype`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Constructor.ts#L36)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP1559Prototype`
## Type Aliases
### BrandedTransactionEIP1559
> **BrandedTransactionEIP1559** = [`TransactionEIP1559Type`](#transactioneip1559type)
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L26)
***
### TransactionEIP1559Type
> **TransactionEIP1559Type** = `object`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L8)
EIP-1559 Transaction type
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TransactionEIP1559"`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L9)
##### accessList
> **accessList**: [`AccessList`](../index.mdx#accesslist)
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L19)
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L11)
##### data
> **data**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L18)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L15)
##### maxFeePerGas
> **maxFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L14)
##### maxPriorityFeePerGas
> **maxPriorityFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L13)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L12)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L21)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L22)
##### to
> **to**: [`AddressType`](../../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L16)
##### type
> **type**: [`EIP1559`](../index.mdx#eip1559)
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L10)
##### value
> **value**: `bigint`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L17)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/TransactionEIP1559Type.ts#L20)
## Variables
### getSigningHash()
> `const` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L21)
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
#### Returns
`Uint8Array`
***
### hash()
> `const` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L22)
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
#### Returns
`Uint8Array`
***
### verifySignature()
> `const` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP1559/EIP1559.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/EIP1559.js#L23)
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
#### Returns
`boolean`
## Functions
### deserialize()
> **deserialize**(`data`): [`TransactionEIP1559Type`](#transactioneip1559type)
Defined in: [src/primitives/Transaction/EIP1559/deserialize.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/deserialize.js#L20)
Deserialize RLP encoded EIP-1559 transaction.
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type byte prefix
#### Returns
[`TransactionEIP1559Type`](#transactioneip1559type)
Deserialized transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction format is invalid
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/EIP1559/deserialize.js';
const tx = deserialize(encodedBytes);
```
***
### getEffectiveGasPrice()
> **getEffectiveGasPrice**(`tx`, `baseFee`): `bigint`
Defined in: [src/primitives/Transaction/EIP1559/getEffectiveGasPrice.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/getEffectiveGasPrice.js#L16)
Calculate effective gas price given base fee.
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction
##### baseFee
`bigint`
Block base fee
#### Returns
`bigint`
Effective gas price
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP1559/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 20n);
```
***
### getSender()
> **getSender**(`tx`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP1559/getSender.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/getSender.js#L22)
Get sender address from transaction signature (EIP-1559).
Recovers the sender address from transaction signature components (r, s, yParity).
Returns a BrandedAddress (20 bytes). Assumes transaction uses branded types
with validated signature components.
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Signed transaction with BrandedAddress fields
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP1559/getSender.js';
const sender = getSender(tx); // Returns BrandedAddress
```
***
### GetSigningHash()
> **GetSigningHash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/getSigningHash.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/getSigningHash.js#L34)
Factory: Get signing hash for EIP-1559 transaction.
Computes the Keccak256 hash of the RLP-encoded transaction fields that need
to be signed. The transaction uses BrandedAddress for `to` field, assumed to be
validated (20 bytes). Returns a HashType (32 bytes).
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
#### Returns
Function that computes signing hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { GetSigningHash } from './primitives/Transaction/EIP1559/getSigningHash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
const getSigningHash = GetSigningHash({ keccak256, rlpEncode });
const signingHash = getSigningHash(tx);
```
***
### Hash()
> **Hash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP1559/hash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/hash.js#L22)
Factory: Compute transaction hash.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes transaction hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Hash } from './primitives/Transaction/EIP1559/hash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
const hash = Hash({ keccak256 });
const txHash = hash(tx);
```
***
### serialize()
> **serialize**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP1559/serialize.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/serialize.js#L23)
Serialize EIP-1559 transaction to RLP encoded bytes.
#### Parameters
##### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
Transaction to serialize
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type byte prefix
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP1559/serialize.js';
const encoded = serialize(tx);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP1559/verifySignature.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP1559/verifySignature.js#L43)
Factory: Verify transaction signature.
Verifies that the transaction signature is valid. This checks that:
1. The signature components (r, s) are well-formed
2. The yParity/v is valid
3. A public key can be recovered from the signature
Note: This does NOT verify the transaction was signed by a specific address.
It only validates the signature is cryptographically valid and can recover
a sender address. To verify against an expected sender, use getSender() and
compare the result.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
###### secp256k1RecoverPublicKey
`any`
secp256k1 public key recovery
#### Returns
Function that verifies signature
> (`tx`): `boolean`
##### Parameters
###### tx
[`TransactionEIP1559Type`](#transactioneip1559type)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { VerifySignature } from './primitives/Transaction/EIP1559/verifySignature.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
import { recoverPublicKey } from '../../../crypto/Secp256k1/index.js';
const verifySignature = VerifySignature({
keccak256,
rlpEncode,
secp256k1RecoverPublicKey: recoverPublicKey
});
const isValid = verifySignature(tx);
```
# EIP2930
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/EIP2930
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / EIP2930
# EIP2930
## Classes
### TransactionEIP2930
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L52)
Factory function for creating EIP-2930 Transaction instances
#### Constructors
##### Constructor
> **new TransactionEIP2930**(`tx`): `TransactionEIP2930`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L52)
Factory function for creating EIP-2930 Transaction instances
###### Parameters
###### tx
`any`
###### Returns
`TransactionEIP2930`
#### Properties
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L86)
Get sender address from EIP-2930 transaction signature.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP2930/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L84)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L83)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L81)
Serialize EIP-2930 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP2930/serialize.js';
const bytes = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L88)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`boolean`
##### getSender()
> `static` **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L76)
Get sender address from EIP-2930 transaction signature.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP2930/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> `static` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L75)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### hash()
> `static` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L74)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### prototype
> `static` **prototype**: `object`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L80)
##### serialize()
> `static` **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L73)
Serialize EIP-2930 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP2930/serialize.js';
const bytes = serialize(tx);
```
##### verifySignature()
> `static` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L77)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`boolean`
## Interfaces
### TransactionEIP2930Constructor()
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L18)
> **TransactionEIP2930Constructor**(`tx`): `TransactionEIP2930Prototype`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L19)
#### Parameters
##### tx
###### accessList
[`AccessList`](../index.mdx#accesslist)
###### chainId
`bigint`
###### data
`Uint8Array`
###### gasLimit
`bigint`
###### gasPrice
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### to
[`AddressType`](../../Address.mdx#addresstype) | `null`
###### value
`bigint`
###### yParity
`number`
#### Returns
`TransactionEIP2930Prototype`
#### Properties
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L37)
Get sender address from EIP-2930 transaction signature.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP2930/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L36)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L35)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`Uint8Array`
##### prototype
> **prototype**: `TransactionEIP2930Prototype`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L32)
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L34)
Serialize EIP-2930 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP2930/serialize.js';
const bytes = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L38)
###### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
###### Returns
`boolean`
#### Methods
##### deserialize()
> **deserialize**(`bytes`): `TransactionEIP2930Prototype`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Constructor.ts#L33)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP2930Prototype`
## Type Aliases
### TransactionEIP2930Type
> **TransactionEIP2930Type** = `object`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L11)
EIP-2930 Transaction type (Access List Transaction)
#### See
[https://eips.ethereum.org/EIPS/eip-2930](https://eips.ethereum.org/EIPS/eip-2930)
#### Since
0.0.0
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TransactionEIP2930"`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L12)
##### accessList
> **accessList**: [`AccessList`](../index.mdx#accesslist)
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L21)
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L14)
##### data
> **data**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L20)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L17)
##### gasPrice
> **gasPrice**: `bigint`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L16)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L15)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L23)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L24)
##### to
> **to**: [`AddressType`](../../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L18)
##### type
> **type**: [`EIP2930`](../index.mdx#eip2930)
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L13)
##### value
> **value**: `bigint`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L19)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/TransactionEIP2930Type.ts#L22)
## Variables
### getSigningHash()
> `const` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L20)
#### Parameters
##### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
#### Returns
`Uint8Array`
***
### hash()
> `const` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L21)
#### Parameters
##### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
#### Returns
`Uint8Array`
***
### verifySignature()
> `const` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP2930/EIP2930.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/EIP2930.js#L22)
#### Parameters
##### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
#### Returns
`boolean`
## Functions
### deserialize()
> **deserialize**(`data`): [`TransactionEIP2930Type`](#transactioneip2930type)
Defined in: [src/primitives/Transaction/EIP2930/deserialize.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/deserialize.js#L20)
Deserialize RLP encoded EIP-2930 transaction.
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes
#### Returns
[`TransactionEIP2930Type`](#transactioneip2930type)
Deserialized transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If data is invalid or malformed
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/EIP2930/deserialize.js';
const tx = deserialize(bytes);
```
***
### getSender()
> **getSender**(`tx`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP2930/getSender.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/getSender.js#L18)
Get sender address from EIP-2930 transaction signature.
#### Parameters
##### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP2930/getSender.js';
const sender = getSender(tx);
```
***
### GetSigningHash()
> **GetSigningHash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/getSigningHash.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/getSigningHash.js#L30)
Factory: Get signing hash for EIP-2930 transaction.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
#### Returns
Function that computes signing hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { GetSigningHash } from './primitives/Transaction/EIP2930/getSigningHash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
const getSigningHash = GetSigningHash({ keccak256, rlpEncode });
const signingHash = getSigningHash(tx);
```
***
### Hash()
> **Hash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP2930/hash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/hash.js#L22)
Factory: Compute transaction hash.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes transaction hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Hash } from './primitives/Transaction/EIP2930/hash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
const hash = Hash({ keccak256 });
const txHash = hash(tx);
```
***
### serialize()
> **serialize**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP2930/serialize.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/serialize.js#L23)
Serialize EIP-2930 transaction to RLP encoded bytes.
#### Parameters
##### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
Transaction to serialize
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP2930/serialize.js';
const bytes = serialize(tx);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP2930/verifySignature.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP2930/verifySignature.js#L43)
Factory: Verify EIP-2930 transaction signature.
Verifies that the transaction signature is valid. This checks that:
1. The signature components (r, s) are well-formed
2. The yParity is valid
3. A public key can be recovered from the signature
Note: This does NOT verify the transaction was signed by a specific address.
It only validates the signature is cryptographically valid and can recover
a sender address. To verify against an expected sender, use getSender() and
compare the result.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
###### secp256k1RecoverPublicKey
`any`
secp256k1 public key recovery
#### Returns
Function that verifies signature
> (`tx`): `boolean`
##### Parameters
###### tx
[`TransactionEIP2930Type`](#transactioneip2930type)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { VerifySignature } from './primitives/Transaction/EIP2930/verifySignature.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
import { recoverPublicKey } from '../../../crypto/Secp256k1/index.js';
const verifySignature = VerifySignature({
keccak256,
rlpEncode,
secp256k1RecoverPublicKey: recoverPublicKey
});
const isValid = verifySignature(tx);
```
# EIP4844
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/EIP4844
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / EIP4844
# EIP4844
## Classes
### TransactionEIP4844
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L56)
Factory function for creating EIP-4844 Transaction instances
#### Constructors
##### Constructor
> **new TransactionEIP4844**(`tx`): [`TransactionEIP4844`](#transactioneip4844)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L56)
Factory function for creating EIP-4844 Transaction instances
###### Parameters
###### tx
`any`
###### Returns
[`TransactionEIP4844`](#transactioneip4844)
#### Properties
##### getBlobGasCost()
> **getBlobGasCost**: (`tx`, `blobBaseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L99)
Calculate total blob gas cost.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### blobBaseFee
`bigint`
Blob base fee per gas
###### Returns
`bigint`
Total blob gas cost
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getBlobGasCost } from './primitives/Transaction/EIP4844/getBlobGasCost.js';
const cost = getBlobGasCost(tx, 1000000n);
```
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L97)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### baseFee
`bigint`
Base fee per gas
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP4844/getEffectiveGasPrice.js';
const price = getEffectiveGasPrice(tx, 1000000000n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L93)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP4844/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L91)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L90)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L88)
Serialize EIP-4844 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP4844/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L95)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`boolean`
##### getBlobGasCost()
> `static` **getBlobGasCost**: (`tx`, `blobBaseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L86)
Calculate total blob gas cost.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### blobBaseFee
`bigint`
Blob base fee per gas
###### Returns
`bigint`
Total blob gas cost
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getBlobGasCost } from './primitives/Transaction/EIP4844/getBlobGasCost.js';
const cost = getBlobGasCost(tx, 1000000n);
```
##### getEffectiveGasPrice()
> `static` **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L85)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### baseFee
`bigint`
Base fee per gas
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP4844/getEffectiveGasPrice.js';
const price = getEffectiveGasPrice(tx, 1000000000n);
```
##### getSender()
> `static` **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L83)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP4844/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> `static` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L82)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### hash()
> `static` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L81)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### serialize()
> `static` **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L80)
Serialize EIP-4844 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP4844/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> `static` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L84)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`boolean`
## Interfaces
### TransactionEIP4844Constructor()
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L22)
> **TransactionEIP4844Constructor**(`tx`): `TransactionEIP4844Prototype`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L23)
#### Parameters
##### tx
###### accessList
[`AccessList`](../index.mdx#accesslist)
###### blobVersionedHashes
readonly [`HashType`](../../../index/namespaces/HashType.mdx#hashtype)\[]
###### chainId
`bigint`
###### data
`Uint8Array`
###### gasLimit
`bigint`
###### maxFeePerBlobGas
`bigint`
###### maxFeePerGas
`bigint`
###### maxPriorityFeePerGas
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### to
[`AddressType`](../../Address.mdx#addresstype)
###### value
`bigint`
###### yParity
`number`
#### Returns
`TransactionEIP4844Prototype`
#### Properties
##### getBlobGasCost()
> **getBlobGasCost**: (`tx`, `blobBaseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L47)
Calculate total blob gas cost.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### blobBaseFee
`bigint`
Blob base fee per gas
###### Returns
`bigint`
Total blob gas cost
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getBlobGasCost } from './primitives/Transaction/EIP4844/getBlobGasCost.js';
const cost = getBlobGasCost(tx, 1000000n);
```
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L46)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### baseFee
`bigint`
Base fee per gas
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP4844/getEffectiveGasPrice.js';
const price = getEffectiveGasPrice(tx, 1000000000n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L44)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP4844/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L43)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L42)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`Uint8Array`
##### prototype
> **prototype**: `TransactionEIP4844Prototype`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L39)
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L41)
Serialize EIP-4844 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP4844/serialize.js';
const encoded = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L45)
###### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
###### Returns
`boolean`
#### Methods
##### deserialize()
> **deserialize**(`bytes`): `TransactionEIP4844Prototype`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Constructor.ts#L40)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP4844Prototype`
## Type Aliases
### TransactionEIP4844Type
> **TransactionEIP4844Type** = `object`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L8)
EIP-4844 Transaction type
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TransactionEIP4844"`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L9)
##### accessList
> **accessList**: [`AccessList`](../index.mdx#accesslist)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L19)
##### blobVersionedHashes
> **blobVersionedHashes**: readonly [`VersionedHash`](../index.mdx#versionedhash)\[]
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L21)
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L11)
##### data
> **data**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L18)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L15)
##### maxFeePerBlobGas
> **maxFeePerBlobGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L20)
##### maxFeePerGas
> **maxFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L14)
##### maxPriorityFeePerGas
> **maxPriorityFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L13)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L12)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L23)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L24)
##### to
> **to**: [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L16)
##### type
> **type**: [`EIP4844`](../index.mdx#eip4844)
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L10)
##### value
> **value**: `bigint`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L17)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844Type.ts#L22)
## Variables
### getSigningHash()
> `const` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L22)
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
#### Returns
`Uint8Array`
***
### hash()
> `const` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L23)
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
#### Returns
`Uint8Array`
***
### verifySignature()
> `const` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP4844/TransactionEIP4844.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/TransactionEIP4844.js#L24)
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
#### Returns
`boolean`
## Functions
### deserialize()
> **deserialize**(`data`): `EIP4844`
Defined in: [src/primitives/Transaction/EIP4844/deserialize.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/deserialize.js#L20)
Deserialize RLP encoded EIP-4844 transaction.
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
#### Returns
`EIP4844`
Deserialized transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If data is invalid or malformed
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/EIP4844/deserialize.js';
const tx = deserialize(encodedData);
```
***
### getBlobGasCost()
> **getBlobGasCost**(`tx`, `blobBaseFee`): `bigint`
Defined in: [src/primitives/Transaction/EIP4844/getBlobGasCost.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/getBlobGasCost.js#L16)
Calculate total blob gas cost.
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
##### blobBaseFee
`bigint`
Blob base fee per gas
#### Returns
`bigint`
Total blob gas cost
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getBlobGasCost } from './primitives/Transaction/EIP4844/getBlobGasCost.js';
const cost = getBlobGasCost(tx, 1000000n);
```
***
### getEffectiveGasPrice()
> **getEffectiveGasPrice**(`tx`, `baseFee`): `bigint`
Defined in: [src/primitives/Transaction/EIP4844/getEffectiveGasPrice.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/getEffectiveGasPrice.js#L16)
Calculate effective gas price given base fee.
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
##### baseFee
`bigint`
Base fee per gas
#### Returns
`bigint`
Effective gas price
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP4844/getEffectiveGasPrice.js';
const price = getEffectiveGasPrice(tx, 1000000000n);
```
***
### getSender()
> **getSender**(`tx`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP4844/getSender.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/getSender.js#L18)
Get sender address from signature.
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP4844/getSender.js';
const sender = getSender(tx);
```
***
### GetSigningHash()
> **GetSigningHash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/getSigningHash.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/getSigningHash.js#L26)
Factory: Get signing hash for EIP-4844 transaction.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
#### Returns
Function that computes signing hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { GetSigningHash } from './primitives/Transaction/EIP4844/getSigningHash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
const getSigningHash = GetSigningHash({ keccak256, rlpEncode });
const sigHash = getSigningHash(tx);
```
***
### Hash()
> **Hash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP4844/hash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/hash.js#L22)
Factory: Compute transaction hash.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes transaction hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Hash } from './primitives/Transaction/EIP4844/hash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
const hash = Hash({ keccak256 });
const txHash = hash(tx);
```
***
### serialize()
> **serialize**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP4844/serialize.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/serialize.js#L19)
Serialize EIP-4844 transaction to RLP encoded bytes.
#### Parameters
##### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
EIP-4844 transaction
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP4844/serialize.js';
const encoded = serialize(tx);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP4844/verifySignature.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP4844/verifySignature.js#L38)
Factory: Verify transaction signature.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
###### secp256k1RecoverPublicKey
`any`
secp256k1 public key recovery
###### secp256k1Verify
`any`
secp256k1 signature verification
#### Returns
Function that verifies signature
> (`tx`): `boolean`
##### Parameters
###### tx
[`TransactionEIP4844Type`](#transactioneip4844type)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { VerifySignature } from './primitives/Transaction/EIP4844/verifySignature.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
import { recoverPublicKey, verify } from '../../../crypto/Secp256k1/index.js';
const verifySignature = VerifySignature({
keccak256,
rlpEncode,
secp256k1RecoverPublicKey: recoverPublicKey,
secp256k1Verify: verify
});
const isValid = verifySignature(tx);
```
# EIP7702
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/EIP7702
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / EIP7702
# EIP7702
## Classes
### TransactionEIP7702
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L54)
Factory function for creating EIP-7702 Transaction instances
#### Constructors
##### Constructor
> **new TransactionEIP7702**(`tx`): `TransactionEIP7702`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L54)
Factory function for creating EIP-7702 Transaction instances
###### Parameters
###### tx
`any`
###### Returns
`TransactionEIP7702`
#### Properties
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L95)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction
###### baseFee
`bigint`
Current block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP7702/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 30n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L91)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction with signature
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP7702/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L89)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L88)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L86)
Serialize EIP-7702 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP7702/serialize.js';
const serialized = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L93)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`boolean`
##### deserialize()
> `static` **deserialize**: (`bytes`) => `TransactionEIP7702Prototype`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L77)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP7702Prototype`
##### getEffectiveGasPrice()
> `static` **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L83)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction
###### baseFee
`bigint`
Current block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP7702/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 30n);
```
##### getSender()
> `static` **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L81)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction with signature
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP7702/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> `static` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L80)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### hash()
> `static` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L79)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### prototype
> `static` **prototype**: `object`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L74)
##### serialize()
> `static` **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L78)
Serialize EIP-7702 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP7702/serialize.js';
const serialized = serialize(tx);
```
##### verifySignature()
> `static` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L82)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`boolean`
## Interfaces
### TransactionEIP7702Constructor()
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L20)
> **TransactionEIP7702Constructor**(`tx`): `TransactionEIP7702Prototype`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L21)
#### Parameters
##### tx
###### accessList
[`AccessList`](../index.mdx#accesslist)
###### authorizationList
[`AuthorizationList`](../index.mdx#authorizationlist)
###### chainId
`bigint`
###### data
`Uint8Array`
###### gasLimit
`bigint`
###### maxFeePerGas
`bigint`
###### maxPriorityFeePerGas
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### to
[`AddressType`](../../Address.mdx#addresstype) | `null`
###### value
`bigint`
###### yParity
`number`
#### Returns
`TransactionEIP7702Prototype`
#### Properties
##### getEffectiveGasPrice()
> **getEffectiveGasPrice**: (`tx`, `baseFee`) => `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L43)
Calculate effective gas price given base fee.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction
###### baseFee
`bigint`
Current block base fee
###### Returns
`bigint`
Effective gas price
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP7702/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 30n);
```
##### getSender()
> **getSender**: (`tx`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L41)
Get sender address from signature.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction with signature
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered sender address
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP7702/getSender.js';
const sender = getSender(tx);
```
##### getSigningHash()
> **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L40)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L39)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`Uint8Array`
##### prototype
> **prototype**: `TransactionEIP7702Prototype`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L36)
##### serialize()
> **serialize**: (`tx`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L38)
Serialize EIP-7702 transaction to RLP encoded bytes.
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction to serialize
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP7702/serialize.js';
const serialized = serialize(tx);
```
##### verifySignature()
> **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L42)
###### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
###### Returns
`boolean`
#### Methods
##### deserialize()
> **deserialize**(`bytes`): `TransactionEIP7702Prototype`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Constructor.ts#L37)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionEIP7702Prototype`
## Type Aliases
### BrandedTransactionEIP7702
> **BrandedTransactionEIP7702** = [`TransactionEIP7702Type`](#transactioneip7702type)
Defined in: [src/primitives/Transaction/EIP7702/BrandedTransactionEIP7702.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/BrandedTransactionEIP7702.ts#L6)
Branded EIP-7702 Transaction type (alias for TransactionEIP7702Type)
***
### TransactionEIP7702Type
> **TransactionEIP7702Type** = `object`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L8)
Branded EIP-7702 Transaction type
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TransactionEIP7702"`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L9)
##### accessList
> **accessList**: [`AccessList`](../index.mdx#accesslist)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L19)
##### authorizationList
> **authorizationList**: [`AuthorizationList`](../index.mdx#authorizationlist)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L20)
##### chainId
> **chainId**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L11)
##### data
> **data**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L18)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L15)
##### maxFeePerGas
> **maxFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L14)
##### maxPriorityFeePerGas
> **maxPriorityFeePerGas**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L13)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L12)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L22)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L23)
##### to
> **to**: [`AddressType`](../../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L16)
##### type
> **type**: [`EIP7702`](../index.mdx#eip7702)
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L10)
##### value
> **value**: `bigint`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L17)
##### yParity
> **yParity**: `number`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702Type.ts#L21)
## Variables
### getSigningHash()
> `const` **getSigningHash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L21)
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
#### Returns
`Uint8Array`
***
### hash()
> `const` **hash**: (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L22)
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
#### Returns
`Uint8Array`
***
### verifySignature()
> `const` **verifySignature**: (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP7702/TransactionEIP7702.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/TransactionEIP7702.js#L23)
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
#### Returns
`boolean`
## Functions
### deserialize()
> **deserialize**(`data`): `EIP7702`
Defined in: [src/primitives/Transaction/EIP7702/deserialize.js:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/deserialize.js#L25)
Deserialize RLP encoded EIP-7702 transaction.
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction bytes with type prefix
#### Returns
`EIP7702`
Deserialized transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If transaction is invalid or malformed
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/EIP7702/deserialize.js';
const tx = deserialize(bytes);
```
***
### getEffectiveGasPrice()
> **getEffectiveGasPrice**(`tx`, `baseFee`): `bigint`
Defined in: [src/primitives/Transaction/EIP7702/getEffectiveGasPrice.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/getEffectiveGasPrice.js#L16)
Calculate effective gas price given base fee.
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction
##### baseFee
`bigint`
Current block base fee
#### Returns
`bigint`
Effective gas price
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getEffectiveGasPrice } from './primitives/Transaction/EIP7702/getEffectiveGasPrice.js';
const effectivePrice = getEffectiveGasPrice(tx, 30n);
```
***
### getSender()
> **getSender**(`tx`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/EIP7702/getSender.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/getSender.js#L18)
Get sender address from signature.
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction with signature
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Recovered sender address
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/EIP7702/getSender.js';
const sender = getSender(tx);
```
***
### GetSigningHash()
> **GetSigningHash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/getSigningHash.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/getSigningHash.js#L31)
Factory: Get signing hash.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
#### Returns
Function that computes signing hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { GetSigningHash } from './primitives/Transaction/EIP7702/getSigningHash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
const getSigningHash = GetSigningHash({ keccak256, rlpEncode });
const signingHash = getSigningHash(tx);
```
***
### Hash()
> **Hash**(`deps`): (`tx`) => `Uint8Array`
Defined in: [src/primitives/Transaction/EIP7702/hash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/hash.js#L22)
Factory: Compute transaction hash.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes transaction hash
> (`tx`): `Uint8Array`
##### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Hash } from './primitives/Transaction/EIP7702/hash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
const hash = Hash({ keccak256 });
const txHash = hash(tx);
```
***
### serialize()
> **serialize**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/EIP7702/serialize.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/serialize.js#L24)
Serialize EIP-7702 transaction to RLP encoded bytes.
#### Parameters
##### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
Transaction to serialize
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction with type prefix
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/EIP7702/serialize.js';
const serialized = serialize(tx);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`tx`) => `boolean`
Defined in: [src/primitives/Transaction/EIP7702/verifySignature.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/EIP7702/verifySignature.js#L38)
Factory: Verify transaction signature.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
###### secp256k1RecoverPublicKey
`any`
secp256k1 public key recovery
###### secp256k1Verify
`any`
secp256k1 signature verification
#### Returns
Function that verifies signature
> (`tx`): `boolean`
##### Parameters
###### tx
[`TransactionEIP7702Type`](#transactioneip7702type)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { VerifySignature } from './primitives/Transaction/EIP7702/verifySignature.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
import { recoverPublicKey, verify } from '../../../crypto/Secp256k1/index.js';
const verifySignature = VerifySignature({
keccak256,
rlpEncode,
secp256k1RecoverPublicKey: recoverPublicKey,
secp256k1Verify: verify
});
const isValid = verifySignature(tx);
```
# Legacy
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/Legacy
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / Legacy
# Legacy
## Classes
### TransactionLegacy
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L78)
Factory function for creating Legacy Transaction instances
#### Constructors
##### Constructor
> **new TransactionLegacy**(`tx`): `TransactionLegacy`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L78)
Factory function for creating Legacy Transaction instances
###### Parameters
###### tx
`any`
###### Returns
`TransactionLegacy`
#### Properties
##### getChainId()
> **getChainId**: (`this`) => `bigint` | `null`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L106)
Extract chain ID from v value (EIP-155).
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`bigint` | `null`
Chain ID if EIP-155, null if pre-EIP-155
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getChainId } from './primitives/Transaction/Legacy/getChainId.js';
const chainId = getChainId.call(tx);
```
##### getSender()
> **getSender**: (`this`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L110)
Get sender address from transaction signature (Legacy).
Recovers the sender address from transaction signature components (r, s, v).
Returns a BrandedAddress (20 bytes). Handles both EIP-155 (chainId in v) and
pre-EIP-155 signatures. Assumes transaction uses branded types with validated
signature components.
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/Legacy/getSender.js';
const sender = getSender.call(tx);
```
##### getSigningHash()
> **getSigningHash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L108)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L105)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`
##### serialize()
> **serialize**: (`this`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L104)
Serialize legacy transaction to RLP encoded bytes.
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/Legacy/serialize.js';
const rlpBytes = serialize.call(tx);
```
##### verifySignature()
> **verifySignature**: (`this`) => `boolean`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L111)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`boolean`
##### deserialize()
> `static` **deserialize**: (`bytes`) => `TransactionLegacyPrototype`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L94)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionLegacyPrototype`
##### prototype
> `static` **prototype**: `object`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L103)
#### Methods
##### getChainId()
> `static` **getChainId**(`tx`): `bigint` | `null`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L97)
###### Parameters
###### tx
`any`
###### Returns
`bigint` | `null`
##### getSender()
> `static` **getSender**(`tx`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L99)
###### Parameters
###### tx
`any`
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
##### getSigningHash()
> `static` **getSigningHash**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L98)
###### Parameters
###### tx
`any`
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### hash()
> `static` **hash**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L96)
###### Parameters
###### tx
`any`
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### serialize()
> `static` **serialize**(`tx`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L95)
###### Parameters
###### tx
`any`
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
##### verifySignature()
> `static` **verifySignature**(`tx`): `boolean`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L100)
###### Parameters
###### tx
`any`
###### Returns
`boolean`
## Interfaces
### TransactionLegacyConstructor()
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L19)
> **TransactionLegacyConstructor**(`tx`): `TransactionLegacyPrototype`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L20)
#### Parameters
##### tx
###### data
`Uint8Array`
###### gasLimit
`bigint`
###### gasPrice
`bigint`
###### nonce
`bigint`
###### r
`Uint8Array`
###### s
`Uint8Array`
###### to
[`AddressType`](../../Address.mdx#addresstype) | `null`
###### v
`bigint`
###### value
`bigint`
#### Returns
`TransactionLegacyPrototype`
#### Properties
##### getChainId()
> **getChainId**: (`this`) => `bigint` | `null`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L35)
Extract chain ID from v value (EIP-155).
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`bigint` | `null`
Chain ID if EIP-155, null if pre-EIP-155
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { getChainId } from './primitives/Transaction/Legacy/getChainId.js';
const chainId = getChainId.call(tx);
```
##### getSender()
> **getSender**: (`this`) => [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L37)
Get sender address from transaction signature (Legacy).
Recovers the sender address from transaction signature components (r, s, v).
Returns a BrandedAddress (20 bytes). Handles both EIP-155 (chainId in v) and
pre-EIP-155 signatures. Assumes transaction uses branded types with validated
signature components.
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
If signature recovery fails
###### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/Legacy/getSender.js';
const sender = getSender.call(tx);
```
##### getSigningHash()
> **getSigningHash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L36)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`
##### hash()
> **hash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L34)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`
##### prototype
> **prototype**: `TransactionLegacyPrototype`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L31)
##### serialize()
> **serialize**: (`this`) => `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L33)
Serialize legacy transaction to RLP encoded bytes.
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction
###### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
###### Since
0.0.0
###### Throws
Never throws
###### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/Legacy/serialize.js';
const rlpBytes = serialize.call(tx);
```
##### verifySignature()
> **verifySignature**: (`this`) => `boolean`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L38)
###### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
###### Returns
`boolean`
#### Methods
##### deserialize()
> **deserialize**(`bytes`): `TransactionLegacyPrototype`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyConstructor.ts#L32)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
`TransactionLegacyPrototype`
## Type Aliases
### ~~BrandedTransactionLegacy~~
> **BrandedTransactionLegacy** = [`TransactionLegacyType`](#transactionlegacytype)
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L25)
#### Deprecated
Use TransactionLegacyType instead
***
### TransactionLegacyType
> **TransactionLegacyType** = `object`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L8)
Branded Legacy Transaction type
#### Properties
##### \[brand]
> `readonly` **\[brand]**: `"TransactionLegacy"`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L9)
##### data
> **data**: `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L16)
##### gasLimit
> **gasLimit**: `bigint`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L13)
##### gasPrice
> **gasPrice**: `bigint`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L12)
##### nonce
> **nonce**: `bigint`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L11)
##### r
> **r**: `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L18)
##### s
> **s**: `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L19)
##### to
> **to**: [`AddressType`](../../Address.mdx#addresstype) | `null`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L14)
##### type
> **type**: [`Legacy`](../index.mdx#legacy)
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L10)
##### v
> **v**: `bigint`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L17)
##### value
> **value**: `bigint`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacyType.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacyType.ts#L15)
## Variables
### getSigningHash()
> `const` **getSigningHash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L42)
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
`Uint8Array`
***
### hash()
> `const` **hash**: (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L43)
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
`Uint8Array`
***
### verifySignature()
> `const` **verifySignature**: (`this`) => `boolean`
Defined in: [src/primitives/Transaction/Legacy/TransactionLegacy.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/TransactionLegacy.js#L44)
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
`boolean`
## Functions
### deserialize()
> **deserialize**(`data`): [`TransactionLegacyType`](#transactionlegacytype)
Defined in: [src/primitives/Transaction/Legacy/deserialize.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/deserialize.js#L20)
Deserialize RLP encoded legacy transaction.
#### Parameters
##### data
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction data
#### Returns
[`TransactionLegacyType`](#transactionlegacytype)
Deserialized legacy transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If data is invalid or not a valid legacy transaction
#### Example
```javascript theme={null}
import { deserialize } from './primitives/Transaction/Legacy/deserialize.js';
const tx = deserialize(rlpBytes);
```
***
### getChainId()
> **getChainId**(`this`): `bigint` | `null`
Defined in: [src/primitives/Transaction/Legacy/getChainId.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/getChainId.js#L15)
Extract chain ID from v value (EIP-155).
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
`bigint` | `null`
Chain ID if EIP-155, null if pre-EIP-155
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { getChainId } from './primitives/Transaction/Legacy/getChainId.js';
const chainId = getChainId.call(tx);
```
***
### getSender()
> **getSender**(`this`): [`AddressType`](../../Address.mdx#addresstype)
Defined in: [src/primitives/Transaction/Legacy/getSender.js:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/getSender.js#L24)
Get sender address from transaction signature (Legacy).
Recovers the sender address from transaction signature components (r, s, v).
Returns a BrandedAddress (20 bytes). Handles both EIP-155 (chainId in v) and
pre-EIP-155 signatures. Assumes transaction uses branded types with validated
signature components.
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
[`AddressType`](../../Address.mdx#addresstype)
Sender address (20 bytes, branded)
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
If signature recovery fails
#### Example
```javascript theme={null}
import { getSender } from './primitives/Transaction/Legacy/getSender.js';
const sender = getSender.call(tx);
```
***
### GetSigningHash()
> **GetSigningHash**(`deps`): (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/getSigningHash.js:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/getSigningHash.js#L31)
Factory: Get signing hash for Legacy transaction.
Computes the Keccak256 hash of the RLP-encoded transaction fields that need
to be signed. Handles both EIP-155 (with chainId) and pre-EIP-155 formats.
The transaction uses BrandedAddress for `to` field, assumed to be validated
(20 bytes or null). Returns a HashType (32 bytes).
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
#### Returns
Function that computes signing hash
> (`this`): `Uint8Array`
##### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { GetSigningHash } from './primitives/Transaction/Legacy/getSigningHash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
const getSigningHash = GetSigningHash({ keccak256, rlpEncode });
const signingHash = getSigningHash.call(tx);
```
***
### Hash()
> **Hash**(`deps`): (`this`) => `Uint8Array`
Defined in: [src/primitives/Transaction/Legacy/hash.js:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/hash.js#L22)
Factory: Compute transaction hash (keccak256 of serialized transaction).
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
Function that computes transaction hash
> (`this`): `Uint8Array`
##### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
##### Returns
`Uint8Array`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { Hash } from './primitives/Transaction/Legacy/hash.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
const hash = Hash({ keccak256 });
const txHash = hash.call(tx);
```
***
### serialize()
> **serialize**(`this`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Transaction/Legacy/serialize.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/serialize.js#L18)
Serialize legacy transaction to RLP encoded bytes.
#### Parameters
##### this
[`TransactionLegacyType`](#transactionlegacytype)
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
RLP encoded transaction
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws
#### Example
```javascript theme={null}
import { serialize } from './primitives/Transaction/Legacy/serialize.js';
const rlpBytes = serialize.call(tx);
```
***
### VerifySignature()
> **VerifySignature**(`deps`): (`this`) => `boolean`
Defined in: [src/primitives/Transaction/Legacy/verifySignature.js:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Transaction/Legacy/verifySignature.js#L44)
Factory: Verify transaction signature.
Verifies that the transaction signature is valid. This checks that:
1. The signature components (r, s) are well-formed
2. The v value is valid (for pre-EIP-155 or EIP-155 format)
3. A public key can be recovered from the signature
Note: This does NOT verify the transaction was signed by a specific address.
It only validates the signature is cryptographically valid and can recover
a sender address. To verify against an expected sender, use getSender() and
compare the result.
#### Parameters
##### deps
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
###### rlpEncode
(`data`) => `Uint8Array`
RLP encode function
###### secp256k1RecoverPublicKey
`any`
secp256k1 public key recovery
#### Returns
Function that verifies signature
> (`this`): `boolean`
##### Parameters
###### this
[`TransactionLegacyType`](#transactionlegacytype)
##### Returns
`boolean`
#### See
[https://voltaire.tevm.sh/primitives/transaction](https://voltaire.tevm.sh/primitives/transaction) for Transaction documentation
#### Since
0.0.0
#### Throws
Never throws - returns false on error
#### Example
```javascript theme={null}
import { VerifySignature } from './primitives/Transaction/Legacy/verifySignature.js';
import { hash as keccak256 } from '../../../crypto/Keccak256/hash.js';
import { encode as rlpEncode } from '../../Rlp/encode.js';
import { recoverPublicKey } from '../../../crypto/Secp256k1/index.js';
const verifySignature = VerifySignature({
keccak256,
rlpEncode,
secp256k1RecoverPublicKey: recoverPublicKey
});
const isValid = verifySignature.call(tx);
```
# default
Source: https://voltaire.tevm.sh/generated-api/primitives/Transaction/namespaces/default
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [primitives/Transaction](../index.mdx) / default
# default
## References
### AccessList
Re-exports [AccessList](../index.mdx#accesslist)
***
### AccessListItem
Re-exports [AccessListItem](../index.mdx#accesslistitem)
***
### Any
Re-exports [Any](../index.mdx#any)
***
### assertSigned
Re-exports [assertSigned](../index.mdx#assertsigned)
***
### assertSigned\_internal
Re-exports [assertSigned\_internal](../index.mdx#assertsigned_internal)
***
### Authorization
Re-exports [Authorization](Authorization.mdx)
***
### AuthorizationList
Re-exports [AuthorizationList](../index.mdx#authorizationlist)
***
### deserialize
Re-exports [deserialize](../index.mdx#deserialize)
***
### detectType
Re-exports [detectType](../index.mdx#detecttype)
***
### EIP1559
Re-exports [EIP1559](EIP1559.mdx)
***
### EIP2930
Re-exports [EIP2930](EIP2930.mdx)
***
### EIP4844
Re-exports [EIP4844](EIP4844.mdx)
***
### EIP7702
Re-exports [EIP7702](EIP7702.mdx)
***
### format
Re-exports [format](../index.mdx#format)
***
### format\_internal
Re-exports [format\_internal](../index.mdx#format_internal)
***
### fromRpc
Re-exports [fromRpc](../index.mdx#fromrpc)
***
### getAccessList
Re-exports [getAccessList](../index.mdx#getaccesslist)
***
### getAccessList\_internal
Re-exports [getAccessList\_internal](../index.mdx#getaccesslist_internal)
***
### getAuthorizationCount
Re-exports [getAuthorizationCount](../index.mdx#getauthorizationcount)
***
### getAuthorizationCount\_internal
Re-exports [getAuthorizationCount\_internal](../index.mdx#getauthorizationcount_internal)
***
### getAuthorizations
Re-exports [getAuthorizations](../index.mdx#getauthorizations)
***
### getAuthorizations\_internal
Re-exports [getAuthorizations\_internal](../index.mdx#getauthorizations_internal)
***
### getBlobCount
Re-exports [getBlobCount](../index.mdx#getblobcount)
***
### getBlobCount\_internal
Re-exports [getBlobCount\_internal](../index.mdx#getblobcount_internal)
***
### getBlobVersionedHashes
Re-exports [getBlobVersionedHashes](../index.mdx#getblobversionedhashes)
***
### getBlobVersionedHashes\_internal
Re-exports [getBlobVersionedHashes\_internal](../index.mdx#getblobversionedhashes_internal)
***
### getChainId
Re-exports [getChainId](../index.mdx#getchainid)
***
### getChainId\_internal
Re-exports [getChainId\_internal](../index.mdx#getchainid_internal)
***
### getGasPrice
Re-exports [getGasPrice](../index.mdx#getgasprice)
***
### getGasPrice\_internal
Re-exports [getGasPrice\_internal](../index.mdx#getgasprice_internal)
***
### getRecipient
Re-exports [getRecipient](../index.mdx#getrecipient)
***
### getRecipient\_internal
Re-exports [getRecipient\_internal](../index.mdx#getrecipient_internal)
***
### getSender
Re-exports [getSender](../index.mdx#getsender)
***
### getSender\_internal
Re-exports [getSender\_internal](../index.mdx#getsender_internal)
***
### getSigningHash
Re-exports [getSigningHash](../index.mdx#getsigninghash)
***
### getSigningHash\_internal
Re-exports [getSigningHash\_internal](../index.mdx#getsigninghash_internal)
***
### hasAccessList
Re-exports [hasAccessList](../index.mdx#hasaccesslist)
***
### hasAccessList\_internal
Re-exports [hasAccessList\_internal](../index.mdx#hasaccesslist_internal)
***
### hash
Re-exports [hash](../index.mdx#hash)
***
### hash\_internal
Re-exports [hash\_internal](../index.mdx#hash_internal)
***
### isContractCall
Re-exports [isContractCall](../index.mdx#iscontractcall)
***
### isContractCall\_internal
Re-exports [isContractCall\_internal](../index.mdx#iscontractcall_internal)
***
### isContractCreation
Re-exports [isContractCreation](../index.mdx#iscontractcreation)
***
### isContractCreation\_internal
Re-exports [isContractCreation\_internal](../index.mdx#iscontractcreation_internal)
***
### isEIP1559
Re-exports [isEIP1559](../index.mdx#iseip1559)
***
### isEIP2930
Re-exports [isEIP2930](../index.mdx#iseip2930)
***
### isEIP4844
Re-exports [isEIP4844](../index.mdx#iseip4844)
***
### isEIP7702
Re-exports [isEIP7702](../index.mdx#iseip7702)
***
### isLegacy
Re-exports [isLegacy](../index.mdx#islegacy)
***
### isSigned
Re-exports [isSigned](../index.mdx#issigned)
***
### isSigned\_internal
Re-exports [isSigned\_internal](../index.mdx#issigned_internal)
***
### Legacy
Re-exports [Legacy](Legacy.mdx)
***
### ReplaceOptions
Re-exports [ReplaceOptions](../index.mdx#replaceoptions)
***
### replaceWith
Re-exports [replaceWith](../index.mdx#replacewith)
***
### replaceWith\_internal
Re-exports [replaceWith\_internal](../index.mdx#replacewith_internal)
***
### serialize
Re-exports [serialize](../index.mdx#serialize)
***
### serialize\_internal
Re-exports [serialize\_internal](../index.mdx#serialize_internal)
***
### Signature
Re-exports [Signature](../index.mdx#signature)
***
### toRpc
Re-exports [toRpc](../index.mdx#torpc)
***
### Transaction
Re-exports [Transaction](../index.mdx#transaction)
***
### Type
Re-exports [Type](../index.mdx#type)
***
### validateChainId
Re-exports [validateChainId](../index.mdx#validatechainid)
***
### validateChainId\_internal
Re-exports [validateChainId\_internal](../index.mdx#validatechainid_internal)
***
### validateGasLimit
Re-exports [validateGasLimit](../index.mdx#validategaslimit)
***
### validateGasLimit\_internal
Re-exports [validateGasLimit\_internal](../index.mdx#validategaslimit_internal)
***
### validateGasPrice
Re-exports [validateGasPrice](../index.mdx#validategasprice)
***
### validateGasPrice\_internal
Re-exports [validateGasPrice\_internal](../index.mdx#validategasprice_internal)
***
### validateNonce
Re-exports [validateNonce](../index.mdx#validatenonce)
***
### validateNonce\_internal
Re-exports [validateNonce\_internal](../index.mdx#validatenonce_internal)
***
### validateValue
Re-exports [validateValue](../index.mdx#validatevalue)
***
### validateValue\_internal
Re-exports [validateValue\_internal](../index.mdx#validatevalue_internal)
***
### verifySignature
Re-exports [verifySignature](../index.mdx#verifysignature)
***
### verifySignature\_internal
Re-exports [verifySignature\_internal](../index.mdx#verifysignature_internal)
***
### VersionedHash
Re-exports [VersionedHash](../index.mdx#versionedhash)
***
### withData
Re-exports [withData](../index.mdx#withdata)
***
### withData\_internal
Re-exports [withData\_internal](../index.mdx#withdata_internal)
***
### withGasLimit
Re-exports [withGasLimit](../index.mdx#withgaslimit)
***
### withGasLimit\_internal
Re-exports [withGasLimit\_internal](../index.mdx#withgaslimit_internal)
***
### withGasPrice
Re-exports [withGasPrice](../index.mdx#withgasprice)
***
### withGasPrice\_internal
Re-exports [withGasPrice\_internal](../index.mdx#withgasprice_internal)
***
### withNonce
Re-exports [withNonce](../index.mdx#withnonce)
***
### withNonce\_internal
Re-exports [withNonce\_internal](../index.mdx#withnonce_internal)
# primitives/TransactionHash
Source: https://voltaire.tevm.sh/generated-api/primitives/TransactionHash
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TransactionHash
# primitives/TransactionHash
## Classes
### InvalidTransactionHashFormatError
Defined in: [src/primitives/TransactionHash/errors.js:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L23)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTransactionHashFormatError**(`message`, `details?`): [`InvalidTransactionHashFormatError`](#invalidtransactionhashformaterror)
Defined in: [src/primitives/TransactionHash/errors.js:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L28)
###### Parameters
###### message
`string`
###### details?
[`ErrorDetails`](#errordetails)
###### Returns
[`InvalidTransactionHashFormatError`](#invalidtransactionhashformaterror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: [`ErrorDetails`](#errordetails)
Defined in: [src/primitives/TransactionHash/errors.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L33)
##### name
> **name**: `string`
Defined in: [src/primitives/TransactionHash/errors.js:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L30)
###### Inherited from
`Error.name`
***
### InvalidTransactionHashLengthError
Defined in: [src/primitives/TransactionHash/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L8)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTransactionHashLengthError**(`message`, `details?`): [`InvalidTransactionHashLengthError`](#invalidtransactionhashlengtherror)
Defined in: [src/primitives/TransactionHash/errors.js:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L13)
###### Parameters
###### message
`string`
###### details?
[`ErrorDetails`](#errordetails)
###### Returns
[`InvalidTransactionHashLengthError`](#invalidtransactionhashlengtherror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: [`ErrorDetails`](#errordetails)
Defined in: [src/primitives/TransactionHash/errors.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L18)
##### name
> **name**: `string`
Defined in: [src/primitives/TransactionHash/errors.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L15)
###### Inherited from
`Error.name`
## Interfaces
### ErrorDetails
Defined in: [src/primitives/TransactionHash/errors.js:2](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L2)
#### Properties
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/TransactionHash/errors.js:5](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L5)
##### expected?
> `optional` **expected**: `string`
Defined in: [src/primitives/TransactionHash/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L4)
##### value?
> `optional` **value**: `unknown`
Defined in: [src/primitives/TransactionHash/errors.js:3](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/errors.js#L3)
## Type Aliases
### TransactionHashType
> **TransactionHashType** = `Uint8Array` & `object`
Defined in: [src/primitives/TransactionHash/TransactionHashType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/TransactionHashType.ts#L6)
Transaction hash (32-byte identifier)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TransactionHash"`
##### length
> `readonly` **length**: `32`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/TransactionHash/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/index.ts#L14)
Check if two TransactionHashes are equal
#### Parameters
##### a
[`TransactionHashType`](#transactionhashtype)
##### b
[`TransactionHashType`](#transactionhashtype)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`TransactionHashType`](#transactionhashtype) = `_from`
Defined in: [src/primitives/TransactionHash/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/index.ts#L10)
Create TransactionHash from various input types
#### Parameters
##### value
`string` | `Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`TransactionHashType`](#transactionhashtype)
#### Throws
***
### fromBytes()
> `const` **fromBytes**: (`bytes`) => [`TransactionHashType`](#transactionhashtype) = `_fromBytes`
Defined in: [src/primitives/TransactionHash/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/index.ts#L11)
Create TransactionHash from bytes
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
#### Returns
[`TransactionHashType`](#transactionhashtype)
#### Throws
If bytes length is not 32
***
### fromHex()
> `const` **fromHex**: (`hex`) => [`TransactionHashType`](#transactionhashtype) = `_fromHex`
Defined in: [src/primitives/TransactionHash/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/index.ts#L12)
Create TransactionHash from hex string
#### Parameters
##### hex
`string`
#### Returns
[`TransactionHashType`](#transactionhashtype)
#### Throws
If hex format is invalid
***
### toHex()
> `const` **toHex**: (`hash`) => `string` = `_toHex`
Defined in: [src/primitives/TransactionHash/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionHash/index.ts#L13)
Convert TransactionHash to hex string
#### Parameters
##### hash
[`TransactionHashType`](#transactionhashtype)
#### Returns
`string`
# primitives/TransactionIndex
Source: https://voltaire.tevm.sh/generated-api/primitives/TransactionIndex
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TransactionIndex
# primitives/TransactionIndex
## Classes
### InvalidTransactionIndexError
Defined in: [src/primitives/TransactionIndex/errors.js:1](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/errors.js#L1)
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTransactionIndexError**(`message`, `details?`): [`InvalidTransactionIndexError`](#invalidtransactionindexerror)
Defined in: [src/primitives/TransactionIndex/errors.js:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/errors.js#L8)
###### Parameters
###### message
`string`
###### details?
###### expected?
`string`
###### value?
`unknown`
###### Returns
[`InvalidTransactionIndexError`](#invalidtransactionindexerror)
###### Overrides
`Error.constructor`
#### Properties
##### details
> **details**: \{ `expected?`: `string`; `value?`: `unknown`; } | `undefined`
Defined in: [src/primitives/TransactionIndex/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/TransactionIndex/errors.js:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/errors.js#L10)
###### Inherited from
`Error.name`
## Type Aliases
### TransactionIndexType
> **TransactionIndexType** = `number` & `object`
Defined in: [src/primitives/TransactionIndex/TransactionIndexType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/TransactionIndexType.ts#L6)
Transaction index in block (0-based)
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"TransactionIndex"`
## Variables
### equals()
> `const` **equals**: (`a`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/TransactionIndex/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/index.ts#L10)
Check if two TransactionIndexes are equal
#### Parameters
##### a
[`TransactionIndexType`](#transactionindextype)
##### b
[`TransactionIndexType`](#transactionindextype)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`TransactionIndexType`](#transactionindextype) = `_from`
Defined in: [src/primitives/TransactionIndex/index.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/index.ts#L8)
Create TransactionIndex from number
#### Parameters
##### value
`number` | `bigint`
#### Returns
[`TransactionIndexType`](#transactionindextype)
#### Throws
***
### toNumber()
> `const` **toNumber**: (`index`) => `number` = `_toNumber`
Defined in: [src/primitives/TransactionIndex/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionIndex/index.ts#L9)
Convert TransactionIndex to number
#### Parameters
##### index
[`TransactionIndexType`](#transactionindextype)
#### Returns
`number`
# primitives/TransactionStatus
Source: https://voltaire.tevm.sh/generated-api/primitives/TransactionStatus
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TransactionStatus
# primitives/TransactionStatus
## Type Aliases
### TransactionStatusType
> **TransactionStatusType** = \{ `type`: `"pending"`; } | \{ `gasUsed`: [`Type`](Uint.mdx#type); `type`: `"success"`; } | \{ `revertReason?`: `string`; `type`: `"failed"`; }
Defined in: [src/primitives/TransactionStatus/TransactionStatusType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/TransactionStatusType.ts#L6)
Transaction status in receipt
## Variables
### failed()
> `const` **failed**: (`revertReason?`) => [`TransactionStatusType`](#transactionstatustype) = `_failed`
Defined in: [src/primitives/TransactionStatus/index.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L12)
Create failed status
#### Parameters
##### revertReason?
`string`
#### Returns
[`TransactionStatusType`](#transactionstatustype)
***
### isFailed()
> `const` **isFailed**: (`status`) => `status is { revertReason?: string; type: "failed" }` = `_isFailed`
Defined in: [src/primitives/TransactionStatus/index.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L15)
Check if status is failed
#### Parameters
##### status
[`TransactionStatusType`](#transactionstatustype)
#### Returns
`status is { revertReason?: string; type: "failed" }`
***
### isPending()
> `const` **isPending**: (`status`) => `boolean` = `_isPending`
Defined in: [src/primitives/TransactionStatus/index.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L13)
Check if status is pending
#### Parameters
##### status
[`TransactionStatusType`](#transactionstatustype)
#### Returns
`boolean`
***
### isSuccess()
> `const` **isSuccess**: (`status`) => `status is { gasUsed: Type; type: "success" }` = `_isSuccess`
Defined in: [src/primitives/TransactionStatus/index.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L14)
Check if status is success
#### Parameters
##### status
[`TransactionStatusType`](#transactionstatustype)
#### Returns
`status is { gasUsed: Type; type: "success" }`
***
### pending()
> `const` **pending**: () => [`TransactionStatusType`](#transactionstatustype) = `_pending`
Defined in: [src/primitives/TransactionStatus/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L10)
Create pending status
#### Returns
[`TransactionStatusType`](#transactionstatustype)
***
### success()
> `const` **success**: (`gasUsed`) => [`TransactionStatusType`](#transactionstatustype) = `_success`
Defined in: [src/primitives/TransactionStatus/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TransactionStatus/index.ts#L11)
Create success status
#### Parameters
##### gasUsed
[`Type`](Uint.mdx#type)
#### Returns
[`TransactionStatusType`](#transactionstatustype)
# primitives/TypedData
Source: https://voltaire.tevm.sh/generated-api/primitives/TypedData
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/TypedData
# primitives/TypedData
## Classes
### InvalidTypedDataError
Defined in: [src/primitives/TypedData/errors.js:4](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/errors.js#L4)
Error thrown when TypedData is invalid
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new InvalidTypedDataError**(`message`, `context?`): [`InvalidTypedDataError`](#invalidtypeddataerror)
Defined in: [src/primitives/TypedData/errors.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/errors.js#L9)
###### Parameters
###### message
`string`
###### context?
`any`
###### Returns
[`InvalidTypedDataError`](#invalidtypeddataerror)
###### Overrides
`Error.constructor`
#### Properties
##### context
> **context**: `any`
Defined in: [src/primitives/TypedData/errors.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/errors.js#L12)
##### name
> **name**: `string`
Defined in: [src/primitives/TypedData/errors.js:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/errors.js#L11)
###### Inherited from
`Error.name`
## Type Aliases
### TypedDataField
> **TypedDataField** = `object`
Defined in: [src/primitives/TypedData/TypedDataType.ts:6](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L6)
EIP-712 Typed Data field definition
#### Properties
##### name
> `readonly` **name**: `string`
Defined in: [src/primitives/TypedData/TypedDataType.ts:7](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L7)
##### type
> `readonly` **type**: `string`
Defined in: [src/primitives/TypedData/TypedDataType.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L8)
***
### TypedDataType
> **TypedDataType**\<`T`> = `object`
Defined in: [src/primitives/TypedData/TypedDataType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L16)
EIP-712 Typed Data structure
Complete structure for EIP-712 typed structured data signing
#### Type Parameters
##### T
`T` = `Record`\<`string`, `unknown`>
#### Properties
##### domain
> `readonly` **domain**: [`DomainType`](Domain.mdx#domaintype)
Defined in: [src/primitives/TypedData/TypedDataType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L22)
##### message
> `readonly` **message**: `T`
Defined in: [src/primitives/TypedData/TypedDataType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L23)
##### primaryType
> `readonly` **primaryType**: `string`
Defined in: [src/primitives/TypedData/TypedDataType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L21)
##### types
> `readonly` **types**: `object`
Defined in: [src/primitives/TypedData/TypedDataType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/TypedDataType.ts#L17)
###### Index Signature
\[`key`: `string`]: readonly [`TypedDataField`](#typeddatafield)\[]
###### EIP712Domain
> `readonly` **EIP712Domain**: readonly [`TypedDataField`](#typeddatafield)\[]
## Functions
### \_encode()
> **\_encode**(`typedData`, `crypto`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/TypedData/encode.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/encode.js#L17)
Encode EIP-712 typed data message
Returns the encoded message data (without domain separator)
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
TypedData
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Encoded message data
#### Example
```javascript theme={null}
const encoded = TypedData.encode(typedData, { keccak256 });
```
***
### \_from()
> **\_from**(`typedData`): [`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
Defined in: [src/primitives/TypedData/from.js:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/from.js#L32)
Create TypedData from object
#### Parameters
##### typedData
TypedData object
###### domain
`object`
Domain separator
###### message
`any`
Message data
###### primaryType
`string`
Primary type name
###### types
`Record`\<`string`, readonly `TypedDataField`\[]>
Type definitions
#### Returns
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
TypedData
#### Throws
If typedData is invalid
#### Example
```javascript theme={null}
import * as TypedData from './primitives/TypedData/index.js';
const typedData = TypedData.from({
types: {
EIP712Domain: [{ name: 'name', type: 'string' }],
Person: [{ name: 'name', type: 'string' }]
},
primaryType: 'Person',
domain: { name: 'MyDApp' },
message: { name: 'Alice' }
});
```
***
### \_hash()
> **\_hash**(`typedData`, `crypto`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/TypedData/hash.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/hash.js#L20)
Compute EIP-712 typed data hash for signing
hash = keccak256("\x19\x01" || domainSeparator || messageHash)
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
TypedData
##### crypto
Crypto dependencies
###### keccak256
(`data`) => `Uint8Array`
Keccak256 hash function
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
Hash for signing
#### Example
```javascript theme={null}
import { keccak256 } from './crypto/Keccak256/index.js';
const hash = TypedData.hash(typedData, { keccak256 });
const signature = await wallet.signMessage(hash);
```
***
### \_validate()
> **\_validate**(`typedData`): `void`
Defined in: [src/primitives/TypedData/validate.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/validate.js#L14)
Validate EIP-712 typed data structure
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
TypedData
#### Returns
`void`
#### Throws
If validation fails
#### Example
```javascript theme={null}
TypedData.validate(typedData); // throws if invalid
```
***
### encode()
> **encode**(`typedData`, `crypto`): `Uint8Array`
Defined in: [src/primitives/TypedData/index.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/index.ts#L45)
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
`Uint8Array`
***
### from()
> **from**\<`T`>(`typedData`): [`TypedDataType`](#typeddatatype)\<`T`>
Defined in: [src/primitives/TypedData/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/index.ts#L16)
#### Type Parameters
##### T
`T` = `Record`\<`string`, `unknown`>
#### Parameters
##### typedData
###### domain
\{ `chainId?`: `number` | [`ChainIdType`](ChainId.mdx#chainidtype); `name?`: `string`; `salt?`: `string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype); `verifyingContract?`: `string` | [`AddressType`](Address.mdx#addresstype); `version?`: `string`; }
###### domain.chainId?
`number` | [`ChainIdType`](ChainId.mdx#chainidtype)
###### domain.name?
`string`
###### domain.salt?
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### domain.verifyingContract?
`string` | [`AddressType`](Address.mdx#addresstype)
###### domain.version?
`string`
###### message
`T`
###### primaryType
`string`
###### types
\{\[`key`: `string`]: readonly [`TypedDataField`](#typeddatafield)\[]; `EIP712Domain`: readonly [`TypedDataField`](#typeddatafield)\[]; }
###### types.EIP712Domain
readonly [`TypedDataField`](#typeddatafield)\[]
#### Returns
[`TypedDataType`](#typeddatatype)\<`T`>
***
### hash()
> **hash**(`typedData`, `crypto`): [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/TypedData/index.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/index.ts#L36)
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
##### crypto
###### keccak256
(`data`) => `Uint8Array`
#### Returns
[`HashType`](../index/namespaces/HashType.mdx#hashtype)
***
### validate()
> **validate**(`typedData`): `void`
Defined in: [src/primitives/TypedData/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/TypedData/index.ts#L54)
#### Parameters
##### typedData
[`TypedDataType`](#typeddatatype)\<`Record`\<`string`, `unknown`>>
#### Returns
`void`
# primitives/Uint
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint
# primitives/Uint
## Interfaces
### UintConstructor()
Defined in: [src/primitives/Uint/UintConstructor.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L69)
> **UintConstructor**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L70)
#### Parameters
##### value
`string` | `number` | `bigint`
#### Returns
[`Type`](#type)
#### Properties
##### bitLength()
> **bitLength**: (`uint`) => `number`
Defined in: [src/primitives/Uint/UintConstructor.ts:112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L112)
Get number of bits required to represent value
###### Parameters
###### uint
[`Type`](#type)
Value to check
###### Returns
`number`
Number of bits (0-256)
###### Example
```typescript theme={null}
const a = Uint(255n);
const bits1 = Uint.bitLength(a); // 8
const bits2 = a.bitLength(); // 8
```
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L97)
Bitwise AND
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
uint & b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseAnd(a, b); // 0x0f
const result2 = a.bitwiseAnd(b); // 0x0f
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L100)
Bitwise NOT
###### Parameters
###### uint
[`Type`](#type)
Operand
###### Returns
[`Type`](#type)
\~uint & MAX
###### Example
```typescript theme={null}
const a = Uint(0n);
const result1 = Uint.bitwiseNot(a); // MAX
const result2 = a.bitwiseNot(); // MAX
```
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:98](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L98)
Bitwise OR
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
uint | b
###### Example
```typescript theme={null}
const a = Uint(0xf0n);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseOr(a, b); // 0xff
const result2 = a.bitwiseOr(b); // 0xff
```
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L99)
Bitwise XOR
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
uint ^ b
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseXor(a, b); // 0xf0
const result2 = a.bitwiseXor(b); // 0xf0
```
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L94)
Divide Uint256 value
###### Parameters
###### uint
[`Type`](#type)
Dividend
###### b
[`Type`](#type)
Divisor
###### Returns
[`Type`](#type)
Quotient (uint / b), floor division
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(10n);
const quotient1 = Uint.dividedBy(a, b); // 10
const quotient2 = a.dividedBy(b); // 10
```
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L103)
Check equality
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint === b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const eq1 = Uint.equals(a, b); // true
const eq2 = a.equals(b); // true
```
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L107)
Check greater than
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint > b
###### Example
```typescript theme={null}
const a = Uint(200n);
const b = Uint(100n);
const isGreater1 = Uint.greaterThan(a, b); // true
const isGreater2 = a.greaterThan(b); // true
```
##### greaterThanOrEqual()
> **greaterThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L108)
Check greater than or equal
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint >= b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isGte1 = Uint.greaterThanOrEqual(a, b); // true
const isGte2 = a.greaterThanOrEqual(b); // true
```
##### isValid()
> **isValid**: (`value`) => `value is Type`
Defined in: [src/primitives/Uint/UintConstructor.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L84)
Check if value is a valid Uint256
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Type`
true if value is valid Uint256
###### Example
```typescript theme={null}
const isValid = Uint.isValid(100n); // true
const isInvalid = Uint.isValid(-1n); // false
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L109)
Check if value is zero
###### Parameters
###### uint
[`Type`](#type)
Value to check
###### Returns
`boolean`
true if uint === 0
###### Example
```typescript theme={null}
const a = Uint(0n);
const isZero1 = Uint.isZero(a); // true
const isZero2 = a.isZero(); // true
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Defined in: [src/primitives/Uint/UintConstructor.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L113)
Get number of leading zero bits
###### Parameters
###### uint
[`Type`](#type)
Value to check
###### Returns
`number`
Number of leading zeros (0-256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const zeros1 = Uint.leadingZeros(a); // 255
const zeros2 = a.leadingZeros(); // 255
```
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L105)
Check less than
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint \< b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isLess1 = Uint.lessThan(a, b); // true
const isLess2 = a.lessThan(b); // true
```
##### lessThanOrEqual()
> **lessThanOrEqual**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:106](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L106)
Check less than or equal
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint is less than or equal to b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isLte1 = Uint.lessThanOrEqual(a, b); // true
const isLte2 = a.lessThanOrEqual(b); // true
```
##### MAX
> **MAX**: [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L72)
##### maximum()
> **maximum**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L111)
Get maximum of two values
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
[`Type`](#type)
max(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const max1 = Uint.maximum(a, b); // 200
const max2 = a.maximum(b); // 200
```
##### MIN
> **MIN**: [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L73)
##### minimum()
> **minimum**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L110)
Get minimum of two values
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
[`Type`](#type)
min(uint, b)
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const min1 = Uint.minimum(a, b); // 100
const min2 = a.minimum(b); // 100
```
##### minus()
> **minus**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L92)
Subtract Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
Difference (uint - b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const diff1 = Uint.minus(a, b); // 50
const diff2 = a.minus(b); // 50
```
##### modulo()
> **modulo**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L95)
Modulo operation
###### Parameters
###### uint
[`Type`](#type)
Dividend
###### b
[`Type`](#type)
Divisor
###### Returns
[`Type`](#type)
Remainder (uint % b)
###### Throws
Error if divisor is zero
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(30n);
const remainder1 = Uint.modulo(a, b); // 10
const remainder2 = a.modulo(b); // 10
```
##### notEquals()
> **notEquals**: (`uint`, `b`) => `boolean`
Defined in: [src/primitives/Uint/UintConstructor.ts:104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L104)
Check inequality
###### Parameters
###### uint
[`Type`](#type)
First value
###### b
[`Type`](#type)
Second value
###### Returns
`boolean`
true if uint !== b
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isNotEq1 = Uint.notEquals(a, b); // true
const isNotEq2 = a.notEquals(b); // true
```
##### ONE
> **ONE**: [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L75)
##### plus()
> **plus**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L91)
Add Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
Sum (uint + b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const sum1 = Uint.plus(a, b); // 150
const sum2 = a.plus(b); // 150
```
##### popCount()
> **popCount**: (`uint`) => `number`
Defined in: [src/primitives/Uint/UintConstructor.ts:114](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L114)
Count number of set bits (population count)
###### Parameters
###### uint
[`Type`](#type)
Value to check
###### Returns
`number`
Number of 1 bits
###### Example
```typescript theme={null}
const a = Uint(0xffn);
const count1 = Uint.popCount(a); // 8
const count2 = a.popCount(); // 8
```
##### prototype
> **prototype**: `UintPrototype`
Defined in: [src/primitives/Uint/UintConstructor.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L71)
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:101](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L101)
Left shift
###### Parameters
###### uint
[`Type`](#type)
Value to shift
###### bits
[`Type`](#type)
Number of bits to shift
###### Returns
[`Type`](#type)
uint shifted left by bits (mod 2^256)
###### Example
```typescript theme={null}
const a = Uint(1n);
const b = Uint(8n);
const result1 = Uint.shiftLeft(a, b); // 256
const result2 = a.shiftLeft(b); // 256
```
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L102)
Right shift
###### Parameters
###### uint
[`Type`](#type)
Value to shift
###### bits
[`Type`](#type)
Number of bits to shift
###### Returns
[`Type`](#type)
uint shifted right by bits
###### Example
```typescript theme={null}
const a = Uint(256n);
const b = Uint(8n);
const result1 = Uint.shiftRight(a, b); // 1
const result2 = a.shiftRight(b); // 1
```
##### SIZE
> **SIZE**: `number`
Defined in: [src/primitives/Uint/UintConstructor.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L76)
##### times()
> **times**: (`uint`, `b`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:93](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L93)
Multiply Uint256 value with wrapping
###### Parameters
###### uint
[`Type`](#type)
First operand
###### b
[`Type`](#type)
Second operand
###### Returns
[`Type`](#type)
Product (uint \* b) mod 2^256
###### Example
```typescript theme={null}
const a = Uint(10n);
const b = Uint(5n);
const product1 = Uint.times(a, b); // 50
const product2 = a.times(b); // 50
```
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/UintConstructor.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L89)
Convert Uint256 to ABI-encoded bytes (32 bytes, big-endian)
This is identical to toBytes() - all Uint256 values in ABI encoding
are represented as 32-byte big-endian values.
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to encode
###### Returns
`Uint8Array`
32-byte ABI-encoded Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const encoded1 = Uint.toAbiEncoded(value);
const encoded2 = value.toAbiEncoded();
```
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
Defined in: [src/primitives/Uint/UintConstructor.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L86)
Convert Uint256 to bigint
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to convert
###### Returns
`bigint`
bigint value
###### Example
```typescript theme={null}
const value = Uint(255n);
const bigint1 = Uint.toBigInt(value);
const bigint2 = value.toBigInt();
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`
Defined in: [src/primitives/Uint/UintConstructor.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L88)
Convert Uint256 to bytes (big-endian, 32 bytes)
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to convert
###### Returns
`Uint8Array`
32-byte Uint8Array
###### Example
```typescript theme={null}
const value = Uint(255n);
const bytes1 = Uint.toBytes(value);
const bytes2 = value.toBytes();
```
##### toHex()
> **toHex**: (`uint`, `padded`) => `string`
Defined in: [src/primitives/Uint/UintConstructor.ts:85](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L85)
Convert Uint256 to hex string
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to convert
###### padded
`boolean` = `true`
Whether to pad to 64 characters (32 bytes)
###### Returns
`string`
Hex string with 0x prefix
###### Example
```typescript theme={null}
const value = Uint(255n);
const hex1 = Uint.toHex(value); // "0x00...ff"
const hex2 = value.toHex(); // "0x00...ff"
const hex3 = value.toHex(false); // "0xff"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Defined in: [src/primitives/Uint/UintConstructor.ts:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L87)
Convert Uint256 to number
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to convert
###### Returns
`number`
number value
###### Throws
Error if value exceeds MAX\_SAFE\_INTEGER
###### Example
```typescript theme={null}
const value = Uint(255n);
const num1 = Uint.toNumber(value);
const num2 = value.toNumber();
```
##### toPower()
> **toPower**: (`uint`, `exponent`) => [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L96)
Exponentiation
###### Parameters
###### uint
[`Type`](#type)
Base value
###### exponent
[`Type`](#type)
Exponent value
###### Returns
[`Type`](#type)
uint^exponent mod 2^256
###### Example
```typescript theme={null}
const base = Uint(2n);
const exp = Uint(8n);
const result1 = Uint.toPower(base, exp); // 256
const result2 = base.toPower(exp); // 256
```
##### toString()
> **toString**: (`uint`, `radix`) => `string`
Defined in: [src/primitives/Uint/UintConstructor.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L90)
Convert Uint256 to string representation
###### Parameters
###### uint
[`Type`](#type)
Uint256 value to convert
###### radix
`number` = `10`
Base for string conversion (2, 10, 16, etc.)
###### Returns
`string`
String representation
###### Example
```typescript theme={null}
const value = Uint(255n);
const dec1 = Uint.toString(value, 10); // "255"
const dec2 = value.toString(10); // "255"
const hex = value.toString(16); // "ff"
```
##### tryFrom()
> **tryFrom**: (`value`) => [`Type`](#type) | `undefined`
Defined in: [src/primitives/Uint/UintConstructor.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L83)
Try to create Uint256, returns undefined if invalid (standard form)
###### Parameters
###### value
bigint, number, or string
`string` | `number` | `bigint`
###### Returns
[`Type`](#type) | `undefined`
Uint256 value or undefined
###### Example
```typescript theme={null}
const a = Uint.tryFrom(100n); // Uint256
const b = Uint.tryFrom(-1n); // undefined
const c = Uint.tryFrom("invalid"); // undefined
```
##### ZERO
> **ZERO**: [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L74)
#### Methods
##### from()
> **from**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L77)
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
[`Type`](#type)
##### fromAbiEncoded()
> **fromAbiEncoded**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L82)
###### Parameters
###### value
`Uint8Array`
###### Returns
[`Type`](#type)
##### fromBigInt()
> **fromBigInt**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L79)
###### Parameters
###### value
`bigint`
###### Returns
[`Type`](#type)
##### fromBytes()
> **fromBytes**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L81)
###### Parameters
###### value
`Uint8Array`
###### Returns
[`Type`](#type)
##### fromHex()
> **fromHex**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L78)
###### Parameters
###### value
`string`
###### Returns
[`Type`](#type)
##### fromNumber()
> **fromNumber**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/UintConstructor.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/UintConstructor.ts#L80)
###### Parameters
###### value
`number` | `bigint`
###### Returns
[`Type`](#type)
## Type Aliases
### ~~BrandedUint~~
> **BrandedUint** = [`Type`](#type)
Defined in: [src/primitives/Uint/Uint256Type.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256Type.ts#L19)
#### Deprecated
Use Uint256Type instead
***
### ~~BrandedUint256~~
> **BrandedUint256** = [`Type`](#type)
Defined in: [src/primitives/Uint/Uint256Type.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256Type.ts#L14)
#### Deprecated
Use Uint256Type instead
***
### Type
> **Type** = `bigint` & `object`
Defined in: [src/primitives/Uint/Uint256Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/Uint256Type.ts#L9)
Uint256 type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Uint256"`
#### See
[https://voltaire.tevm.sh/primitives/uint256](https://voltaire.tevm.sh/primitives/uint256) for Uint256 documentation
#### Since
0.0.0
## Variables
### MAX
> `const` **MAX**: [`Type`](#type)
Defined in: [src/primitives/Uint/constants.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/constants.ts#L17)
Maximum Uint256 value: 2^256 - 1
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
***
### MIN
> `const` **MIN**: [`Type`](#type)
Defined in: [src/primitives/Uint/constants.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/constants.ts#L25)
Minimum Uint256 value: 0
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
***
### ONE
> `const` **ONE**: [`Type`](#type)
Defined in: [src/primitives/Uint/constants.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/constants.ts#L41)
One value
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
***
### SIZE
> `const` **SIZE**: `32` = `32`
Defined in: [src/primitives/Uint/constants.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/constants.ts#L9)
Size in bytes (32 bytes for Uint256)
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
***
### Uint256Type
> `const` **Uint256Type**: `object`
Defined in: [src/primitives/Uint/index.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/index.ts#L105)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`number`
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### Returns
[`Type`](#type)
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### clone()
> **clone**: (`uint`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### Returns
[`Type`](#type)
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Type`](#type)
###### Parameters
###### value
`bigint` | `number` | `string`
###### Returns
[`Type`](#type)
##### fromAbiEncoded()
> **fromAbiEncoded**: (`data`) => [`Type`](#type)
###### Parameters
###### data
`Uint8Array`
###### Returns
[`Type`](#type)
##### fromBigInt()
> **fromBigInt**: (`value`) => [`Type`](#type)
###### Parameters
###### value
`bigint`
###### Returns
[`Type`](#type)
##### fromBytes()
> **fromBytes**: (`bytes`) => [`Type`](#type)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`Type`](#type)
##### fromHex()
> **fromHex**: (`hex`) => [`Type`](#type)
###### Parameters
###### hex
`string`
###### Returns
[`Type`](#type)
##### fromNumber()
> **fromNumber**: (`value`) => [`Type`](#type)
###### Parameters
###### value
`number`
###### Returns
[`Type`](#type)
##### gcd()
> **gcd**: (`a`, `b`) => [`Type`](#type)
###### Parameters
###### a
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### greaterThanOrEqual()
> **greaterThanOrEqual**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### isPowerOf2()
> **isPowerOf2**: (`uint`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`boolean`
##### isValid()
> **isValid**: (`value`) => `value is Type`
###### Parameters
###### value
`unknown`
###### Returns
`value is Type`
##### isZero()
> **isZero**: (`uint`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`boolean`
##### lcm()
> **lcm**: (`a`, `b`) => [`Type`](#type)
###### Parameters
###### a
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`number`
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### lessThanOrEqual()
> **lessThanOrEqual**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### max()
> **max**: (...`values`) => [`Type`](#type)
###### Parameters
###### values
...[`Type`](#type)\[]
###### Returns
[`Type`](#type)
##### MAX
> **MAX**: [`Type`](#type)
##### maximum()
> **maximum**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### min()
> **min**: (...`values`) => [`Type`](#type)
###### Parameters
###### values
...[`Type`](#type)\[]
###### Returns
[`Type`](#type)
##### MIN
> **MIN**: [`Type`](#type)
##### minimum()
> **minimum**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### minus()
> **minus**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### modulo()
> **modulo**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### notEquals()
> **notEquals**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
`boolean`
##### ONE
> **ONE**: [`Type`](#type)
##### plus()
> **plus**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### popCount()
> **popCount**: (`uint`) => `number`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`number`
##### product()
> **product**: (...`values`) => [`Type`](#type)
###### Parameters
###### values
...[`Type`](#type)\[]
###### Returns
[`Type`](#type)
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### bits
[`Type`](#type)
###### Returns
[`Type`](#type)
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### bits
[`Type`](#type)
###### Returns
[`Type`](#type)
##### SIZE
> **SIZE**: `32`
##### sum()
> **sum**: (...`values`) => [`Type`](#type)
###### Parameters
###### values
...[`Type`](#type)\[]
###### Returns
[`Type`](#type)
##### times()
> **times**: (`uint`, `b`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### b
[`Type`](#type)
###### Returns
[`Type`](#type)
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`Uint8Array`
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`bigint`
##### toBytes()
> **toBytes**: (`uint`, `size?`) => `Uint8Array`
###### Parameters
###### uint
[`Type`](#type)
###### size?
`number`
###### Returns
`Uint8Array`
##### toHex()
> **toHex**: (`uint`, `padded?`) => `string`
###### Parameters
###### uint
[`Type`](#type)
###### padded?
`boolean`
###### Returns
`string`
##### toNumber()
> **toNumber**: (`uint`) => `number`
###### Parameters
###### uint
[`Type`](#type)
###### Returns
`number`
##### toPower()
> **toPower**: (`uint`, `exponent`) => [`Type`](#type)
###### Parameters
###### uint
[`Type`](#type)
###### exponent
[`Type`](#type)
###### Returns
[`Type`](#type)
##### toString()
> **toString**: (`uint`, `radix?`) => `string`
###### Parameters
###### uint
[`Type`](#type)
###### radix?
`number`
###### Returns
`string`
##### tryFrom()
> **tryFrom**: (`value`) => [`Type`](#type) | `undefined`
###### Parameters
###### value
`bigint` | `number` | `string`
###### Returns
[`Type`](#type) | `undefined`
##### ZERO
> **ZERO**: [`Type`](#type)
***
### ZERO
> `const` **ZERO**: [`Type`](#type)
Defined in: [src/primitives/Uint/constants.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/constants.ts#L33)
Zero value
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
## Functions
### bitLength()
> **bitLength**(`uint`): `number`
Defined in: [src/primitives/Uint/bitLength.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/bitLength.ts#L16)
Get number of bits required to represent value
#### Parameters
##### uint
[`Type`](#type)
Value to check
#### Returns
`number`
Number of bits (0-256)
#### Example
```typescript theme={null}
const a = Uint(255n);
const bits1 = Uint.bitLength(a); // 8
const bits2 = a.bitLength(); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/bitwiseAnd.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/bitwiseAnd.ts#L18)
Bitwise AND
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
uint & b
#### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseAnd(a, b); // 0x0f
const result2 = a.bitwiseAnd(b); // 0x0f
```
***
### bitwiseNot()
> **bitwiseNot**(`uint`): [`Type`](#type)
Defined in: [src/primitives/Uint/bitwiseNot.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/bitwiseNot.ts#L17)
Bitwise NOT
#### Parameters
##### uint
[`Type`](#type)
Operand
#### Returns
[`Type`](#type)
\~uint & MAX
#### Example
```typescript theme={null}
const a = Uint(0n);
const result1 = Uint.bitwiseNot(a); // MAX
const result2 = a.bitwiseNot(); // MAX
```
***
### bitwiseOr()
> **bitwiseOr**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/bitwiseOr.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/bitwiseOr.ts#L18)
Bitwise OR
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
uint | b
#### Example
```typescript theme={null}
const a = Uint(0xf0n);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseOr(a, b); // 0xff
const result2 = a.bitwiseOr(b); // 0xff
```
***
### bitwiseXor()
> **bitwiseXor**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/bitwiseXor.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/bitwiseXor.ts#L18)
Bitwise XOR
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
uint ^ b
#### Example
```typescript theme={null}
const a = Uint(0xffn);
const b = Uint(0x0fn);
const result1 = Uint.bitwiseXor(a, b); // 0xf0
const result2 = a.bitwiseXor(b); // 0xf0
```
***
### clone()
> **clone**(`uint`): [`Type`](#type)
Defined in: [src/primitives/Uint/clone.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/clone.js#L17)
Create a copy of a Uint256 value
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to clone
#### Returns
[`Type`](#type)
Copy of the value
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const n1 = Uint256.from(100n);
const n2 = Uint256.clone(n1);
console.log(Uint256.equals(n1, n2)); // true
```
***
### dividedBy()
> **dividedBy**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/dividedBy.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/dividedBy.ts#L19)
Divide Uint256 value
#### Parameters
##### uint
[`Type`](#type)
Dividend
##### b
[`Type`](#type)
Divisor
#### Returns
[`Type`](#type)
Quotient (uint / b), floor division
#### Throws
Error if divisor is zero
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(10n);
const quotient1 = Uint.dividedBy(a, b); // 10
const quotient2 = a.dividedBy(b); // 10
```
***
### equals()
> **equals**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/equals.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/equals.ts#L18)
Check equality
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint === b
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const eq1 = Uint.equals(a, b); // true
const eq2 = a.equals(b); // true
```
***
### from()
> **from**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/from.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/from.ts#L18)
Create Uint256 from bigint or string (standard form)
#### Parameters
##### value
bigint or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`Type`](#type)
Uint256 value
#### Throws
Error if value is out of range or invalid
#### Example
```typescript theme={null}
const a = Uint.from(100n);
const b = Uint.from("255");
const c = Uint.from("0xff");
```
***
### fromAbiEncoded()
> **fromAbiEncoded**(`bytes`): [`Type`](#type)
Defined in: [src/primitives/Uint/fromAbiEncoded.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/fromAbiEncoded.ts#L18)
Decode Uint256 from ABI-encoded bytes (32 bytes, big-endian)
#### Parameters
##### bytes
`Uint8Array`
32-byte ABI-encoded data
#### Returns
[`Type`](#type)
Decoded Uint256 value
#### Throws
Error if bytes length is not 32
#### Example
```typescript theme={null}
const encoded = new Uint8Array(32);
encoded[31] = 255;
const value = Uint.fromAbiEncoded(encoded); // 255n
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/fromBigInt.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/fromBigInt.ts#L16)
Create Uint256 from bigint
#### Parameters
##### value
`bigint`
bigint to convert
#### Returns
[`Type`](#type)
Uint256 value
#### Throws
Error if value out of range
#### Example
```typescript theme={null}
const value = Uint.fromBigInt(100n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Type`](#type)
Defined in: [src/primitives/Uint/fromBytes.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/fromBytes.ts#L16)
Create Uint256 from bytes (big-endian)
#### Parameters
##### bytes
`Uint8Array`
bytes to convert
#### Returns
[`Type`](#type)
Uint256 value
#### Throws
Error if bytes length exceeds 32
#### Example
```typescript theme={null}
const bytes = new Uint8Array([0xff, 0x00]);
const value = Uint.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): [`Type`](#type)
Defined in: [src/primitives/Uint/fromHex.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/fromHex.ts#L19)
Create Uint256 from hex string
#### Parameters
##### hex
`string`
Hex string to convert
#### Returns
[`Type`](#type)
Uint256 value
#### Throws
If value is negative
#### Throws
If value exceeds maximum
#### Example
```typescript theme={null}
const value = Uint.fromHex("0xff");
const value2 = Uint.fromHex("ff");
```
***
### fromNumber()
> **fromNumber**(`value`): [`Type`](#type)
Defined in: [src/primitives/Uint/fromNumber.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/fromNumber.ts#L16)
Create Uint256 from number
#### Parameters
##### value
`number`
number to convert
#### Returns
[`Type`](#type)
Uint256 value
#### Throws
Error if value is not an integer or out of range
#### Example
```typescript theme={null}
const value = Uint.fromNumber(255);
```
***
### gcd()
> **gcd**(`a`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/gcd.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/gcd.js#L18)
Calculate greatest common divisor using Euclidean algorithm
#### Parameters
##### a
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
[`Type`](#type)
GCD of a and b
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.gcd(Uint256.from(48n), Uint256.from(18n)); // 6n
```
***
### greaterThan()
> **greaterThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/greaterThan.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/greaterThan.ts#L18)
Check greater than
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint > b
#### Example
```typescript theme={null}
const a = Uint(200n);
const b = Uint(100n);
const isGreater1 = Uint.greaterThan(a, b); // true
const isGreater2 = a.greaterThan(b); // true
```
***
### greaterThanOrEqual()
> **greaterThanOrEqual**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/greaterThanOrEqual.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/greaterThanOrEqual.ts#L18)
Check greater than or equal
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint >= b
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isGte1 = Uint.greaterThanOrEqual(a, b); // true
const isGte2 = a.greaterThanOrEqual(b); // true
```
***
### isPowerOf2()
> **isPowerOf2**(`value`): `boolean`
Defined in: [src/primitives/Uint/isPowerOf2.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/isPowerOf2.js#L18)
Check if value is a power of 2
#### Parameters
##### value
[`Type`](#type)
Value to check
#### Returns
`boolean`
True if value is power of 2
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
Uint256.isPowerOf2(Uint256.from(16n)); // true
Uint256.isPowerOf2(Uint256.from(15n)); // false
```
***
### isValid()
> **isValid**(`value`): `value is Type`
Defined in: [src/primitives/Uint/isValid.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/isValid.ts#L16)
Check if value is a valid Uint256
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is Type`
true if value is valid Uint256
#### Example
```typescript theme={null}
const isValid = Uint.isValid(100n); // true
const isInvalid = Uint.isValid(-1n); // false
```
***
### isZero()
> **isZero**(`uint`): `boolean`
Defined in: [src/primitives/Uint/isZero.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/isZero.ts#L16)
Check if value is zero
#### Parameters
##### uint
[`Type`](#type)
Value to check
#### Returns
`boolean`
true if uint === 0
#### Example
```typescript theme={null}
const a = Uint(0n);
const isZero1 = Uint.isZero(a); // true
const isZero2 = a.isZero(); // true
```
***
### lcm()
> **lcm**(`a`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/lcm.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/lcm.js#L19)
Calculate least common multiple
#### Parameters
##### a
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
[`Type`](#type)
LCM of a and b
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.lcm(Uint256.from(12n), Uint256.from(18n)); // 36n
```
***
### leadingZeros()
> **leadingZeros**(`uint`): `number`
Defined in: [src/primitives/Uint/leadingZeros.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/leadingZeros.ts#L17)
Get number of leading zero bits
#### Parameters
##### uint
[`Type`](#type)
Value to check
#### Returns
`number`
Number of leading zeros (0-256)
#### Example
```typescript theme={null}
const a = Uint(1n);
const zeros1 = Uint.leadingZeros(a); // 255
const zeros2 = a.leadingZeros(); // 255
```
***
### lessThan()
> **lessThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/lessThan.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/lessThan.ts#L18)
Check less than
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint \< b
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isLess1 = Uint.lessThan(a, b); // true
const isLess2 = a.lessThan(b); // true
```
***
### lessThanOrEqual()
> **lessThanOrEqual**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/lessThanOrEqual.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/lessThanOrEqual.ts#L18)
Check less than or equal
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint is less than or equal to b
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(100n);
const isLte1 = Uint.lessThanOrEqual(a, b); // true
const isLte2 = a.lessThanOrEqual(b); // true
```
***
### max()
> **max**(...`values`): [`Type`](#type)
Defined in: [src/primitives/Uint/max.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/max.js#L17)
Find maximum of multiple Uint256 values
#### Parameters
##### values
...[`Type`](#type)\[]
Values to compare
#### Returns
[`Type`](#type)
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
If no values provided
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.max(Uint256.from(100n), Uint256.from(50n), Uint256.from(75n)); // 100n
```
***
### maximum()
> **maximum**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/maximum.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/maximum.ts#L18)
Get maximum of two values
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
[`Type`](#type)
max(uint, b)
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const max1 = Uint.maximum(a, b); // 200
const max2 = a.maximum(b); // 200
```
***
### min()
> **min**(...`values`): [`Type`](#type)
Defined in: [src/primitives/Uint/min.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/min.js#L15)
Find minimum of multiple Uint256 values
#### Parameters
##### values
...[`Type`](#type)\[]
Values to compare
#### Returns
[`Type`](#type)
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
If no values provided
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.min(Uint256.from(100n), Uint256.from(50n), Uint256.from(75n)); // 50n
```
***
### minimum()
> **minimum**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/minimum.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/minimum.ts#L18)
Get minimum of two values
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
[`Type`](#type)
min(uint, b)
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const min1 = Uint.minimum(a, b); // 100
const min2 = a.minimum(b); // 100
```
***
### minus()
> **minus**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/minus.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/minus.ts#L19)
Subtract Uint256 value with wrapping
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
Difference (uint - b) mod 2^256
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const diff1 = Uint.minus(a, b); // 50
const diff2 = a.minus(b); // 50
```
***
### modulo()
> **modulo**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/modulo.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/modulo.ts#L19)
Modulo operation
#### Parameters
##### uint
[`Type`](#type)
Dividend
##### b
[`Type`](#type)
Divisor
#### Returns
[`Type`](#type)
Remainder (uint % b)
#### Throws
Error if divisor is zero
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(30n);
const remainder1 = Uint.modulo(a, b); // 10
const remainder2 = a.modulo(b); // 10
```
***
### notEquals()
> **notEquals**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint/notEquals.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/notEquals.ts#L18)
Check inequality
#### Parameters
##### uint
[`Type`](#type)
First value
##### b
[`Type`](#type)
Second value
#### Returns
`boolean`
true if uint !== b
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(200n);
const isNotEq1 = Uint.notEquals(a, b); // true
const isNotEq2 = a.notEquals(b); // true
```
***
### plus()
> **plus**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/plus.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/plus.ts#L19)
Add Uint256 value with wrapping
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
Sum (uint + b) mod 2^256
#### Example
```typescript theme={null}
const a = Uint(100n);
const b = Uint(50n);
const sum1 = Uint.plus(a, b); // 150
const sum2 = a.plus(b); // 150
```
***
### popCount()
> **popCount**(`uint`): `number`
Defined in: [src/primitives/Uint/popCount.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/popCount.ts#L16)
Count number of set bits (population count)
#### Parameters
##### uint
[`Type`](#type)
Value to check
#### Returns
`number`
Number of 1 bits
#### Example
```typescript theme={null}
const a = Uint(0xffn);
const count1 = Uint.popCount(a); // 8
const count2 = a.popCount(); // 8
```
***
### product()
> **product**(...`values`): [`Type`](#type)
Defined in: [src/primitives/Uint/product.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/product.js#L17)
Multiply multiple Uint256 values with wrapping
#### Parameters
##### values
...[`Type`](#type)\[]
Values to multiply
#### Returns
[`Type`](#type)
Product of all values mod 2^256
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.product(Uint256.from(10n), Uint256.from(5n), Uint256.from(2n)); // 100n
```
***
### shiftLeft()
> **shiftLeft**(`uint`, `bits`): [`Type`](#type)
Defined in: [src/primitives/Uint/shiftLeft.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/shiftLeft.ts#L19)
Left shift
#### Parameters
##### uint
[`Type`](#type)
Value to shift
##### bits
[`Type`](#type)
Number of bits to shift
#### Returns
[`Type`](#type)
uint shifted left by bits (mod 2^256)
#### Example
```typescript theme={null}
const a = Uint(1n);
const b = Uint(8n);
const result1 = Uint.shiftLeft(a, b); // 256
const result2 = a.shiftLeft(b); // 256
```
***
### shiftRight()
> **shiftRight**(`uint`, `bits`): [`Type`](#type)
Defined in: [src/primitives/Uint/shiftRight.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/shiftRight.ts#L18)
Right shift
#### Parameters
##### uint
[`Type`](#type)
Value to shift
##### bits
[`Type`](#type)
Number of bits to shift
#### Returns
[`Type`](#type)
uint shifted right by bits
#### Example
```typescript theme={null}
const a = Uint(256n);
const b = Uint(8n);
const result1 = Uint.shiftRight(a, b); // 1
const result2 = a.shiftRight(b); // 1
```
***
### sum()
> **sum**(...`values`): [`Type`](#type)
Defined in: [src/primitives/Uint/sum.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/sum.js#L17)
Sum multiple Uint256 values with wrapping
#### Parameters
##### values
...[`Type`](#type)\[]
Values to sum
#### Returns
[`Type`](#type)
Sum of all values mod 2^256
#### See
[https://voltaire.tevm.sh/primitives/uint](https://voltaire.tevm.sh/primitives/uint) for Uint documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint256 from './primitives/Uint/index.js';
const result = Uint256.sum(Uint256.from(100n), Uint256.from(50n), Uint256.from(25n)); // 175n
```
***
### times()
> **times**(`uint`, `b`): [`Type`](#type)
Defined in: [src/primitives/Uint/times.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/times.ts#L19)
Multiply Uint256 value with wrapping
#### Parameters
##### uint
[`Type`](#type)
First operand
##### b
[`Type`](#type)
Second operand
#### Returns
[`Type`](#type)
Product (uint \* b) mod 2^256
#### Example
```typescript theme={null}
const a = Uint(10n);
const b = Uint(5n);
const product1 = Uint.times(a, b); // 50
const product2 = a.times(b); // 50
```
***
### toAbiEncoded()
> **toAbiEncoded**(`uint`): `Uint8Array`
Defined in: [src/primitives/Uint/toAbiEncoded.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toAbiEncoded.ts#L20)
Convert Uint256 to ABI-encoded bytes (32 bytes, big-endian)
This is identical to toBytes() - all Uint256 values in ABI encoding
are represented as 32-byte big-endian values.
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to encode
#### Returns
`Uint8Array`
32-byte ABI-encoded Uint8Array
#### Example
```typescript theme={null}
const value = Uint(255n);
const encoded1 = Uint.toAbiEncoded(value);
const encoded2 = value.toAbiEncoded();
```
***
### toBigInt()
> **toBigInt**(`uint`): `bigint`
Defined in: [src/primitives/Uint/toBigInt.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toBigInt.ts#L16)
Convert Uint256 to bigint
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to convert
#### Returns
`bigint`
bigint value
#### Example
```typescript theme={null}
const value = Uint(255n);
const bigint1 = Uint.toBigInt(value);
const bigint2 = value.toBigInt();
```
***
### toBytes()
> **toBytes**(`uint`): `Uint8Array`
Defined in: [src/primitives/Uint/toBytes.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toBytes.ts#L16)
Convert Uint256 to bytes (big-endian, 32 bytes)
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to convert
#### Returns
`Uint8Array`
32-byte Uint8Array
#### Example
```typescript theme={null}
const value = Uint(255n);
const bytes1 = Uint.toBytes(value);
const bytes2 = value.toBytes();
```
***
### toHex()
> **toHex**(`uint`, `padded`): `string`
Defined in: [src/primitives/Uint/toHex.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toHex.ts#L18)
Convert Uint256 to hex string
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to convert
##### padded
`boolean` = `true`
Whether to pad to 64 characters (32 bytes)
#### Returns
`string`
Hex string with 0x prefix
#### Example
```typescript theme={null}
const value = Uint(255n);
const hex1 = Uint.toHex(value); // "0x00...ff"
const hex2 = value.toHex(); // "0x00...ff"
const hex3 = value.toHex(false); // "0xff"
```
***
### toNumber()
> **toNumber**(`uint`): `number`
Defined in: [src/primitives/Uint/toNumber.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toNumber.ts#L17)
Convert Uint256 to number
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to convert
#### Returns
`number`
number value
#### Throws
Error if value exceeds MAX\_SAFE\_INTEGER
#### Example
```typescript theme={null}
const value = Uint(255n);
const num1 = Uint.toNumber(value);
const num2 = value.toNumber();
```
***
### toPower()
> **toPower**(`uint`, `exponent`): [`Type`](#type)
Defined in: [src/primitives/Uint/toPower.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toPower.ts#L19)
Exponentiation
#### Parameters
##### uint
[`Type`](#type)
Base value
##### exponent
[`Type`](#type)
Exponent value
#### Returns
[`Type`](#type)
uint^exponent mod 2^256
#### Example
```typescript theme={null}
const base = Uint(2n);
const exp = Uint(8n);
const result1 = Uint.toPower(base, exp); // 256
const result2 = base.toPower(exp); // 256
```
***
### toString()
> **toString**(`uint`, `radix`): `string`
Defined in: [src/primitives/Uint/toString.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/toString.ts#L19)
Convert Uint256 to string representation
#### Parameters
##### uint
[`Type`](#type)
Uint256 value to convert
##### radix
`number` = `10`
Base for string conversion (2, 10, 16, etc.)
#### Returns
`string`
String representation
#### Example
```typescript theme={null}
const value = Uint(255n);
const dec1 = Uint.toString(value, 10); // "255"
const dec2 = value.toString(10); // "255"
const hex = value.toString(16); // "ff"
```
***
### tryFrom()
> **tryFrom**(`value`): [`Type`](#type) | `undefined`
Defined in: [src/primitives/Uint/tryFrom.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint/tryFrom.ts#L17)
Try to create Uint256, returns undefined if invalid (standard form)
#### Parameters
##### value
bigint, number, or string
`string` | `number` | `bigint`
#### Returns
[`Type`](#type) | `undefined`
Uint256 value or undefined
#### Example
```typescript theme={null}
const a = Uint.tryFrom(100n); // Uint256
const b = Uint.tryFrom(-1n); // undefined
const c = Uint.tryFrom("invalid"); // undefined
```
## References
### Uint256
Renames and re-exports [Uint256Type](#uint256type)
# primitives/Uint128
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint128
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint128
# primitives/Uint128
## Type Aliases
### Uint128Type
> **Uint128Type** = `bigint` & `object`
Defined in: [src/primitives/Uint128/Uint128Type.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/Uint128Type.ts#L9)
Uint128 type
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Uint128"`
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
## Variables
### bitLength()
> `const` **bitLength**: (`uint`) => `number` = `_bitLength`
Defined in: [src/primitives/Uint128/index.ts:120](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L120)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`number`
***
### bitwiseAnd()
> `const` **bitwiseAnd**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_bitwiseAnd`
Defined in: [src/primitives/Uint128/index.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L88)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### bitwiseNot()
> `const` **bitwiseNot**: (`uint`) => [`Uint128Type`](#uint128type) = `_bitwiseNot`
Defined in: [src/primitives/Uint128/index.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L94)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### bitwiseOr()
> `const` **bitwiseOr**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_bitwiseOr`
Defined in: [src/primitives/Uint128/index.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L90)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### bitwiseXor()
> `const` **bitwiseXor**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_bitwiseXor`
Defined in: [src/primitives/Uint128/index.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L92)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### BrandedUint128
> `const` **BrandedUint128**: `object`
Defined in: [src/primitives/Uint128/index.ts:134](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L134)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`number`
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### clone()
> **clone**: (`uint`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### from()
> **from**: (`value`) => [`Uint128Type`](#uint128type)
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
[`Uint128Type`](#uint128type)
##### fromAbiEncoded()
> **fromAbiEncoded**: (`bytes`) => [`Uint128Type`](#uint128type)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`Uint128Type`](#uint128type)
##### fromBigInt()
> **fromBigInt**: (`value`) => [`Uint128Type`](#uint128type)
###### Parameters
###### value
`bigint`
###### Returns
[`Uint128Type`](#uint128type)
##### fromBytes()
> **fromBytes**: (`bytes`) => [`Uint128Type`](#uint128type)
###### Parameters
###### bytes
`Uint8Array`
###### Returns
[`Uint128Type`](#uint128type)
##### fromHex()
> **fromHex**: (`hex`) => [`Uint128Type`](#uint128type)
###### Parameters
###### hex
`string`
###### Returns
[`Uint128Type`](#uint128type)
##### fromNumber()
> **fromNumber**: (`value`) => [`Uint128Type`](#uint128type)
###### Parameters
###### value
`number`
###### Returns
[`Uint128Type`](#uint128type)
##### gcd()
> **gcd**: (`a`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### a
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### greaterThanOrEqual()
> **greaterThanOrEqual**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### isPowerOf2()
> **isPowerOf2**: (`uint`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### isValid()
> **isValid**: (`value`) => `boolean`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
`boolean`
##### isZero()
> **isZero**: (`uint`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### lcm()
> **lcm**: (`a`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### a
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`number`
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### lessThanOrEqual()
> **lessThanOrEqual**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### max()
> **max**: (`values`) => [`Uint128Type`](#uint128type)
###### Parameters
###### values
[`Uint128Type`](#uint128type)\[]
###### Returns
[`Uint128Type`](#uint128type)
##### MAX
> **MAX**: [`Uint128Type`](#uint128type)
Maximum Uint128 value: 2^128 - 1
###### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MAX } from './primitives/Uint128/index.js';
console.log(MAX); // 340282366920938463463374607431768211455n
```
##### maximum()
> **maximum**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### min()
> **min**: (`values`) => [`Uint128Type`](#uint128type)
###### Parameters
###### values
[`Uint128Type`](#uint128type)\[]
###### Returns
[`Uint128Type`](#uint128type)
##### MIN
> **MIN**: [`Uint128Type`](#uint128type)
Minimum Uint128 value: 0
###### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MIN } from './primitives/Uint128/index.js';
console.log(MIN); // 0n
```
##### minimum()
> **minimum**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### minus()
> **minus**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### modulo()
> **modulo**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### notEquals()
> **notEquals**: (`uint`, `b`) => `boolean`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
`boolean`
##### ONE
> **ONE**: [`Uint128Type`](#uint128type)
One value
###### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ONE } from './primitives/Uint128/index.js';
console.log(ONE); // 1n
```
##### plus()
> **plus**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### popCount()
> **popCount**: (`uint`) => `number`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`number`
##### product()
> **product**: (`values`) => [`Uint128Type`](#uint128type)
###### Parameters
###### values
[`Uint128Type`](#uint128type)\[]
###### Returns
[`Uint128Type`](#uint128type)
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### bits
`number`
###### Returns
[`Uint128Type`](#uint128type)
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### bits
`number`
###### Returns
[`Uint128Type`](#uint128type)
##### SIZE
> **SIZE**: `16`
Size in bytes (16 bytes for Uint128)
###### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint128/index.js';
console.log(SIZE); // 16
```
##### sum()
> **sum**: (`values`) => [`Uint128Type`](#uint128type)
###### Parameters
###### values
[`Uint128Type`](#uint128type)\[]
###### Returns
[`Uint128Type`](#uint128type)
##### times()
> **times**: (`uint`, `b`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### b
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`Uint8Array`
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`bigint`
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`Uint8Array`
##### toHex()
> **toHex**: (`uint`) => `string`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`string`
##### toNumber()
> **toNumber**: (`uint`) => `number`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### Returns
`number`
##### toPower()
> **toPower**: (`uint`, `exponent`) => [`Uint128Type`](#uint128type)
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### exponent
[`Uint128Type`](#uint128type)
###### Returns
[`Uint128Type`](#uint128type)
##### toString()
> **toString**: (`uint`, `radix?`) => `string`
###### Parameters
###### uint
[`Uint128Type`](#uint128type)
###### radix?
`number`
###### Returns
`string`
##### tryFrom()
> **tryFrom**: (`value`) => [`Uint128Type`](#uint128type) | `null`
###### Parameters
###### value
`string` | `number` | `bigint`
###### Returns
[`Uint128Type`](#uint128type) | `null`
##### ZERO
> **ZERO**: [`Uint128Type`](#uint128type)
Zero value
###### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint128/index.js';
console.log(ZERO); // 0n
```
***
### clone()
> `const` **clone**: (`uint`) => [`Uint128Type`](#uint128type) = `_clone`
Defined in: [src/primitives/Uint128/index.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L74)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### dividedBy()
> `const` **dividedBy**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_dividedBy`
Defined in: [src/primitives/Uint128/index.ts:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L79)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### equals()
> `const` **equals**: (`uint`, `b`) => `boolean` = `_equals`
Defined in: [src/primitives/Uint128/index.ts:100](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L100)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### from()
> `const` **from**: (`value`) => [`Uint128Type`](#uint128type) = `_from`
Defined in: [src/primitives/Uint128/index.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L54)
#### Parameters
##### value
`bigint` | `number` | `string`
#### Returns
[`Uint128Type`](#uint128type)
***
### fromAbiEncoded()
> `const` **fromAbiEncoded**: (`bytes`) => [`Uint128Type`](#uint128type) = `_fromAbiEncoded`
Defined in: [src/primitives/Uint128/index.ts:59](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L59)
#### Parameters
##### bytes
`Uint8Array`
#### Returns
[`Uint128Type`](#uint128type)
***
### fromBigInt()
> `const` **fromBigInt**: (`value`) => [`Uint128Type`](#uint128type) = `_fromBigInt`
Defined in: [src/primitives/Uint128/index.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L56)
#### Parameters
##### value
`bigint`
#### Returns
[`Uint128Type`](#uint128type)
***
### fromBytes()
> `const` **fromBytes**: (`bytes`) => [`Uint128Type`](#uint128type) = `_fromBytes`
Defined in: [src/primitives/Uint128/index.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L58)
#### Parameters
##### bytes
`Uint8Array`
#### Returns
[`Uint128Type`](#uint128type)
***
### fromHex()
> `const` **fromHex**: (`hex`) => [`Uint128Type`](#uint128type) = `_fromHex`
Defined in: [src/primitives/Uint128/index.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L55)
#### Parameters
##### hex
`string`
#### Returns
[`Uint128Type`](#uint128type)
***
### fromNumber()
> `const` **fromNumber**: (`value`) => [`Uint128Type`](#uint128type) = `_fromNumber`
Defined in: [src/primitives/Uint128/index.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L57)
#### Parameters
##### value
`number`
#### Returns
[`Uint128Type`](#uint128type)
***
### gcd()
> `const` **gcd**: (`a`, `b`) => [`Uint128Type`](#uint128type) = `_gcd`
Defined in: [src/primitives/Uint128/index.ts:129](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L129)
#### Parameters
##### a
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### greaterThan()
> `const` **greaterThan**: (`uint`, `b`) => `boolean` = `_greaterThan`
Defined in: [src/primitives/Uint128/index.ts:107](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L107)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### greaterThanOrEqual()
> `const` **greaterThanOrEqual**: (`uint`, `b`) => `boolean` = `_greaterThanOrEqual`
Defined in: [src/primitives/Uint128/index.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L109)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### isPowerOf2()
> `const` **isPowerOf2**: (`uint`) => `boolean` = `_isPowerOf2`
Defined in: [src/primitives/Uint128/index.ts:131](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L131)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### isValid()
> `const` **isValid**: (`value`) => `boolean` = `_isValid`
Defined in: [src/primitives/Uint128/index.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L63)
#### Parameters
##### value
`bigint` | `number` | `string`
#### Returns
`boolean`
***
### isZero()
> `const` **isZero**: (`uint`) => `boolean` = `_isZero`
Defined in: [src/primitives/Uint128/index.ts:113](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L113)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### lcm()
> `const` **lcm**: (`a`, `b`) => [`Uint128Type`](#uint128type) = `_lcm`
Defined in: [src/primitives/Uint128/index.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L130)
#### Parameters
##### a
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### leadingZeros()
> `const` **leadingZeros**: (`uint`) => `number` = `_leadingZeros`
Defined in: [src/primitives/Uint128/index.ts:121](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L121)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`number`
***
### lessThan()
> `const` **lessThan**: (`uint`, `b`) => `boolean` = `_lessThan`
Defined in: [src/primitives/Uint128/index.ts:103](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L103)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### lessThanOrEqual()
> `const` **lessThanOrEqual**: (`uint`, `b`) => `boolean` = `_lessThanOrEqual`
Defined in: [src/primitives/Uint128/index.ts:105](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L105)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### max()
> `const` **max**: (`values`) => [`Uint128Type`](#uint128type) = `_max`
Defined in: [src/primitives/Uint128/index.ts:127](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L127)
#### Parameters
##### values
[`Uint128Type`](#uint128type)\[]
#### Returns
[`Uint128Type`](#uint128type)
***
### MAX
> `const` **MAX**: [`Uint128Type`](#uint128type)
Defined in: [src/primitives/Uint128/constants.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/constants.js#L34)
Maximum Uint128 value: 2^128 - 1
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MAX } from './primitives/Uint128/index.js';
console.log(MAX); // 340282366920938463463374607431768211455n
```
***
### maximum()
> `const` **maximum**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_maximum`
Defined in: [src/primitives/Uint128/index.ts:117](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L117)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### min()
> `const` **min**: (`values`) => [`Uint128Type`](#uint128type) = `_min`
Defined in: [src/primitives/Uint128/index.ts:126](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L126)
#### Parameters
##### values
[`Uint128Type`](#uint128type)\[]
#### Returns
[`Uint128Type`](#uint128type)
***
### MIN
> `const` **MIN**: [`Uint128Type`](#uint128type)
Defined in: [src/primitives/Uint128/constants.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/constants.js#L50)
Minimum Uint128 value: 0
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MIN } from './primitives/Uint128/index.js';
console.log(MIN); // 0n
```
***
### minimum()
> `const` **minimum**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_minimum`
Defined in: [src/primitives/Uint128/index.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L115)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### minus()
> `const` **minus**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_minus`
Defined in: [src/primitives/Uint128/index.ts:77](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L77)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### modulo()
> `const` **modulo**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_modulo`
Defined in: [src/primitives/Uint128/index.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L81)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### notEquals()
> `const` **notEquals**: (`uint`, `b`) => `boolean` = `_notEquals`
Defined in: [src/primitives/Uint128/index.ts:101](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L101)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
`boolean`
***
### ONE
> `const` **ONE**: [`Uint128Type`](#uint128type)
Defined in: [src/primitives/Uint128/constants.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/constants.js#L78)
One value
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ONE } from './primitives/Uint128/index.js';
console.log(ONE); // 1n
```
***
### plus()
> `const` **plus**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_plus`
Defined in: [src/primitives/Uint128/index.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L76)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### popCount()
> `const` **popCount**: (`uint`) => `number` = `_popCount`
Defined in: [src/primitives/Uint128/index.ts:122](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L122)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`number`
***
### product()
> `const` **product**: (`values`) => [`Uint128Type`](#uint128type) = `_product`
Defined in: [src/primitives/Uint128/index.ts:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L125)
#### Parameters
##### values
[`Uint128Type`](#uint128type)\[]
#### Returns
[`Uint128Type`](#uint128type)
***
### shiftLeft()
> `const` **shiftLeft**: (`uint`, `bits`) => [`Uint128Type`](#uint128type) = `_shiftLeft`
Defined in: [src/primitives/Uint128/index.ts:95](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L95)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### bits
`number`
#### Returns
[`Uint128Type`](#uint128type)
***
### shiftRight()
> `const` **shiftRight**: (`uint`, `bits`) => [`Uint128Type`](#uint128type) = `_shiftRight`
Defined in: [src/primitives/Uint128/index.ts:97](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L97)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### bits
`number`
#### Returns
[`Uint128Type`](#uint128type)
***
### SIZE
> `const` **SIZE**: `16` = `16`
Defined in: [src/primitives/Uint128/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/constants.js#L20)
Size in bytes (16 bytes for Uint128)
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint128/index.js';
console.log(SIZE); // 16
```
***
### sum()
> `const` **sum**: (`values`) => [`Uint128Type`](#uint128type) = `_sum`
Defined in: [src/primitives/Uint128/index.ts:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L124)
#### Parameters
##### values
[`Uint128Type`](#uint128type)\[]
#### Returns
[`Uint128Type`](#uint128type)
***
### times()
> `const` **times**: (`uint`, `b`) => [`Uint128Type`](#uint128type) = `_times`
Defined in: [src/primitives/Uint128/index.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L78)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### b
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### toAbiEncoded()
> `const` **toAbiEncoded**: (`uint`) => `Uint8Array` = `_toAbiEncoded`
Defined in: [src/primitives/Uint128/index.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L69)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`Uint8Array`
***
### toBigInt()
> `const` **toBigInt**: (`uint`) => `bigint` = `_toBigInt`
Defined in: [src/primitives/Uint128/index.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L66)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`bigint`
***
### toBytes()
> `const` **toBytes**: (`uint`) => `Uint8Array` = `_toBytes`
Defined in: [src/primitives/Uint128/index.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L68)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`Uint8Array`
***
### toHex()
> `const` **toHex**: (`uint`) => `string` = `_toHex`
Defined in: [src/primitives/Uint128/index.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L65)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`string`
***
### toNumber()
> `const` **toNumber**: (`uint`) => `number` = `_toNumber`
Defined in: [src/primitives/Uint128/index.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L67)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
#### Returns
`number`
***
### toPower()
> `const` **toPower**: (`uint`, `exponent`) => [`Uint128Type`](#uint128type) = `_toPower`
Defined in: [src/primitives/Uint128/index.ts:83](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L83)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### exponent
[`Uint128Type`](#uint128type)
#### Returns
[`Uint128Type`](#uint128type)
***
### toString()
> `const` **toString**: (`uint`, `radix?`) => `string` = `_toString`
Defined in: [src/primitives/Uint128/index.ts:71](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L71)
#### Parameters
##### uint
[`Uint128Type`](#uint128type)
##### radix?
`number`
#### Returns
`string`
***
### tryFrom()
> `const` **tryFrom**: (`value`) => [`Uint128Type`](#uint128type) | `null` = `_tryFrom`
Defined in: [src/primitives/Uint128/index.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/index.ts#L61)
#### Parameters
##### value
`bigint` | `number` | `string`
#### Returns
[`Uint128Type`](#uint128type) | `null`
***
### ZERO
> `const` **ZERO**: [`Uint128Type`](#uint128type)
Defined in: [src/primitives/Uint128/constants.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint128/constants.js#L64)
Zero value
#### See
[https://voltaire.tevm.sh/primitives/uint128](https://voltaire.tevm.sh/primitives/uint128) for Uint128 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint128/index.js';
console.log(ZERO); // 0n
```
# primitives/Uint16
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint16
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint16
# primitives/Uint16
## Variables
### MAX
> `const` **MAX**: `Uint16Type`
Defined in: [src/primitives/Uint16/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/constants.js#L12)
***
### MIN
> `const` **MIN**: `Uint16Type`
Defined in: [src/primitives/Uint16/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/constants.js#L9)
***
### ONE
> `const` **ONE**: `Uint16Type`
Defined in: [src/primitives/Uint16/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/constants.js#L18)
***
### SIZE
> `const` **SIZE**: `number` = `16`
Defined in: [src/primitives/Uint16/constants.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/constants.js#L21)
***
### Uint16Type
> `const` **Uint16Type**: `object`
Defined in: [src/primitives/Uint16/index.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/index.ts#L72)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
Get bit length of Uint16 value (position of highest set bit)
###### Parameters
###### uint
`Uint16Type`
Input value
###### Returns
`number`
Number of bits needed to represent value (0-16)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.bitLength(Uint16.from(0)); // 0
Uint16.bitLength(Uint16.from(1)); // 1
Uint16.bitLength(Uint16.from(65535)); // 16
Uint16.bitLength(Uint16.from(32768)); // 16
```
##### bitwiseAnd()
> **bitwiseAnd**: (`a`, `b`) => `Uint16Type`
Bitwise AND of two Uint16 values
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Bitwise AND result
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b1111000011110000);
const result = Uint16.bitwiseAnd(a, b); // 0b1111000000000000 = 61440
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => `Uint16Type`
Bitwise NOT of Uint16 value
###### Parameters
###### uint
`Uint16Type`
Input value
###### Returns
`Uint16Type`
Bitwise NOT result
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const result = Uint16.bitwiseNot(a); // 0b0000000011111111 = 255
```
##### bitwiseOr()
> **bitwiseOr**: (`a`, `b`) => `Uint16Type`
Bitwise OR of two Uint16 values
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Bitwise OR result
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b0000000011111111);
const result = Uint16.bitwiseOr(a, b); // 0b1111111111111111 = 65535
```
##### bitwiseXor()
> **bitwiseXor**: (`a`, `b`) => `Uint16Type`
Bitwise XOR of two Uint16 values
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Bitwise XOR result
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b1111000011110000);
const result = Uint16.bitwiseXor(a, b); // 0b0000111111110000 = 4080
```
##### dividedBy()
> **dividedBy**: (`a`, `b`) => `Uint16Type`
Divide two Uint16 values (integer division)
###### Parameters
###### a
`Uint16Type`
Dividend
###### b
`Uint16Type`
Divisor
###### Returns
`Uint16Type`
Quotient (floor(a / b))
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10000);
const b = Uint16.from(100);
const quotient = Uint16.dividedBy(a, b); // 100
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two Uint16 values are equal
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`boolean`
true if a === b
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(30000);
const isEqual = Uint16.equals(a, b); // true
```
##### from()
> **from**: (`value`) => `Uint16Type`
Create Uint16 from number or string
###### Parameters
###### value
number or decimal/hex string
`string` | `number`
###### Returns
`Uint16Type`
Uint16 value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(1000);
const b = Uint16.from("65535");
const c = Uint16.from("0xffff");
```
##### fromBigint()
> **fromBigint**: (`value`) => `Uint16Type`
Create Uint16 from bigint
###### Parameters
###### value
`bigint`
bigint value
###### Returns
`Uint16Type`
Uint16 value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.fromBigint(65535n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => `Uint16Type`
Create Uint16 from Uint8Array (2 bytes, big-endian)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array (must be exactly 2 bytes)
###### Returns
`Uint16Type`
Uint16 value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 2
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const bytes = new Uint8Array([0xff, 0xff]);
const value = Uint16.fromBytes(bytes); // 65535
```
##### fromHex()
> **fromHex**: (`hex`) => `Uint16Type`
Create Uint16 from hex string
###### Parameters
###### hex
`string`
hex string (with or without 0x prefix)
###### Returns
`Uint16Type`
Uint16 value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If hex is invalid or out of range
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.fromHex("0xffff");
const b = Uint16.fromHex("ffff");
```
##### fromNumber()
> **fromNumber**: (`value`) => `Uint16Type`
Create Uint16 from number
###### Parameters
###### value
`number`
number value
###### Returns
`Uint16Type`
Uint16 value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If value is out of range or not an integer
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.fromNumber(65535);
```
##### greaterThan()
> **greaterThan**: (`a`, `b`) => `boolean`
Check if first Uint16 is greater than second
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`boolean`
true if a > b
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const isGreater = Uint16.greaterThan(a, b); // true
```
##### isValid()
> **isValid**: (`value`) => `value is Uint16Type`
Check if value is a valid Uint16
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Uint16Type`
true if valid Uint16
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.isValid(30000); // true
Uint16.isValid(65535); // true
Uint16.isValid(65536); // false
Uint16.isValid(-1); // false
Uint16.isValid(1.5); // false
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Check if Uint16 value is zero
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### Returns
`boolean`
true if uint === 0
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0);
const b = Uint16.from(100);
Uint16.isZero(a); // true
Uint16.isZero(b); // false
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Count leading zero bits in Uint16 value
###### Parameters
###### uint
`Uint16Type`
Input value
###### Returns
`number`
Number of leading zero bits (0-16)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.leadingZeros(Uint16.from(0)); // 16
Uint16.leadingZeros(Uint16.from(1)); // 15
Uint16.leadingZeros(Uint16.from(65535)); // 0
Uint16.leadingZeros(Uint16.from(32768)); // 0
```
##### lessThan()
> **lessThan**: (`a`, `b`) => `boolean`
Check if first Uint16 is less than second
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`boolean`
true if a \< b
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10000);
const b = Uint16.from(30000);
const isLess = Uint16.lessThan(a, b); // true
```
##### MAX
> **MAX**: `Uint16Type`
##### maximum()
> **maximum**: (`a`, `b`) => `Uint16Type`
Return maximum of two Uint16 values
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const max = Uint16.maximum(a, b); // 30000
```
##### MIN
> **MIN**: `Uint16Type`
##### minimum()
> **minimum**: (`a`, `b`) => `Uint16Type`
Return minimum of two Uint16 values
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const min = Uint16.minimum(a, b); // 10000
```
##### minus()
> **minus**: (`a`, `b`) => `Uint16Type`
Subtract two Uint16 values with underflow checking
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Difference (a - b)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If result is negative
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(20000);
const diff = Uint16.minus(a, b); // 10000
```
##### modulo()
> **modulo**: (`a`, `b`) => `Uint16Type`
Compute modulo of two Uint16 values
###### Parameters
###### a
`Uint16Type`
Dividend
###### b
`Uint16Type`
Divisor
###### Returns
`Uint16Type`
Remainder (a % b)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10007);
const b = Uint16.from(1000);
const remainder = Uint16.modulo(a, b); // 7
```
##### ONE
> **ONE**: `Uint16Type`
##### plus()
> **plus**: (`a`, `b`) => `Uint16Type`
Add two Uint16 values with overflow checking
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Sum (a + b)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If result exceeds maximum value
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(20000);
const sum = Uint16.plus(a, b); // 50000
```
##### popCount()
> **popCount**: (`uint`) => `number`
Count number of set bits (population count) in Uint16 value
###### Parameters
###### uint
`Uint16Type`
Input value
###### Returns
`number`
Number of set bits (0-16)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.popCount(Uint16.from(0)); // 0
Uint16.popCount(Uint16.from(65535)); // 16
Uint16.popCount(Uint16.from(0b1010101010101010)); // 8
```
##### shiftLeft()
> **shiftLeft**: (`uint`, `shift`) => `Uint16Type`
Left shift Uint16 value
###### Parameters
###### uint
`Uint16Type`
Value to shift
###### shift
`number`
Number of bits to shift (0-15)
###### Returns
`Uint16Type`
Left-shifted value (masked to 16 bits)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b0000000011111111);
const result = Uint16.shiftLeft(a, 8); // 0b1111111100000000 = 65280
```
##### shiftRight()
> **shiftRight**: (`uint`, `shift`) => `Uint16Type`
Right shift Uint16 value (logical shift)
###### Parameters
###### uint
`Uint16Type`
Value to shift
###### shift
`number`
Number of bits to shift (0-15)
###### Returns
`Uint16Type`
Right-shifted value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const result = Uint16.shiftRight(a, 8); // 0b0000000011111111 = 255
```
##### SIZE
> **SIZE**: `number`
##### times()
> **times**: (`a`, `b`) => `Uint16Type`
Multiply two Uint16 values with overflow checking
###### Parameters
###### a
`Uint16Type`
First operand
###### b
`Uint16Type`
Second operand
###### Returns
`Uint16Type`
Product (a \* b)
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
If result exceeds maximum value
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(100);
const b = Uint16.from(500);
const product = Uint16.times(a, b); // 50000
```
##### toBigint()
> **toBigint**: (`uint`) => `bigint`
Convert Uint16 to bigint
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### Returns
`bigint`
bigint value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const bigintValue = Uint16.toBigint(value); // 65535n
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint16 to Uint8Array (2 bytes, big-endian)
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array of length 2
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const bytes = Uint16.toBytes(value); // Uint8Array([255, 255])
```
##### toHex()
> **toHex**: (`uint`, `padded?`) => `string`
Convert Uint16 to hex string
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### padded?
`boolean` = `true`
Whether to pad to 4 characters (2 bytes)
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const hex1 = Uint16.toHex(value); // "0xffff"
const hex2 = Uint16.toHex(value, false); // "0xffff"
const value2 = Uint16.from(15);
const hex3 = Uint16.toHex(value2); // "0x000f"
const hex4 = Uint16.toHex(value2, false); // "0xf"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Convert Uint16 to number
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### Returns
`number`
number value
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const num = Uint16.toNumber(value); // 65535
```
##### toString()
> **toString**: (`uint`) => `string`
Convert Uint16 to decimal string
###### Parameters
###### uint
`Uint16Type`
Uint16 value
###### Returns
`string`
Decimal string representation
###### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const str = Uint16.toString(value); // "65535"
```
##### ZERO
> **ZERO**: `Uint16Type`
***
### ZERO
> `const` **ZERO**: `Uint16Type`
Defined in: [src/primitives/Uint16/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/constants.js#L15)
## Functions
### bitLength()
> **bitLength**(`uint`): `number`
Defined in: [src/primitives/Uint16/bitLength.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/bitLength.js#L18)
Get bit length of Uint16 value (position of highest set bit)
#### Parameters
##### uint
`Uint16Type`
Input value
#### Returns
`number`
Number of bits needed to represent value (0-16)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.bitLength(Uint16.from(0)); // 0
Uint16.bitLength(Uint16.from(1)); // 1
Uint16.bitLength(Uint16.from(65535)); // 16
Uint16.bitLength(Uint16.from(32768)); // 16
```
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/bitwiseAnd.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/bitwiseAnd.js#L18)
Bitwise AND of two Uint16 values
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Bitwise AND result
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b1111000011110000);
const result = Uint16.bitwiseAnd(a, b); // 0b1111000000000000 = 61440
```
***
### bitwiseNot()
> **bitwiseNot**(`uint`): `Uint16Type`
Defined in: [src/primitives/Uint16/bitwiseNot.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/bitwiseNot.js#L18)
Bitwise NOT of Uint16 value
#### Parameters
##### uint
`Uint16Type`
Input value
#### Returns
`Uint16Type`
Bitwise NOT result
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const result = Uint16.bitwiseNot(a); // 0b0000000011111111 = 255
```
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/bitwiseOr.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/bitwiseOr.js#L18)
Bitwise OR of two Uint16 values
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Bitwise OR result
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b0000000011111111);
const result = Uint16.bitwiseOr(a, b); // 0b1111111111111111 = 65535
```
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/bitwiseXor.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/bitwiseXor.js#L18)
Bitwise XOR of two Uint16 values
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Bitwise XOR result
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const b = Uint16.from(0b1111000011110000);
const result = Uint16.bitwiseXor(a, b); // 0b0000111111110000 = 4080
```
***
### dividedBy()
> **dividedBy**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/dividedBy.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/dividedBy.js#L18)
Divide two Uint16 values (integer division)
#### Parameters
##### a
`Uint16Type`
Dividend
##### b
`Uint16Type`
Divisor
#### Returns
`Uint16Type`
Quotient (floor(a / b))
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10000);
const b = Uint16.from(100);
const quotient = Uint16.dividedBy(a, b); // 100
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint16/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/equals.js#L18)
Check if two Uint16 values are equal
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`boolean`
true if a === b
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(30000);
const isEqual = Uint16.equals(a, b); // true
```
***
### from()
> **from**(`value`): `Uint16Type`
Defined in: [src/primitives/Uint16/from.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/from.js#L19)
Create Uint16 from number or string
#### Parameters
##### value
number or decimal/hex string
`string` | `number`
#### Returns
`Uint16Type`
Uint16 value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(1000);
const b = Uint16.from("65535");
const c = Uint16.from("0xffff");
```
***
### fromBigint()
> **fromBigint**(`value`): `Uint16Type`
Defined in: [src/primitives/Uint16/fromBigint.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/fromBigint.js#L17)
Create Uint16 from bigint
#### Parameters
##### value
`bigint`
bigint value
#### Returns
`Uint16Type`
Uint16 value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.fromBigint(65535n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): `Uint16Type`
Defined in: [src/primitives/Uint16/fromBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/fromBytes.js#L16)
Create Uint16 from Uint8Array (2 bytes, big-endian)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array (must be exactly 2 bytes)
#### Returns
`Uint16Type`
Uint16 value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 2
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const bytes = new Uint8Array([0xff, 0xff]);
const value = Uint16.fromBytes(bytes); // 65535
```
***
### fromHex()
> **fromHex**(`hex`): `Uint16Type`
Defined in: [src/primitives/Uint16/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/fromHex.js#L18)
Create Uint16 from hex string
#### Parameters
##### hex
`string`
hex string (with or without 0x prefix)
#### Returns
`Uint16Type`
Uint16 value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If hex is invalid or out of range
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.fromHex("0xffff");
const b = Uint16.fromHex("ffff");
```
***
### fromNumber()
> **fromNumber**(`value`): `Uint16Type`
Defined in: [src/primitives/Uint16/fromNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/fromNumber.js#L17)
Create Uint16 from number
#### Parameters
##### value
`number`
number value
#### Returns
`Uint16Type`
Uint16 value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If value is out of range or not an integer
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.fromNumber(65535);
```
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint16/greaterThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/greaterThan.js#L18)
Check if first Uint16 is greater than second
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`boolean`
true if a > b
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const isGreater = Uint16.greaterThan(a, b); // true
```
***
### isValid()
> **isValid**(`value`): `value is Uint16Type`
Defined in: [src/primitives/Uint16/isValid.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/isValid.js#L21)
Check if value is a valid Uint16
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is Uint16Type`
true if valid Uint16
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.isValid(30000); // true
Uint16.isValid(65535); // true
Uint16.isValid(65536); // false
Uint16.isValid(-1); // false
Uint16.isValid(1.5); // false
```
***
### isZero()
> **isZero**(`uint`): `boolean`
Defined in: [src/primitives/Uint16/isZero.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/isZero.js#L18)
Check if Uint16 value is zero
#### Parameters
##### uint
`Uint16Type`
Uint16 value
#### Returns
`boolean`
true if uint === 0
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0);
const b = Uint16.from(100);
Uint16.isZero(a); // true
Uint16.isZero(b); // false
```
***
### leadingZeros()
> **leadingZeros**(`uint`): `number`
Defined in: [src/primitives/Uint16/leadingZeros.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/leadingZeros.js#L18)
Count leading zero bits in Uint16 value
#### Parameters
##### uint
`Uint16Type`
Input value
#### Returns
`number`
Number of leading zero bits (0-16)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.leadingZeros(Uint16.from(0)); // 16
Uint16.leadingZeros(Uint16.from(1)); // 15
Uint16.leadingZeros(Uint16.from(65535)); // 0
Uint16.leadingZeros(Uint16.from(32768)); // 0
```
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint16/lessThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/lessThan.js#L18)
Check if first Uint16 is less than second
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`boolean`
true if a \< b
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10000);
const b = Uint16.from(30000);
const isLess = Uint16.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/maximum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/maximum.js#L18)
Return maximum of two Uint16 values
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const max = Uint16.maximum(a, b); // 30000
```
***
### minimum()
> **minimum**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/minimum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/minimum.js#L18)
Return minimum of two Uint16 values
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(10000);
const min = Uint16.minimum(a, b); // 10000
```
***
### minus()
> **minus**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/minus.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/minus.js#L18)
Subtract two Uint16 values with underflow checking
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Difference (a - b)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If result is negative
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(20000);
const diff = Uint16.minus(a, b); // 10000
```
***
### modulo()
> **modulo**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/modulo.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/modulo.js#L18)
Compute modulo of two Uint16 values
#### Parameters
##### a
`Uint16Type`
Dividend
##### b
`Uint16Type`
Divisor
#### Returns
`Uint16Type`
Remainder (a % b)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(10007);
const b = Uint16.from(1000);
const remainder = Uint16.modulo(a, b); // 7
```
***
### plus()
> **plus**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/plus.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/plus.js#L20)
Add two Uint16 values with overflow checking
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Sum (a + b)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If result exceeds maximum value
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(30000);
const b = Uint16.from(20000);
const sum = Uint16.plus(a, b); // 50000
```
***
### popCount()
> **popCount**(`uint`): `number`
Defined in: [src/primitives/Uint16/popCount.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/popCount.js#L17)
Count number of set bits (population count) in Uint16 value
#### Parameters
##### uint
`Uint16Type`
Input value
#### Returns
`number`
Number of set bits (0-16)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
Uint16.popCount(Uint16.from(0)); // 0
Uint16.popCount(Uint16.from(65535)); // 16
Uint16.popCount(Uint16.from(0b1010101010101010)); // 8
```
***
### shiftLeft()
> **shiftLeft**(`uint`, `shift`): `Uint16Type`
Defined in: [src/primitives/Uint16/shiftLeft.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/shiftLeft.js#L19)
Left shift Uint16 value
#### Parameters
##### uint
`Uint16Type`
Value to shift
##### shift
`number`
Number of bits to shift (0-15)
#### Returns
`Uint16Type`
Left-shifted value (masked to 16 bits)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b0000000011111111);
const result = Uint16.shiftLeft(a, 8); // 0b1111111100000000 = 65280
```
***
### shiftRight()
> **shiftRight**(`uint`, `shift`): `Uint16Type`
Defined in: [src/primitives/Uint16/shiftRight.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/shiftRight.js#L17)
Right shift Uint16 value (logical shift)
#### Parameters
##### uint
`Uint16Type`
Value to shift
##### shift
`number`
Number of bits to shift (0-15)
#### Returns
`Uint16Type`
Right-shifted value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(0b1111111100000000);
const result = Uint16.shiftRight(a, 8); // 0b0000000011111111 = 255
```
***
### times()
> **times**(`a`, `b`): `Uint16Type`
Defined in: [src/primitives/Uint16/times.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/times.js#L20)
Multiply two Uint16 values with overflow checking
#### Parameters
##### a
`Uint16Type`
First operand
##### b
`Uint16Type`
Second operand
#### Returns
`Uint16Type`
Product (a \* b)
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
If result exceeds maximum value
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const a = Uint16.from(100);
const b = Uint16.from(500);
const product = Uint16.times(a, b); // 50000
```
***
### toBigint()
> **toBigint**(`uint`): `bigint`
Defined in: [src/primitives/Uint16/toBigint.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/toBigint.js#L16)
Convert Uint16 to bigint
#### Parameters
##### uint
`Uint16Type`
Uint16 value
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const bigintValue = Uint16.toBigint(value); // 65535n
```
***
### toBytes()
> **toBytes**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint16/toBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/toBytes.js#L16)
Convert Uint16 to Uint8Array (2 bytes, big-endian)
#### Parameters
##### uint
`Uint16Type`
Uint16 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array of length 2
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const bytes = Uint16.toBytes(value); // Uint8Array([255, 255])
```
***
### toHex()
> **toHex**(`uint`, `padded?`): `string`
Defined in: [src/primitives/Uint16/toHex.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/toHex.js#L21)
Convert Uint16 to hex string
#### Parameters
##### uint
`Uint16Type`
Uint16 value
##### padded?
`boolean` = `true`
Whether to pad to 4 characters (2 bytes)
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const hex1 = Uint16.toHex(value); // "0xffff"
const hex2 = Uint16.toHex(value, false); // "0xffff"
const value2 = Uint16.from(15);
const hex3 = Uint16.toHex(value2); // "0x000f"
const hex4 = Uint16.toHex(value2, false); // "0xf"
```
***
### toNumber()
> **toNumber**(`uint`): `number`
Defined in: [src/primitives/Uint16/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/toNumber.js#L16)
Convert Uint16 to number
#### Parameters
##### uint
`Uint16Type`
Uint16 value
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const num = Uint16.toNumber(value); // 65535
```
***
### toString()
> **toString**(`uint`): `string`
Defined in: [src/primitives/Uint16/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint16/toString.js#L17)
Convert Uint16 to decimal string
#### Parameters
##### uint
`Uint16Type`
Uint16 value
#### Returns
`string`
Decimal string representation
#### See
[https://voltaire.tevm.sh/primitives/uint16](https://voltaire.tevm.sh/primitives/uint16) for Uint16 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint16 from './primitives/Uint16/index.js';
const value = Uint16.from(65535);
const str = Uint16.toString(value); // "65535"
```
# primitives/Uint32
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint32
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint32
# primitives/Uint32
## Type Aliases
### Uint32Type
> **Uint32Type** = `number` & `object`
Defined in: [src/primitives/Uint32/Uint32Type.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/Uint32Type.ts#L12)
Uint32 type
32-bit unsigned integer (0 to 4294967295).
Used for block numbers, gas limits, timestamps (until year 2106).
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Uint32"`
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
## Variables
### MAX
> `const` **MAX**: [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/constants.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/constants.js#L34)
Maximum Uint32 value: 2^32 - 1 = 4294967295
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MAX } from './primitives/Uint32/index.js';
console.log(MAX); // 4294967295
```
***
### MIN
> `const` **MIN**: [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/constants.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/constants.js#L50)
Minimum Uint32 value: 0
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MIN } from './primitives/Uint32/index.js';
console.log(MIN); // 0
```
***
### ONE
> `const` **ONE**: [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/constants.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/constants.js#L78)
One value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ONE } from './primitives/Uint32/index.js';
console.log(ONE); // 1
```
***
### SIZE
> `const` **SIZE**: `4` = `4`
Defined in: [src/primitives/Uint32/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/constants.js#L20)
Size in bytes (4 bytes for Uint32)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint32/index.js';
console.log(SIZE); // 4
```
***
### Uint32
> `const` **Uint32**: `object`
Defined in: [src/primitives/Uint32/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/index.ts#L82)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
Calculate bit length of Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value
###### Returns
`number`
Number of bits needed to represent value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(255);
const result = Uint32.bitLength(a); // 8
```
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Bitwise AND Uint32 values
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Result (uint & b)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseAnd(a, b); // 0b1000 = 8
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Uint32Type`](#uint32type)
Bitwise NOT Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Operand
###### Returns
[`Uint32Type`](#uint32type)
Result (\~uint)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0);
const result = Uint32.bitwiseNot(a); // 4294967295 (all bits set)
```
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Bitwise OR Uint32 values
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Result (uint | b)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseOr(a, b); // 0b1110 = 14
```
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Bitwise XOR Uint32 values
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Result (uint ^ b)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseXor(a, b); // 0b0110 = 6
```
##### clone()
> **clone**: (`uint`) => [`Uint32Type`](#uint32type)
Clone Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value to clone
###### Returns
[`Uint32Type`](#uint32type)
Cloned value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.clone(a);
```
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Divide Uint32 value (integer division)
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Dividend
###### b
[`Uint32Type`](#uint32type)
Divisor
###### Returns
[`Uint32Type`](#uint32type)
Quotient (uint / b) truncated
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(3);
const quotient = Uint32.dividedBy(a, b); // 33
```
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
Check if Uint32 values are equal
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First value
###### b
[`Uint32Type`](#uint32type)
Second value
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(100);
const result = Uint32.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`Uint32Type`](#uint32type)
Create Uint32 from number, bigint, or string
###### Parameters
###### value
number, bigint, or decimal/hex string
`string` | `number` | `bigint`
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from("255");
const c = Uint32.from("0xff");
const d = Uint32.from(42n);
```
##### fromAbiEncoded()
> **fromAbiEncoded**: (`bytes`) => [`Uint32Type`](#uint32type)
Create Uint32 from ABI-encoded bytes (32 bytes, big-endian, left-padded)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
ABI-encoded byte array (32 bytes)
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 32
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const abiBytes = new Uint8Array(32);
abiBytes[31] = 255;
const value = Uint32.fromAbiEncoded(abiBytes); // 255
```
##### fromBigInt()
> **fromBigInt**: (`value`) => [`Uint32Type`](#uint32type)
Create Uint32 from bigint
###### Parameters
###### value
`bigint`
bigint value
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.fromBigInt(100n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`Uint32Type`](#uint32type)
Create Uint32 from bytes (big-endian, 4 bytes)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
byte array (must be exactly 4 bytes)
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 4
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const bytes = new Uint8Array([0, 0, 0, 255]);
const value = Uint32.fromBytes(bytes); // 255
```
##### fromHex()
> **fromHex**: (`hex`) => [`Uint32Type`](#uint32type)
Create Uint32 from hex string
###### Parameters
###### hex
`string`
hex string (with or without 0x prefix)
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid hex
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.fromHex("0xff");
const b = Uint32.fromHex("ff");
```
##### fromNumber()
> **fromNumber**: (`value`) => [`Uint32Type`](#uint32type)
Create Uint32 from number
###### Parameters
###### value
`number`
number value
###### Returns
[`Uint32Type`](#uint32type)
Uint32 value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.fromNumber(42);
```
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
Check if Uint32 value is greater than another
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First value
###### b
[`Uint32Type`](#uint32type)
Second value
###### Returns
`boolean`
true if uint > b
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(200);
const b = Uint32.from(100);
const result = Uint32.greaterThan(a, b); // true
```
##### isValid()
> **isValid**: (`value`) => `value is Uint32Type`
Check if value is a valid Uint32
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Uint32Type`
true if valid Uint32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const result1 = Uint32.isValid(100); // true
const result2 = Uint32.isValid(-1); // false
const result3 = Uint32.isValid(5000000000); // false (exceeds max)
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Check if Uint32 value is zero
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value to check
###### Returns
`boolean`
true if zero
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0);
const result = Uint32.isZero(a); // true
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Count leading zeros in Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value
###### Returns
`number`
Number of leading zero bits
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(255);
const result = Uint32.leadingZeros(a); // 24
```
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
Check if Uint32 value is less than another
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First value
###### b
[`Uint32Type`](#uint32type)
Second value
###### Returns
`boolean`
true if uint \< b
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.lessThan(a, b); // true
```
##### MAX
> **MAX**: [`Uint32Type`](#uint32type)
Maximum Uint32 value: 2^32 - 1 = 4294967295
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MAX } from './primitives/Uint32/index.js';
console.log(MAX); // 4294967295
```
##### maximum()
> **maximum**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Return maximum of two Uint32 values
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First value
###### b
[`Uint32Type`](#uint32type)
Second value
###### Returns
[`Uint32Type`](#uint32type)
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.maximum(a, b); // 200
```
##### MIN
> **MIN**: [`Uint32Type`](#uint32type)
Minimum Uint32 value: 0
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MIN } from './primitives/Uint32/index.js';
console.log(MIN); // 0
```
##### minimum()
> **minimum**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Return minimum of two Uint32 values
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First value
###### b
[`Uint32Type`](#uint32type)
Second value
###### Returns
[`Uint32Type`](#uint32type)
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.minimum(a, b); // 100
```
##### minus()
> **minus**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Subtract Uint32 value with wrapping
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Difference (uint - b) mod 2^32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const diff = Uint32.minus(a, b); // 50
```
##### modulo()
> **modulo**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Modulo Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Dividend
###### b
[`Uint32Type`](#uint32type)
Divisor
###### Returns
[`Uint32Type`](#uint32type)
Remainder (uint % b)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(3);
const remainder = Uint32.modulo(a, b); // 1
```
##### ONE
> **ONE**: [`Uint32Type`](#uint32type)
One value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ONE } from './primitives/Uint32/index.js';
console.log(ONE); // 1
```
##### plus()
> **plus**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Add Uint32 value with wrapping
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Sum (uint + b) mod 2^32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const sum = Uint32.plus(a, b); // 150
```
##### popCount()
> **popCount**: (`uint`) => `number`
Count set bits (population count) in Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value
###### Returns
`number`
Number of set bits
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1111);
const result = Uint32.popCount(a); // 4
```
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Uint32Type`](#uint32type)
Left shift Uint32 value
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value to shift
###### bits
`number`
Number of bits to shift (0-31)
###### Returns
[`Uint32Type`](#uint32type)
Result (uint shifted left by bits) mod 2^32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(1);
const result = Uint32.shiftLeft(a, 8); // 256
```
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Uint32Type`](#uint32type)
Right shift Uint32 value (logical shift, zero-fill)
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Value to shift
###### bits
`number`
Number of bits to shift (0-31)
###### Returns
[`Uint32Type`](#uint32type)
Result (uint shifted right by bits)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(256);
const result = Uint32.shiftRight(a, 8); // 1
```
##### SIZE
> **SIZE**: `4`
Size in bytes (4 bytes for Uint32)
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint32/index.js';
console.log(SIZE); // 4
```
##### times()
> **times**: (`uint`, `b`) => [`Uint32Type`](#uint32type)
Multiply Uint32 value with wrapping
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
First operand
###### b
[`Uint32Type`](#uint32type)
Second operand
###### Returns
[`Uint32Type`](#uint32type)
Product (uint \* b) mod 2^32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const product = Uint32.times(a, b); // 5000
```
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint32 to ABI-encoded bytes (32 bytes, big-endian, left-padded with zeros)
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const abiBytes = Uint32.toAbiEncoded(value); // 32 bytes with last byte = 255
```
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
Convert Uint32 to bigint
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`bigint`
bigint value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const bigintValue = Uint32.toBigInt(value); // 255n
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint32 to bytes (big-endian, 4 bytes)
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte Uint8Array
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const bytes = Uint32.toBytes(value); // Uint8Array([0, 0, 0, 255])
```
##### toHex()
> **toHex**: (`uint`) => `string`
Convert Uint32 to hex string (with 0x prefix)
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`string`
hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const hex = Uint32.toHex(value); // "0xff"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Convert Uint32 to number
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`number`
number value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const num = Uint32.toNumber(value); // 255
```
##### toPower()
> **toPower**: (`uint`, `exp`) => [`Uint32Type`](#uint32type)
Raise Uint32 to power with wrapping
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Base
###### exp
[`Uint32Type`](#uint32type)
Exponent
###### Returns
[`Uint32Type`](#uint32type)
Result (uint ^ exp) mod 2^32
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const base = Uint32.from(2);
const exp = Uint32.from(10);
const result = Uint32.toPower(base, exp); // 1024
```
##### toString()
> **toString**: (`uint`) => `string`
Convert Uint32 to string
###### Parameters
###### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
###### Returns
`string`
decimal string representation
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const str = Uint32.toString(value); // "255"
```
##### tryFrom()
> **tryFrom**: (`value`) => [`Uint32Type`](#uint32type) | `null`
Try to create Uint32 from value, return null if invalid
###### Parameters
###### value
`unknown`
Value to convert
###### Returns
[`Uint32Type`](#uint32type) | `null`
Uint32 value or null
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.tryFrom(100); // 100
const b = Uint32.tryFrom(-1); // null
const c = Uint32.tryFrom(5000000000); // null
```
##### ZERO
> **ZERO**: [`Uint32Type`](#uint32type)
Zero value
###### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint32/index.js';
console.log(ZERO); // 0
```
***
### ZERO
> `const` **ZERO**: [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/constants.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/constants.js#L64)
Zero value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint32/index.js';
console.log(ZERO); // 0
```
## Functions
### bitLength()
> **bitLength**(`uint`): `number`
Defined in: [src/primitives/Uint32/bitLength.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/bitLength.js#L16)
Calculate bit length of Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value
#### Returns
`number`
Number of bits needed to represent value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(255);
const result = Uint32.bitLength(a); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/bitwiseAnd.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/bitwiseAnd.js#L18)
Bitwise AND Uint32 values
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Result (uint & b)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseAnd(a, b); // 0b1000 = 8
```
***
### bitwiseNot()
> **bitwiseNot**(`uint`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/bitwiseNot.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/bitwiseNot.js#L16)
Bitwise NOT Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Operand
#### Returns
[`Uint32Type`](#uint32type)
Result (\~uint)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0);
const result = Uint32.bitwiseNot(a); // 4294967295 (all bits set)
```
***
### bitwiseOr()
> **bitwiseOr**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/bitwiseOr.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/bitwiseOr.js#L18)
Bitwise OR Uint32 values
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Result (uint | b)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseOr(a, b); // 0b1110 = 14
```
***
### bitwiseXor()
> **bitwiseXor**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/bitwiseXor.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/bitwiseXor.js#L18)
Bitwise XOR Uint32 values
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Result (uint ^ b)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1100);
const b = Uint32.from(0b1010);
const result = Uint32.bitwiseXor(a, b); // 0b0110 = 6
```
***
### clone()
> **clone**(`uint`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/clone.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/clone.js#L16)
Clone Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value to clone
#### Returns
[`Uint32Type`](#uint32type)
Cloned value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.clone(a);
```
***
### dividedBy()
> **dividedBy**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/dividedBy.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/dividedBy.js#L18)
Divide Uint32 value (integer division)
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Dividend
##### b
[`Uint32Type`](#uint32type)
Divisor
#### Returns
[`Uint32Type`](#uint32type)
Quotient (uint / b) truncated
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(3);
const quotient = Uint32.dividedBy(a, b); // 33
```
***
### equals()
> **equals**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint32/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/equals.js#L18)
Check if Uint32 values are equal
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First value
##### b
[`Uint32Type`](#uint32type)
Second value
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(100);
const result = Uint32.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/from.js#L20)
Create Uint32 from number, bigint, or string
#### Parameters
##### value
number, bigint, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from("255");
const c = Uint32.from("0xff");
const d = Uint32.from(42n);
```
***
### fromAbiEncoded()
> **fromAbiEncoded**(`bytes`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/fromAbiEncoded.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/fromAbiEncoded.js#L17)
Create Uint32 from ABI-encoded bytes (32 bytes, big-endian, left-padded)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
ABI-encoded byte array (32 bytes)
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 32
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const abiBytes = new Uint8Array(32);
abiBytes[31] = 255;
const value = Uint32.fromAbiEncoded(abiBytes); // 255
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/fromBigInt.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/fromBigInt.js#L17)
Create Uint32 from bigint
#### Parameters
##### value
`bigint`
bigint value
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.fromBigInt(100n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/fromBytes.js#L18)
Create Uint32 from bytes (big-endian, 4 bytes)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
byte array (must be exactly 4 bytes)
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 4
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const bytes = new Uint8Array([0, 0, 0, 255]);
const value = Uint32.fromBytes(bytes); // 255
```
***
### fromHex()
> **fromHex**(`hex`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/fromHex.js#L18)
Create Uint32 from hex string
#### Parameters
##### hex
`string`
hex string (with or without 0x prefix)
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid hex
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.fromHex("0xff");
const b = Uint32.fromHex("ff");
```
***
### fromNumber()
> **fromNumber**(`value`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/fromNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/fromNumber.js#L17)
Create Uint32 from number
#### Parameters
##### value
`number`
number value
#### Returns
[`Uint32Type`](#uint32type)
Uint32 value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.fromNumber(42);
```
***
### greaterThan()
> **greaterThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint32/greaterThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/greaterThan.js#L18)
Check if Uint32 value is greater than another
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First value
##### b
[`Uint32Type`](#uint32type)
Second value
#### Returns
`boolean`
true if uint > b
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(200);
const b = Uint32.from(100);
const result = Uint32.greaterThan(a, b); // true
```
***
### isValid()
> **isValid**(`value`): `value is Uint32Type`
Defined in: [src/primitives/Uint32/isValid.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/isValid.js#L19)
Check if value is a valid Uint32
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is Uint32Type`
true if valid Uint32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const result1 = Uint32.isValid(100); // true
const result2 = Uint32.isValid(-1); // false
const result3 = Uint32.isValid(5000000000); // false (exceeds max)
```
***
### isZero()
> **isZero**(`uint`): `boolean`
Defined in: [src/primitives/Uint32/isZero.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/isZero.js#L16)
Check if Uint32 value is zero
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value to check
#### Returns
`boolean`
true if zero
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0);
const result = Uint32.isZero(a); // true
```
***
### leadingZeros()
> **leadingZeros**(`uint`): `number`
Defined in: [src/primitives/Uint32/leadingZeros.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/leadingZeros.js#L16)
Count leading zeros in Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value
#### Returns
`number`
Number of leading zero bits
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(255);
const result = Uint32.leadingZeros(a); // 24
```
***
### lessThan()
> **lessThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint32/lessThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/lessThan.js#L18)
Check if Uint32 value is less than another
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First value
##### b
[`Uint32Type`](#uint32type)
Second value
#### Returns
`boolean`
true if uint \< b
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/maximum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/maximum.js#L18)
Return maximum of two Uint32 values
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First value
##### b
[`Uint32Type`](#uint32type)
Second value
#### Returns
[`Uint32Type`](#uint32type)
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.maximum(a, b); // 200
```
***
### minimum()
> **minimum**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/minimum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/minimum.js#L18)
Return minimum of two Uint32 values
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First value
##### b
[`Uint32Type`](#uint32type)
Second value
#### Returns
[`Uint32Type`](#uint32type)
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(200);
const result = Uint32.minimum(a, b); // 100
```
***
### minus()
> **minus**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/minus.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/minus.js#L18)
Subtract Uint32 value with wrapping
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Difference (uint - b) mod 2^32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const diff = Uint32.minus(a, b); // 50
```
***
### modulo()
> **modulo**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/modulo.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/modulo.js#L18)
Modulo Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Dividend
##### b
[`Uint32Type`](#uint32type)
Divisor
#### Returns
[`Uint32Type`](#uint32type)
Remainder (uint % b)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(3);
const remainder = Uint32.modulo(a, b); // 1
```
***
### plus()
> **plus**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/plus.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/plus.js#L18)
Add Uint32 value with wrapping
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Sum (uint + b) mod 2^32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const sum = Uint32.plus(a, b); // 150
```
***
### popCount()
> **popCount**(`uint`): `number`
Defined in: [src/primitives/Uint32/popCount.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/popCount.js#L16)
Count set bits (population count) in Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value
#### Returns
`number`
Number of set bits
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(0b1111);
const result = Uint32.popCount(a); // 4
```
***
### shiftLeft()
> **shiftLeft**(`uint`, `bits`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/shiftLeft.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/shiftLeft.js#L17)
Left shift Uint32 value
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value to shift
##### bits
`number`
Number of bits to shift (0-31)
#### Returns
[`Uint32Type`](#uint32type)
Result (uint shifted left by bits) mod 2^32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(1);
const result = Uint32.shiftLeft(a, 8); // 256
```
***
### shiftRight()
> **shiftRight**(`uint`, `bits`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/shiftRight.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/shiftRight.js#L17)
Right shift Uint32 value (logical shift, zero-fill)
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Value to shift
##### bits
`number`
Number of bits to shift (0-31)
#### Returns
[`Uint32Type`](#uint32type)
Result (uint shifted right by bits)
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(256);
const result = Uint32.shiftRight(a, 8); // 1
```
***
### times()
> **times**(`uint`, `b`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/times.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/times.js#L18)
Multiply Uint32 value with wrapping
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
First operand
##### b
[`Uint32Type`](#uint32type)
Second operand
#### Returns
[`Uint32Type`](#uint32type)
Product (uint \* b) mod 2^32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.from(100);
const b = Uint32.from(50);
const product = Uint32.times(a, b); // 5000
```
***
### toAbiEncoded()
> **toAbiEncoded**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint32/toAbiEncoded.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toAbiEncoded.js#L16)
Convert Uint32 to ABI-encoded bytes (32 bytes, big-endian, left-padded with zeros)
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const abiBytes = Uint32.toAbiEncoded(value); // 32 bytes with last byte = 255
```
***
### toBigInt()
> **toBigInt**(`uint`): `bigint`
Defined in: [src/primitives/Uint32/toBigInt.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toBigInt.js#L16)
Convert Uint32 to bigint
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const bigintValue = Uint32.toBigInt(value); // 255n
```
***
### toBytes()
> **toBytes**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint32/toBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toBytes.js#L18)
Convert Uint32 to bytes (big-endian, 4 bytes)
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
4-byte Uint8Array
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const bytes = Uint32.toBytes(value); // Uint8Array([0, 0, 0, 255])
```
***
### toHex()
> **toHex**(`uint`): `string`
Defined in: [src/primitives/Uint32/toHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toHex.js#L16)
Convert Uint32 to hex string (with 0x prefix)
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`string`
hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const hex = Uint32.toHex(value); // "0xff"
```
***
### toNumber()
> **toNumber**(`uint`): `number`
Defined in: [src/primitives/Uint32/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toNumber.js#L16)
Convert Uint32 to number
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const num = Uint32.toNumber(value); // 255
```
***
### toPower()
> **toPower**(`uint`, `exp`): [`Uint32Type`](#uint32type)
Defined in: [src/primitives/Uint32/toPower.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toPower.js#L18)
Raise Uint32 to power with wrapping
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Base
##### exp
[`Uint32Type`](#uint32type)
Exponent
#### Returns
[`Uint32Type`](#uint32type)
Result (uint ^ exp) mod 2^32
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const base = Uint32.from(2);
const exp = Uint32.from(10);
const result = Uint32.toPower(base, exp); // 1024
```
***
### toString()
> **toString**(`uint`): `string`
Defined in: [src/primitives/Uint32/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/toString.js#L17)
Convert Uint32 to string
#### Parameters
##### uint
[`Uint32Type`](#uint32type)
Uint32 value to convert
#### Returns
`string`
decimal string representation
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const value = Uint32.from(255);
const str = Uint32.toString(value); // "255"
```
***
### tryFrom()
> **tryFrom**(`value`): [`Uint32Type`](#uint32type) | `null`
Defined in: [src/primitives/Uint32/tryFrom.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint32/tryFrom.js#L19)
Try to create Uint32 from value, return null if invalid
#### Parameters
##### value
`unknown`
Value to convert
#### Returns
[`Uint32Type`](#uint32type) | `null`
Uint32 value or null
#### See
[https://voltaire.tevm.sh/primitives/uint32](https://voltaire.tevm.sh/primitives/uint32) for Uint32 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint32 from './primitives/Uint32/index.js';
const a = Uint32.tryFrom(100); // 100
const b = Uint32.tryFrom(-1); // null
const c = Uint32.tryFrom(5000000000); // null
```
# primitives/Uint64
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint64
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint64
# primitives/Uint64
## Type Aliases
### Uint64Type
> **Uint64Type** = `bigint` & `object`
Defined in: [src/primitives/Uint64/Uint64Type.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/Uint64Type.ts#L13)
Uint64 type
64-bit unsigned integer (0 to 18446744073709551615).
Uses bigint to handle values beyond Number.MAX\_SAFE\_INTEGER.
Used for timestamps, large counters, nonces.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"Uint64"`
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
## Variables
### MAX
> `const` **MAX**: [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/constants.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/constants.js#L34)
Maximum Uint64 value: 2^64 - 1 = 18446744073709551615n
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MAX } from './primitives/Uint64/index.js';
console.log(MAX); // 18446744073709551615n
```
***
### MIN
> `const` **MIN**: [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/constants.js:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/constants.js#L50)
Minimum Uint64 value: 0n
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { MIN } from './primitives/Uint64/index.js';
console.log(MIN); // 0n
```
***
### ONE
> `const` **ONE**: [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/constants.js:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/constants.js#L78)
One value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ONE } from './primitives/Uint64/index.js';
console.log(ONE); // 1n
```
***
### SIZE
> `const` **SIZE**: `8` = `8`
Defined in: [src/primitives/Uint64/constants.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/constants.js#L20)
Size in bytes (8 bytes for Uint64)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint64/index.js';
console.log(SIZE); // 8
```
***
### Uint64
> `const` **Uint64**: `object`
Defined in: [src/primitives/Uint64/index.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/index.ts#L82)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
Calculate bit length of Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value
###### Returns
`number`
Number of bits needed to represent value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(255n);
const result = Uint64.bitLength(a); // 8
```
##### bitwiseAnd()
> **bitwiseAnd**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Bitwise AND Uint64 values
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Result (uint & b)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseAnd(a, b); // 0b1000n = 8n
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => [`Uint64Type`](#uint64type)
Bitwise NOT Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Operand
###### Returns
[`Uint64Type`](#uint64type)
Result (\~uint)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0n);
const result = Uint64.bitwiseNot(a); // 18446744073709551615n (all bits set)
```
##### bitwiseOr()
> **bitwiseOr**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Bitwise OR Uint64 values
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Result (uint | b)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseOr(a, b); // 0b1110n = 14n
```
##### bitwiseXor()
> **bitwiseXor**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Bitwise XOR Uint64 values
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Result (uint ^ b)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseXor(a, b); // 0b0110n = 6n
```
##### clone()
> **clone**: (`uint`) => [`Uint64Type`](#uint64type)
Clone Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value to clone
###### Returns
[`Uint64Type`](#uint64type)
Cloned value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.clone(a);
```
##### dividedBy()
> **dividedBy**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Divide Uint64 value (integer division)
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Dividend
###### b
[`Uint64Type`](#uint64type)
Divisor
###### Returns
[`Uint64Type`](#uint64type)
Quotient (uint / b) truncated
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(3n);
const quotient = Uint64.dividedBy(a, b); // 33n
```
##### equals()
> **equals**: (`uint`, `b`) => `boolean`
Check if Uint64 values are equal
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First value
###### b
[`Uint64Type`](#uint64type)
Second value
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(100n);
const result = Uint64.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`Uint64Type`](#uint64type)
Create Uint64 from bigint, number, or string
###### Parameters
###### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from("18446744073709551615");
const c = Uint64.from("0xffffffffffffffff");
const d = Uint64.from(42);
```
##### fromAbiEncoded()
> **fromAbiEncoded**: (`bytes`) => [`Uint64Type`](#uint64type)
Create Uint64 from ABI-encoded bytes (32 bytes, big-endian, left-padded)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
ABI-encoded byte array (32 bytes)
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 32
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const abiBytes = new Uint8Array(32);
abiBytes[31] = 255;
const value = Uint64.fromAbiEncoded(abiBytes); // 255n
```
##### fromBigInt()
> **fromBigInt**: (`value`) => [`Uint64Type`](#uint64type)
Create Uint64 from bigint
###### Parameters
###### value
`bigint`
bigint value
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.fromBigInt(100n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => [`Uint64Type`](#uint64type)
Create Uint64 from bytes (big-endian, 8 bytes)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
byte array (must be exactly 8 bytes)
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 8
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const bytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 255]);
const value = Uint64.fromBytes(bytes); // 255n
```
##### fromHex()
> **fromHex**: (`hex`) => [`Uint64Type`](#uint64type)
Create Uint64 from hex string
###### Parameters
###### hex
`string`
hex string (with or without 0x prefix)
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid hex
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.fromHex("0xffffffffffffffff");
const b = Uint64.fromHex("ff");
```
##### fromNumber()
> **fromNumber**: (`value`) => [`Uint64Type`](#uint64type)
Create Uint64 from number
WARNING: Values above Number.MAX\_SAFE\_INTEGER may lose precision
###### Parameters
###### value
`number`
number value
###### Returns
[`Uint64Type`](#uint64type)
Uint64 value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If value is out of range or invalid
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.fromNumber(42);
```
##### greaterThan()
> **greaterThan**: (`uint`, `b`) => `boolean`
Check if Uint64 value is greater than another
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First value
###### b
[`Uint64Type`](#uint64type)
Second value
###### Returns
`boolean`
true if uint > b
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(200n);
const b = Uint64.from(100n);
const result = Uint64.greaterThan(a, b); // true
```
##### isValid()
> **isValid**: (`value`) => `value is Uint64Type`
Check if value is a valid Uint64
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Uint64Type`
true if valid Uint64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const result1 = Uint64.isValid(100n); // true
const result2 = Uint64.isValid(-1n); // false
const result3 = Uint64.isValid(100); // false (must be bigint)
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Check if Uint64 value is zero
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value to check
###### Returns
`boolean`
true if zero
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0n);
const result = Uint64.isZero(a); // true
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Count leading zeros in Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value
###### Returns
`number`
Number of leading zero bits
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(255n);
const result = Uint64.leadingZeros(a); // 56
```
##### lessThan()
> **lessThan**: (`uint`, `b`) => `boolean`
Check if Uint64 value is less than another
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First value
###### b
[`Uint64Type`](#uint64type)
Second value
###### Returns
`boolean`
true if uint \< b
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.lessThan(a, b); // true
```
##### MAX
> **MAX**: [`Uint64Type`](#uint64type)
Maximum Uint64 value: 2^64 - 1 = 18446744073709551615n
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MAX } from './primitives/Uint64/index.js';
console.log(MAX); // 18446744073709551615n
```
##### maximum()
> **maximum**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Return maximum of two Uint64 values
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First value
###### b
[`Uint64Type`](#uint64type)
Second value
###### Returns
[`Uint64Type`](#uint64type)
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.maximum(a, b); // 200n
```
##### MIN
> **MIN**: [`Uint64Type`](#uint64type)
Minimum Uint64 value: 0n
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { MIN } from './primitives/Uint64/index.js';
console.log(MIN); // 0n
```
##### minimum()
> **minimum**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Return minimum of two Uint64 values
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First value
###### b
[`Uint64Type`](#uint64type)
Second value
###### Returns
[`Uint64Type`](#uint64type)
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.minimum(a, b); // 100n
```
##### minus()
> **minus**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Subtract Uint64 value with wrapping
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Difference (uint - b) mod 2^64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const diff = Uint64.minus(a, b); // 50n
```
##### modulo()
> **modulo**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Modulo Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Dividend
###### b
[`Uint64Type`](#uint64type)
Divisor
###### Returns
[`Uint64Type`](#uint64type)
Remainder (uint % b)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(3n);
const remainder = Uint64.modulo(a, b); // 1n
```
##### ONE
> **ONE**: [`Uint64Type`](#uint64type)
One value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ONE } from './primitives/Uint64/index.js';
console.log(ONE); // 1n
```
##### plus()
> **plus**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Add Uint64 value with wrapping
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Sum (uint + b) mod 2^64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const sum = Uint64.plus(a, b); // 150n
```
##### popCount()
> **popCount**: (`uint`) => `number`
Count set bits (population count) in Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value
###### Returns
`number`
Number of set bits
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1111n);
const result = Uint64.popCount(a); // 4
```
##### shiftLeft()
> **shiftLeft**: (`uint`, `bits`) => [`Uint64Type`](#uint64type)
Left shift Uint64 value
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value to shift
###### bits
Number of bits to shift (0-63)
`number` | `bigint`
###### Returns
[`Uint64Type`](#uint64type)
Result (uint shifted left by bits) mod 2^64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(1n);
const result = Uint64.shiftLeft(a, 8n); // 256n
```
##### shiftRight()
> **shiftRight**: (`uint`, `bits`) => [`Uint64Type`](#uint64type)
Right shift Uint64 value (logical shift, zero-fill)
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Value to shift
###### bits
Number of bits to shift (0-63)
`number` | `bigint`
###### Returns
[`Uint64Type`](#uint64type)
Result (uint shifted right by bits)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(256n);
const result = Uint64.shiftRight(a, 8n); // 1n
```
##### SIZE
> **SIZE**: `8`
Size in bytes (8 bytes for Uint64)
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { SIZE } from './primitives/Uint64/index.js';
console.log(SIZE); // 8
```
##### times()
> **times**: (`uint`, `b`) => [`Uint64Type`](#uint64type)
Multiply Uint64 value with wrapping
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
First operand
###### b
[`Uint64Type`](#uint64type)
Second operand
###### Returns
[`Uint64Type`](#uint64type)
Product (uint \* b) mod 2^64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const product = Uint64.times(a, b); // 5000n
```
##### toAbiEncoded()
> **toAbiEncoded**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint64 to ABI-encoded bytes (32 bytes, big-endian, left-padded with zeros)
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const abiBytes = Uint64.toAbiEncoded(value);
```
##### toBigInt()
> **toBigInt**: (`uint`) => `bigint`
Convert Uint64 to bigint
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`bigint`
bigint value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const bigintValue = Uint64.toBigInt(value); // 255n
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint64 to bytes (big-endian, 8 bytes)
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
8-byte Uint8Array
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const bytes = Uint64.toBytes(value);
```
##### toHex()
> **toHex**: (`uint`) => `string`
Convert Uint64 to hex string (with 0x prefix)
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`string`
hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const hex = Uint64.toHex(value); // "0xff"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Convert Uint64 to number
WARNING: Values above Number.MAX\_SAFE\_INTEGER (9007199254740991) may lose precision
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`number`
number value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const num = Uint64.toNumber(value); // 255
```
##### toPower()
> **toPower**: (`uint`, `exp`) => [`Uint64Type`](#uint64type)
Raise Uint64 to power with wrapping
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Base
###### exp
[`Uint64Type`](#uint64type)
Exponent
###### Returns
[`Uint64Type`](#uint64type)
Result (uint ^ exp) mod 2^64
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const base = Uint64.from(2n);
const exp = Uint64.from(10n);
const result = Uint64.toPower(base, exp); // 1024n
```
##### toString()
> **toString**: (`uint`) => `string`
Convert Uint64 to string
###### Parameters
###### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
###### Returns
`string`
decimal string representation
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const str = Uint64.toString(value); // "255"
```
##### tryFrom()
> **tryFrom**: (`value`) => [`Uint64Type`](#uint64type) | `null`
Try to create Uint64 from value, return null if invalid
###### Parameters
###### value
`unknown`
Value to convert
###### Returns
[`Uint64Type`](#uint64type) | `null`
Uint64 value or null
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.tryFrom(100n); // 100n
const b = Uint64.tryFrom(-1n); // null
const c = Uint64.tryFrom("not a number"); // null
```
##### ZERO
> **ZERO**: [`Uint64Type`](#uint64type)
Zero value
###### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
###### Since
0.0.0
###### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint64/index.js';
console.log(ZERO); // 0n
```
***
### ZERO
> `const` **ZERO**: [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/constants.js:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/constants.js#L64)
Zero value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Example
```javascript theme={null}
import { ZERO } from './primitives/Uint64/index.js';
console.log(ZERO); // 0n
```
## Functions
### bitLength()
> **bitLength**(`uint`): `number`
Defined in: [src/primitives/Uint64/bitLength.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/bitLength.js#L16)
Calculate bit length of Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value
#### Returns
`number`
Number of bits needed to represent value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(255n);
const result = Uint64.bitLength(a); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/bitwiseAnd.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/bitwiseAnd.js#L18)
Bitwise AND Uint64 values
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Result (uint & b)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseAnd(a, b); // 0b1000n = 8n
```
***
### bitwiseNot()
> **bitwiseNot**(`uint`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/bitwiseNot.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/bitwiseNot.js#L18)
Bitwise NOT Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Operand
#### Returns
[`Uint64Type`](#uint64type)
Result (\~uint)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0n);
const result = Uint64.bitwiseNot(a); // 18446744073709551615n (all bits set)
```
***
### bitwiseOr()
> **bitwiseOr**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/bitwiseOr.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/bitwiseOr.js#L18)
Bitwise OR Uint64 values
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Result (uint | b)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseOr(a, b); // 0b1110n = 14n
```
***
### bitwiseXor()
> **bitwiseXor**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/bitwiseXor.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/bitwiseXor.js#L18)
Bitwise XOR Uint64 values
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Result (uint ^ b)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1100n);
const b = Uint64.from(0b1010n);
const result = Uint64.bitwiseXor(a, b); // 0b0110n = 6n
```
***
### clone()
> **clone**(`uint`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/clone.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/clone.js#L16)
Clone Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value to clone
#### Returns
[`Uint64Type`](#uint64type)
Cloned value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.clone(a);
```
***
### dividedBy()
> **dividedBy**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/dividedBy.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/dividedBy.js#L18)
Divide Uint64 value (integer division)
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Dividend
##### b
[`Uint64Type`](#uint64type)
Divisor
#### Returns
[`Uint64Type`](#uint64type)
Quotient (uint / b) truncated
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(3n);
const quotient = Uint64.dividedBy(a, b); // 33n
```
***
### equals()
> **equals**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint64/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/equals.js#L18)
Check if Uint64 values are equal
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First value
##### b
[`Uint64Type`](#uint64type)
Second value
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(100n);
const result = Uint64.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/from.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/from.js#L20)
Create Uint64 from bigint, number, or string
#### Parameters
##### value
bigint, number, or decimal/hex string
`string` | `number` | `bigint`
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from("18446744073709551615");
const c = Uint64.from("0xffffffffffffffff");
const d = Uint64.from(42);
```
***
### fromAbiEncoded()
> **fromAbiEncoded**(`bytes`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/fromAbiEncoded.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/fromAbiEncoded.js#L17)
Create Uint64 from ABI-encoded bytes (32 bytes, big-endian, left-padded)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
ABI-encoded byte array (32 bytes)
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 32
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const abiBytes = new Uint8Array(32);
abiBytes[31] = 255;
const value = Uint64.fromAbiEncoded(abiBytes); // 255n
```
***
### fromBigInt()
> **fromBigInt**(`value`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/fromBigInt.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/fromBigInt.js#L17)
Create Uint64 from bigint
#### Parameters
##### value
`bigint`
bigint value
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.fromBigInt(100n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/fromBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/fromBytes.js#L18)
Create Uint64 from bytes (big-endian, 8 bytes)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
byte array (must be exactly 8 bytes)
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 8
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const bytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 255]);
const value = Uint64.fromBytes(bytes); // 255n
```
***
### fromHex()
> **fromHex**(`hex`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/fromHex.js#L18)
Create Uint64 from hex string
#### Parameters
##### hex
`string`
hex string (with or without 0x prefix)
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid hex
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.fromHex("0xffffffffffffffff");
const b = Uint64.fromHex("ff");
```
***
### fromNumber()
> **fromNumber**(`value`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/fromNumber.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/fromNumber.js#L18)
Create Uint64 from number
WARNING: Values above Number.MAX\_SAFE\_INTEGER may lose precision
#### Parameters
##### value
`number`
number value
#### Returns
[`Uint64Type`](#uint64type)
Uint64 value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If value is out of range or invalid
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.fromNumber(42);
```
***
### greaterThan()
> **greaterThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint64/greaterThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/greaterThan.js#L18)
Check if Uint64 value is greater than another
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First value
##### b
[`Uint64Type`](#uint64type)
Second value
#### Returns
`boolean`
true if uint > b
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(200n);
const b = Uint64.from(100n);
const result = Uint64.greaterThan(a, b); // true
```
***
### isValid()
> **isValid**(`value`): `value is Uint64Type`
Defined in: [src/primitives/Uint64/isValid.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/isValid.js#L19)
Check if value is a valid Uint64
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is Uint64Type`
true if valid Uint64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const result1 = Uint64.isValid(100n); // true
const result2 = Uint64.isValid(-1n); // false
const result3 = Uint64.isValid(100); // false (must be bigint)
```
***
### isZero()
> **isZero**(`uint`): `boolean`
Defined in: [src/primitives/Uint64/isZero.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/isZero.js#L16)
Check if Uint64 value is zero
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value to check
#### Returns
`boolean`
true if zero
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0n);
const result = Uint64.isZero(a); // true
```
***
### leadingZeros()
> **leadingZeros**(`uint`): `number`
Defined in: [src/primitives/Uint64/leadingZeros.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/leadingZeros.js#L16)
Count leading zeros in Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value
#### Returns
`number`
Number of leading zero bits
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(255n);
const result = Uint64.leadingZeros(a); // 56
```
***
### lessThan()
> **lessThan**(`uint`, `b`): `boolean`
Defined in: [src/primitives/Uint64/lessThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/lessThan.js#L18)
Check if Uint64 value is less than another
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First value
##### b
[`Uint64Type`](#uint64type)
Second value
#### Returns
`boolean`
true if uint \< b
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/maximum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/maximum.js#L18)
Return maximum of two Uint64 values
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First value
##### b
[`Uint64Type`](#uint64type)
Second value
#### Returns
[`Uint64Type`](#uint64type)
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.maximum(a, b); // 200n
```
***
### minimum()
> **minimum**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/minimum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/minimum.js#L18)
Return minimum of two Uint64 values
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First value
##### b
[`Uint64Type`](#uint64type)
Second value
#### Returns
[`Uint64Type`](#uint64type)
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(200n);
const result = Uint64.minimum(a, b); // 100n
```
***
### minus()
> **minus**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/minus.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/minus.js#L20)
Subtract Uint64 value with wrapping
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Difference (uint - b) mod 2^64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const diff = Uint64.minus(a, b); // 50n
```
***
### modulo()
> **modulo**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/modulo.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/modulo.js#L18)
Modulo Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Dividend
##### b
[`Uint64Type`](#uint64type)
Divisor
#### Returns
[`Uint64Type`](#uint64type)
Remainder (uint % b)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(3n);
const remainder = Uint64.modulo(a, b); // 1n
```
***
### plus()
> **plus**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/plus.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/plus.js#L20)
Add Uint64 value with wrapping
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Sum (uint + b) mod 2^64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const sum = Uint64.plus(a, b); // 150n
```
***
### popCount()
> **popCount**(`uint`): `number`
Defined in: [src/primitives/Uint64/popCount.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/popCount.js#L16)
Count set bits (population count) in Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value
#### Returns
`number`
Number of set bits
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(0b1111n);
const result = Uint64.popCount(a); // 4
```
***
### shiftLeft()
> **shiftLeft**(`uint`, `bits`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/shiftLeft.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/shiftLeft.js#L19)
Left shift Uint64 value
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value to shift
##### bits
Number of bits to shift (0-63)
`number` | `bigint`
#### Returns
[`Uint64Type`](#uint64type)
Result (uint shifted left by bits) mod 2^64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(1n);
const result = Uint64.shiftLeft(a, 8n); // 256n
```
***
### shiftRight()
> **shiftRight**(`uint`, `bits`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/shiftRight.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/shiftRight.js#L17)
Right shift Uint64 value (logical shift, zero-fill)
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Value to shift
##### bits
Number of bits to shift (0-63)
`number` | `bigint`
#### Returns
[`Uint64Type`](#uint64type)
Result (uint shifted right by bits)
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(256n);
const result = Uint64.shiftRight(a, 8n); // 1n
```
***
### times()
> **times**(`uint`, `b`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/times.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/times.js#L20)
Multiply Uint64 value with wrapping
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
First operand
##### b
[`Uint64Type`](#uint64type)
Second operand
#### Returns
[`Uint64Type`](#uint64type)
Product (uint \* b) mod 2^64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.from(100n);
const b = Uint64.from(50n);
const product = Uint64.times(a, b); // 5000n
```
***
### toAbiEncoded()
> **toAbiEncoded**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint64/toAbiEncoded.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toAbiEncoded.js#L16)
Convert Uint64 to ABI-encoded bytes (32 bytes, big-endian, left-padded with zeros)
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte Uint8Array
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const abiBytes = Uint64.toAbiEncoded(value);
```
***
### toBigInt()
> **toBigInt**(`uint`): `bigint`
Defined in: [src/primitives/Uint64/toBigInt.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toBigInt.js#L16)
Convert Uint64 to bigint
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const bigintValue = Uint64.toBigInt(value); // 255n
```
***
### toBytes()
> **toBytes**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint64/toBytes.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toBytes.js#L18)
Convert Uint64 to bytes (big-endian, 8 bytes)
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
8-byte Uint8Array
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const bytes = Uint64.toBytes(value);
```
***
### toHex()
> **toHex**(`uint`): `string`
Defined in: [src/primitives/Uint64/toHex.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toHex.js#L16)
Convert Uint64 to hex string (with 0x prefix)
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`string`
hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const hex = Uint64.toHex(value); // "0xff"
```
***
### toNumber()
> **toNumber**(`uint`): `number`
Defined in: [src/primitives/Uint64/toNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toNumber.js#L17)
Convert Uint64 to number
WARNING: Values above Number.MAX\_SAFE\_INTEGER (9007199254740991) may lose precision
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const num = Uint64.toNumber(value); // 255
```
***
### toPower()
> **toPower**(`uint`, `exp`): [`Uint64Type`](#uint64type)
Defined in: [src/primitives/Uint64/toPower.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toPower.js#L20)
Raise Uint64 to power with wrapping
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Base
##### exp
[`Uint64Type`](#uint64type)
Exponent
#### Returns
[`Uint64Type`](#uint64type)
Result (uint ^ exp) mod 2^64
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const base = Uint64.from(2n);
const exp = Uint64.from(10n);
const result = Uint64.toPower(base, exp); // 1024n
```
***
### toString()
> **toString**(`uint`): `string`
Defined in: [src/primitives/Uint64/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/toString.js#L17)
Convert Uint64 to string
#### Parameters
##### uint
[`Uint64Type`](#uint64type)
Uint64 value to convert
#### Returns
`string`
decimal string representation
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const value = Uint64.from(255n);
const str = Uint64.toString(value); // "255"
```
***
### tryFrom()
> **tryFrom**(`value`): [`Uint64Type`](#uint64type) | `null`
Defined in: [src/primitives/Uint64/tryFrom.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint64/tryFrom.js#L19)
Try to create Uint64 from value, return null if invalid
#### Parameters
##### value
`unknown`
Value to convert
#### Returns
[`Uint64Type`](#uint64type) | `null`
Uint64 value or null
#### See
[https://voltaire.tevm.sh/primitives/uint64](https://voltaire.tevm.sh/primitives/uint64) for Uint64 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint64 from './primitives/Uint64/index.js';
const a = Uint64.tryFrom(100n); // 100n
const b = Uint64.tryFrom(-1n); // null
const c = Uint64.tryFrom("not a number"); // null
```
# primitives/Uint8
Source: https://voltaire.tevm.sh/generated-api/primitives/Uint8
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uint8
# primitives/Uint8
## Variables
### MAX
> `const` **MAX**: `Uint8Type`
Defined in: [src/primitives/Uint8/constants.js:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/constants.js#L12)
***
### MIN
> `const` **MIN**: `Uint8Type`
Defined in: [src/primitives/Uint8/constants.js:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/constants.js#L9)
***
### ONE
> `const` **ONE**: `Uint8Type`
Defined in: [src/primitives/Uint8/constants.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/constants.js#L18)
***
### SIZE
> `const` **SIZE**: `number` = `8`
Defined in: [src/primitives/Uint8/constants.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/constants.js#L21)
***
### Uint8Type
> `const` **Uint8Type**: `object`
Defined in: [src/primitives/Uint8/index.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/index.ts#L72)
#### Type Declaration
##### bitLength()
> **bitLength**: (`uint`) => `number`
Get bit length of Uint8 value (position of highest set bit)
###### Parameters
###### uint
`Uint8Type`
Input value
###### Returns
`number`
Number of bits needed to represent value (0-8)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.bitLength(Uint8.from(0)); // 0
Uint8.bitLength(Uint8.from(1)); // 1
Uint8.bitLength(Uint8.from(255)); // 8
Uint8.bitLength(Uint8.from(128)); // 8
```
##### bitwiseAnd()
> **bitwiseAnd**: (`a`, `b`) => `Uint8Type`
Bitwise AND of two Uint8 values
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Bitwise AND result
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b11001100);
const result = Uint8.bitwiseAnd(a, b); // 0b11000000 = 192
```
##### bitwiseNot()
> **bitwiseNot**: (`uint`) => `Uint8Type`
Bitwise NOT of Uint8 value
###### Parameters
###### uint
`Uint8Type`
Input value
###### Returns
`Uint8Type`
Bitwise NOT result
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const result = Uint8.bitwiseNot(a); // 0b00001111 = 15
```
##### bitwiseOr()
> **bitwiseOr**: (`a`, `b`) => `Uint8Type`
Bitwise OR of two Uint8 values
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Bitwise OR result
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b00001111);
const result = Uint8.bitwiseOr(a, b); // 0b11111111 = 255
```
##### bitwiseXor()
> **bitwiseXor**: (`a`, `b`) => `Uint8Type`
Bitwise XOR of two Uint8 values
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Bitwise XOR result
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b11001100);
const result = Uint8.bitwiseXor(a, b); // 0b00111100 = 60
```
##### dividedBy()
> **dividedBy**: (`a`, `b`) => `Uint8Type`
Divide two Uint8 values (integer division)
###### Parameters
###### a
`Uint8Type`
Dividend
###### b
`Uint8Type`
Divisor
###### Returns
`Uint8Type`
Quotient (floor(a / b))
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(5);
const quotient = Uint8.dividedBy(a, b); // 20
```
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if two Uint8 values are equal
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`boolean`
true if a === b
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(100);
const isEqual = Uint8.equals(a, b); // true
```
##### from()
> **from**: (`value`) => `Uint8Type`
Create Uint8 from number or string
###### Parameters
###### value
number or decimal/hex string
`string` | `number`
###### Returns
`Uint8Type`
Uint8 value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If value is not a valid integer
###### Throws
If value is negative
###### Throws
If value exceeds 255
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from("255");
const c = Uint8.from("0xff");
```
##### fromBigint()
> **fromBigint**: (`value`) => `Uint8Type`
Create Uint8 from bigint
###### Parameters
###### value
`bigint`
bigint value
###### Returns
`Uint8Type`
Uint8 value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If value is out of range
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.fromBigint(255n);
```
##### fromBytes()
> **fromBytes**: (`bytes`) => `Uint8Type`
Create Uint8 from Uint8Array (single byte)
###### Parameters
###### bytes
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array (must be exactly 1 byte)
###### Returns
`Uint8Type`
Uint8 value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If bytes length is not 1
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const bytes = new Uint8Array([255]);
const value = Uint8.fromBytes(bytes);
```
##### fromHex()
> **fromHex**: (`hex`) => `Uint8Type`
Create Uint8 from hex string
###### Parameters
###### hex
`string`
hex string (with or without 0x prefix)
###### Returns
`Uint8Type`
Uint8 value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If hex is invalid or out of range
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.fromHex("0xff");
const b = Uint8.fromHex("ff");
```
##### fromNumber()
> **fromNumber**: (`value`) => `Uint8Type`
Create Uint8 from number
###### Parameters
###### value
`number`
number value
###### Returns
`Uint8Type`
Uint8 value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If value is out of range or not an integer
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.fromNumber(255);
```
##### greaterThan()
> **greaterThan**: (`a`, `b`) => `boolean`
Check if first Uint8 is greater than second
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`boolean`
true if a > b
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const isGreater = Uint8.greaterThan(a, b); // true
```
##### isValid()
> **isValid**: (`value`) => `value is Uint8Type`
Check if value is a valid Uint8
###### Parameters
###### value
`unknown`
Value to check
###### Returns
`value is Uint8Type`
true if valid Uint8
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.isValid(100); // true
Uint8.isValid(255); // true
Uint8.isValid(256); // false
Uint8.isValid(-1); // false
Uint8.isValid(1.5); // false
```
##### isZero()
> **isZero**: (`uint`) => `boolean`
Check if Uint8 value is zero
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### Returns
`boolean`
true if uint === 0
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0);
const b = Uint8.from(100);
Uint8.isZero(a); // true
Uint8.isZero(b); // false
```
##### leadingZeros()
> **leadingZeros**: (`uint`) => `number`
Count leading zero bits in Uint8 value
###### Parameters
###### uint
`Uint8Type`
Input value
###### Returns
`number`
Number of leading zero bits (0-8)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.leadingZeros(Uint8.from(0)); // 8
Uint8.leadingZeros(Uint8.from(1)); // 7
Uint8.leadingZeros(Uint8.from(255)); // 0
Uint8.leadingZeros(Uint8.from(128)); // 0
```
##### lessThan()
> **lessThan**: (`a`, `b`) => `boolean`
Check if first Uint8 is less than second
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`boolean`
true if a \< b
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(50);
const b = Uint8.from(100);
const isLess = Uint8.lessThan(a, b); // true
```
##### MAX
> **MAX**: `Uint8Type`
##### maximum()
> **maximum**: (`a`, `b`) => `Uint8Type`
Return maximum of two Uint8 values
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Maximum value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const max = Uint8.maximum(a, b); // 100
```
##### MIN
> **MIN**: `Uint8Type`
##### minimum()
> **minimum**: (`a`, `b`) => `Uint8Type`
Return minimum of two Uint8 values
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Minimum value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const min = Uint8.minimum(a, b); // 50
```
##### minus()
> **minus**: (`a`, `b`) => `Uint8Type`
Subtract two Uint8 values with underflow checking
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Difference (a - b)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If result is negative
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const diff = Uint8.minus(a, b); // 50
```
##### modulo()
> **modulo**: (`a`, `b`) => `Uint8Type`
Compute modulo of two Uint8 values
###### Parameters
###### a
`Uint8Type`
Dividend
###### b
`Uint8Type`
Divisor
###### Returns
`Uint8Type`
Remainder (a % b)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If divisor is zero
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(7);
const remainder = Uint8.modulo(a, b); // 2
```
##### ONE
> **ONE**: `Uint8Type`
##### plus()
> **plus**: (`a`, `b`) => `Uint8Type`
Add two Uint8 values with overflow checking
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Sum (a + b)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If result exceeds maximum value
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const sum = Uint8.plus(a, b); // 150
```
##### popCount()
> **popCount**: (`uint`) => `number`
Count number of set bits (population count) in Uint8 value
###### Parameters
###### uint
`Uint8Type`
Input value
###### Returns
`number`
Number of set bits (0-8)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.popCount(Uint8.from(0)); // 0
Uint8.popCount(Uint8.from(255)); // 8
Uint8.popCount(Uint8.from(0b10101010)); // 4
```
##### shiftLeft()
> **shiftLeft**: (`uint`, `shift`) => `Uint8Type`
Left shift Uint8 value
###### Parameters
###### uint
`Uint8Type`
Value to shift
###### shift
`number`
Number of bits to shift (0-7)
###### Returns
`Uint8Type`
Left-shifted value (masked to 8 bits)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b00001111);
const result = Uint8.shiftLeft(a, 4); // 0b11110000 = 240
```
##### shiftRight()
> **shiftRight**: (`uint`, `shift`) => `Uint8Type`
Right shift Uint8 value (logical shift)
###### Parameters
###### uint
`Uint8Type`
Value to shift
###### shift
`number`
Number of bits to shift (0-7)
###### Returns
`Uint8Type`
Right-shifted value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const result = Uint8.shiftRight(a, 4); // 0b00001111 = 15
```
##### SIZE
> **SIZE**: `number`
##### times()
> **times**: (`a`, `b`) => `Uint8Type`
Multiply two Uint8 values with overflow checking
###### Parameters
###### a
`Uint8Type`
First operand
###### b
`Uint8Type`
Second operand
###### Returns
`Uint8Type`
Product (a \* b)
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
If result exceeds maximum value
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(10);
const b = Uint8.from(5);
const product = Uint8.times(a, b); // 50
```
##### toBigint()
> **toBigint**: (`uint`) => `bigint`
Convert Uint8 to bigint
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### Returns
`bigint`
bigint value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const bigintValue = Uint8.toBigint(value); // 255n
```
##### toBytes()
> **toBytes**: (`uint`) => `Uint8Array`\<`ArrayBufferLike`>
Convert Uint8 to Uint8Array (1 byte)
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### Returns
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array of length 1
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const bytes = Uint8.toBytes(value); // Uint8Array([255])
```
##### toHex()
> **toHex**: (`uint`, `padded?`) => `string`
Convert Uint8 to hex string
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### padded?
`boolean` = `true`
Whether to pad to 2 characters (1 byte)
###### Returns
`string`
Hex string with 0x prefix
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const hex1 = Uint8.toHex(value); // "0xff"
const hex2 = Uint8.toHex(value, false); // "0xff"
const value2 = Uint8.from(15);
const hex3 = Uint8.toHex(value2); // "0x0f"
const hex4 = Uint8.toHex(value2, false); // "0xf"
```
##### toNumber()
> **toNumber**: (`uint`) => `number`
Convert Uint8 to number
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### Returns
`number`
number value
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const num = Uint8.toNumber(value); // 255
```
##### toString()
> **toString**: (`uint`) => `string`
Convert Uint8 to decimal string
###### Parameters
###### uint
`Uint8Type`
Uint8 value
###### Returns
`string`
Decimal string representation
###### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const str = Uint8.toString(value); // "255"
```
##### ZERO
> **ZERO**: `Uint8Type`
***
### ZERO
> `const` **ZERO**: `Uint8Type`
Defined in: [src/primitives/Uint8/constants.js:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/constants.js#L15)
## Functions
### bitLength()
> **bitLength**(`uint`): `number`
Defined in: [src/primitives/Uint8/bitLength.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/bitLength.js#L18)
Get bit length of Uint8 value (position of highest set bit)
#### Parameters
##### uint
`Uint8Type`
Input value
#### Returns
`number`
Number of bits needed to represent value (0-8)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.bitLength(Uint8.from(0)); // 0
Uint8.bitLength(Uint8.from(1)); // 1
Uint8.bitLength(Uint8.from(255)); // 8
Uint8.bitLength(Uint8.from(128)); // 8
```
***
### bitwiseAnd()
> **bitwiseAnd**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/bitwiseAnd.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/bitwiseAnd.js#L18)
Bitwise AND of two Uint8 values
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Bitwise AND result
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b11001100);
const result = Uint8.bitwiseAnd(a, b); // 0b11000000 = 192
```
***
### bitwiseNot()
> **bitwiseNot**(`uint`): `Uint8Type`
Defined in: [src/primitives/Uint8/bitwiseNot.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/bitwiseNot.js#L18)
Bitwise NOT of Uint8 value
#### Parameters
##### uint
`Uint8Type`
Input value
#### Returns
`Uint8Type`
Bitwise NOT result
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const result = Uint8.bitwiseNot(a); // 0b00001111 = 15
```
***
### bitwiseOr()
> **bitwiseOr**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/bitwiseOr.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/bitwiseOr.js#L18)
Bitwise OR of two Uint8 values
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Bitwise OR result
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b00001111);
const result = Uint8.bitwiseOr(a, b); // 0b11111111 = 255
```
***
### bitwiseXor()
> **bitwiseXor**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/bitwiseXor.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/bitwiseXor.js#L18)
Bitwise XOR of two Uint8 values
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Bitwise XOR result
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const b = Uint8.from(0b11001100);
const result = Uint8.bitwiseXor(a, b); // 0b00111100 = 60
```
***
### dividedBy()
> **dividedBy**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/dividedBy.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/dividedBy.js#L18)
Divide two Uint8 values (integer division)
#### Parameters
##### a
`Uint8Type`
Dividend
##### b
`Uint8Type`
Divisor
#### Returns
`Uint8Type`
Quotient (floor(a / b))
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(5);
const quotient = Uint8.dividedBy(a, b); // 20
```
***
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint8/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/equals.js#L18)
Check if two Uint8 values are equal
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`boolean`
true if a === b
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(100);
const isEqual = Uint8.equals(a, b); // true
```
***
### from()
> **from**(`value`): `Uint8Type`
Defined in: [src/primitives/Uint8/from.js:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/from.js#L26)
Create Uint8 from number or string
#### Parameters
##### value
number or decimal/hex string
`string` | `number`
#### Returns
`Uint8Type`
Uint8 value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If value is not a valid integer
#### Throws
If value is negative
#### Throws
If value exceeds 255
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from("255");
const c = Uint8.from("0xff");
```
***
### fromBigint()
> **fromBigint**(`value`): `Uint8Type`
Defined in: [src/primitives/Uint8/fromBigint.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/fromBigint.js#L17)
Create Uint8 from bigint
#### Parameters
##### value
`bigint`
bigint value
#### Returns
`Uint8Type`
Uint8 value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If value is out of range
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.fromBigint(255n);
```
***
### fromBytes()
> **fromBytes**(`bytes`): `Uint8Type`
Defined in: [src/primitives/Uint8/fromBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/fromBytes.js#L16)
Create Uint8 from Uint8Array (single byte)
#### Parameters
##### bytes
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array (must be exactly 1 byte)
#### Returns
`Uint8Type`
Uint8 value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If bytes length is not 1
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const bytes = new Uint8Array([255]);
const value = Uint8.fromBytes(bytes);
```
***
### fromHex()
> **fromHex**(`hex`): `Uint8Type`
Defined in: [src/primitives/Uint8/fromHex.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/fromHex.js#L18)
Create Uint8 from hex string
#### Parameters
##### hex
`string`
hex string (with or without 0x prefix)
#### Returns
`Uint8Type`
Uint8 value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If hex is invalid or out of range
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.fromHex("0xff");
const b = Uint8.fromHex("ff");
```
***
### fromNumber()
> **fromNumber**(`value`): `Uint8Type`
Defined in: [src/primitives/Uint8/fromNumber.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/fromNumber.js#L17)
Create Uint8 from number
#### Parameters
##### value
`number`
number value
#### Returns
`Uint8Type`
Uint8 value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If value is out of range or not an integer
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.fromNumber(255);
```
***
### greaterThan()
> **greaterThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint8/greaterThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/greaterThan.js#L18)
Check if first Uint8 is greater than second
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`boolean`
true if a > b
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const isGreater = Uint8.greaterThan(a, b); // true
```
***
### isValid()
> **isValid**(`value`): `value is Uint8Type`
Defined in: [src/primitives/Uint8/isValid.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/isValid.js#L21)
Check if value is a valid Uint8
#### Parameters
##### value
`unknown`
Value to check
#### Returns
`value is Uint8Type`
true if valid Uint8
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.isValid(100); // true
Uint8.isValid(255); // true
Uint8.isValid(256); // false
Uint8.isValid(-1); // false
Uint8.isValid(1.5); // false
```
***
### isZero()
> **isZero**(`uint`): `boolean`
Defined in: [src/primitives/Uint8/isZero.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/isZero.js#L18)
Check if Uint8 value is zero
#### Parameters
##### uint
`Uint8Type`
Uint8 value
#### Returns
`boolean`
true if uint === 0
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0);
const b = Uint8.from(100);
Uint8.isZero(a); // true
Uint8.isZero(b); // false
```
***
### leadingZeros()
> **leadingZeros**(`uint`): `number`
Defined in: [src/primitives/Uint8/leadingZeros.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/leadingZeros.js#L18)
Count leading zero bits in Uint8 value
#### Parameters
##### uint
`Uint8Type`
Input value
#### Returns
`number`
Number of leading zero bits (0-8)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.leadingZeros(Uint8.from(0)); // 8
Uint8.leadingZeros(Uint8.from(1)); // 7
Uint8.leadingZeros(Uint8.from(255)); // 0
Uint8.leadingZeros(Uint8.from(128)); // 0
```
***
### lessThan()
> **lessThan**(`a`, `b`): `boolean`
Defined in: [src/primitives/Uint8/lessThan.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/lessThan.js#L18)
Check if first Uint8 is less than second
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`boolean`
true if a \< b
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(50);
const b = Uint8.from(100);
const isLess = Uint8.lessThan(a, b); // true
```
***
### maximum()
> **maximum**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/maximum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/maximum.js#L18)
Return maximum of two Uint8 values
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Maximum value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const max = Uint8.maximum(a, b); // 100
```
***
### minimum()
> **minimum**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/minimum.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/minimum.js#L18)
Return minimum of two Uint8 values
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Minimum value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const min = Uint8.minimum(a, b); // 50
```
***
### minus()
> **minus**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/minus.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/minus.js#L18)
Subtract two Uint8 values with underflow checking
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Difference (a - b)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If result is negative
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const diff = Uint8.minus(a, b); // 50
```
***
### modulo()
> **modulo**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/modulo.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/modulo.js#L18)
Compute modulo of two Uint8 values
#### Parameters
##### a
`Uint8Type`
Dividend
##### b
`Uint8Type`
Divisor
#### Returns
`Uint8Type`
Remainder (a % b)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If divisor is zero
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(7);
const remainder = Uint8.modulo(a, b); // 2
```
***
### plus()
> **plus**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/plus.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/plus.js#L20)
Add two Uint8 values with overflow checking
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Sum (a + b)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If result exceeds maximum value
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(100);
const b = Uint8.from(50);
const sum = Uint8.plus(a, b); // 150
```
***
### popCount()
> **popCount**(`uint`): `number`
Defined in: [src/primitives/Uint8/popCount.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/popCount.js#L17)
Count number of set bits (population count) in Uint8 value
#### Parameters
##### uint
`Uint8Type`
Input value
#### Returns
`number`
Number of set bits (0-8)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
Uint8.popCount(Uint8.from(0)); // 0
Uint8.popCount(Uint8.from(255)); // 8
Uint8.popCount(Uint8.from(0b10101010)); // 4
```
***
### shiftLeft()
> **shiftLeft**(`uint`, `shift`): `Uint8Type`
Defined in: [src/primitives/Uint8/shiftLeft.js:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/shiftLeft.js#L19)
Left shift Uint8 value
#### Parameters
##### uint
`Uint8Type`
Value to shift
##### shift
`number`
Number of bits to shift (0-7)
#### Returns
`Uint8Type`
Left-shifted value (masked to 8 bits)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b00001111);
const result = Uint8.shiftLeft(a, 4); // 0b11110000 = 240
```
***
### shiftRight()
> **shiftRight**(`uint`, `shift`): `Uint8Type`
Defined in: [src/primitives/Uint8/shiftRight.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/shiftRight.js#L17)
Right shift Uint8 value (logical shift)
#### Parameters
##### uint
`Uint8Type`
Value to shift
##### shift
`number`
Number of bits to shift (0-7)
#### Returns
`Uint8Type`
Right-shifted value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(0b11110000);
const result = Uint8.shiftRight(a, 4); // 0b00001111 = 15
```
***
### times()
> **times**(`a`, `b`): `Uint8Type`
Defined in: [src/primitives/Uint8/times.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/times.js#L20)
Multiply two Uint8 values with overflow checking
#### Parameters
##### a
`Uint8Type`
First operand
##### b
`Uint8Type`
Second operand
#### Returns
`Uint8Type`
Product (a \* b)
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
If result exceeds maximum value
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const a = Uint8.from(10);
const b = Uint8.from(5);
const product = Uint8.times(a, b); // 50
```
***
### toBigint()
> **toBigint**(`uint`): `bigint`
Defined in: [src/primitives/Uint8/toBigint.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/toBigint.js#L16)
Convert Uint8 to bigint
#### Parameters
##### uint
`Uint8Type`
Uint8 value
#### Returns
`bigint`
bigint value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const bigintValue = Uint8.toBigint(value); // 255n
```
***
### toBytes()
> **toBytes**(`uint`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/Uint8/toBytes.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/toBytes.js#L16)
Convert Uint8 to Uint8Array (1 byte)
#### Parameters
##### uint
`Uint8Type`
Uint8 value
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
Uint8Array of length 1
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const bytes = Uint8.toBytes(value); // Uint8Array([255])
```
***
### toHex()
> **toHex**(`uint`, `padded?`): `string`
Defined in: [src/primitives/Uint8/toHex.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/toHex.js#L21)
Convert Uint8 to hex string
#### Parameters
##### uint
`Uint8Type`
Uint8 value
##### padded?
`boolean` = `true`
Whether to pad to 2 characters (1 byte)
#### Returns
`string`
Hex string with 0x prefix
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const hex1 = Uint8.toHex(value); // "0xff"
const hex2 = Uint8.toHex(value, false); // "0xff"
const value2 = Uint8.from(15);
const hex3 = Uint8.toHex(value2); // "0x0f"
const hex4 = Uint8.toHex(value2, false); // "0xf"
```
***
### toNumber()
> **toNumber**(`uint`): `number`
Defined in: [src/primitives/Uint8/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/toNumber.js#L16)
Convert Uint8 to number
#### Parameters
##### uint
`Uint8Type`
Uint8 value
#### Returns
`number`
number value
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const num = Uint8.toNumber(value); // 255
```
***
### toString()
> **toString**(`uint`): `string`
Defined in: [src/primitives/Uint8/toString.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uint8/toString.js#L17)
Convert Uint8 to decimal string
#### Parameters
##### uint
`Uint8Type`
Uint8 value
#### Returns
`string`
Decimal string representation
#### See
[https://voltaire.tevm.sh/primitives/uint8](https://voltaire.tevm.sh/primitives/uint8) for Uint8 documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Uint8 from './primitives/Uint8/index.js';
const value = Uint8.from(255);
const str = Uint8.toString(value); // "255"
```
# primitives/Uncle
Source: https://voltaire.tevm.sh/generated-api/primitives/Uncle
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Uncle
# primitives/Uncle
## Type Aliases
### UncleType
> **UncleType** = `object`
Defined in: [src/primitives/Uncle/UncleType.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L17)
Uncle (Ommer) block type - represents uncle/ommer block header
Uncle blocks are valid blocks that were mined but not included in the main chain.
They receive reduced rewards and help secure the network.
#### See
* [https://voltaire.tevm.sh/primitives/uncle](https://voltaire.tevm.sh/primitives/uncle) for Uncle documentation
* [https://ethereum.org/en/glossary/#ommer](https://ethereum.org/en/glossary/#ommer) for ommer/uncle definition
#### Since
0.0.0
#### Properties
##### beneficiary
> `readonly` **beneficiary**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Uncle/UncleType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L20)
##### difficulty
> `readonly` **difficulty**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Uncle/UncleType.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L25)
##### extraData
> `readonly` **extraData**: `Uint8Array`
Defined in: [src/primitives/Uncle/UncleType.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L30)
##### gasLimit
> `readonly` **gasLimit**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Uncle/UncleType.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L27)
##### gasUsed
> `readonly` **gasUsed**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Uncle/UncleType.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L28)
##### logsBloom
> `readonly` **logsBloom**: `Uint8Array`
Defined in: [src/primitives/Uncle/UncleType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L24)
##### mixHash
> `readonly` **mixHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L31)
##### nonce
> `readonly` **nonce**: `Uint8Array`
Defined in: [src/primitives/Uncle/UncleType.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L32)
##### number
> `readonly` **number**: [`BlockNumberType`](BlockNumber.mdx#blocknumbertype)
Defined in: [src/primitives/Uncle/UncleType.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L26)
##### ommersHash
> `readonly` **ommersHash**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:19](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L19)
##### parentHash
> `readonly` **parentHash**: [`BlockHashType`](BlockHash.mdx#blockhashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L18)
##### receiptsRoot
> `readonly` **receiptsRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L23)
##### stateRoot
> `readonly` **stateRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L21)
##### timestamp
> `readonly` **timestamp**: [`Type`](Uint.mdx#type)
Defined in: [src/primitives/Uncle/UncleType.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L29)
##### transactionsRoot
> `readonly` **transactionsRoot**: [`HashType`](../index/namespaces/HashType.mdx#hashtype)
Defined in: [src/primitives/Uncle/UncleType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/UncleType.ts#L22)
## Variables
### Uncle
> `const` **Uncle**: `object`
Defined in: [src/primitives/Uncle/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/index.ts#L32)
#### Type Declaration
##### from()
> **from**: (`params`) => [`UncleType`](#uncletype)
###### Parameters
###### params
###### beneficiary
`string` | [`AddressType`](Address.mdx#addresstype)
###### difficulty
`string` | `number` | `bigint`
###### extraData
`Uint8Array`
###### gasLimit
`string` | `number` | `bigint`
###### gasUsed
`string` | `number` | `bigint`
###### logsBloom
`Uint8Array`
###### mixHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### nonce
`Uint8Array`
###### number
`number` | `bigint`
###### ommersHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentHash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### receiptsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### stateRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### timestamp
`string` | `number` | `bigint`
###### transactionsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### Returns
[`UncleType`](#uncletype)
## Functions
### \_from()
> **\_from**(`params`): [`UncleType`](#uncletype)
Defined in: [src/primitives/Uncle/from.js:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/from.js#L53)
Create Uncle from components
#### Parameters
##### params
`UncleParams`
Uncle parameters
#### Returns
[`UncleType`](#uncletype)
Uncle
#### Example
```typescript theme={null}
const uncle = Uncle.from({
parentHash: "0x1234...",
ommersHash: "0x5678...",
beneficiary: "0xabcd...",
stateRoot: "0xef01...",
transactionsRoot: "0x2345...",
receiptsRoot: "0x6789...",
logsBloom: new Uint8Array(256),
difficulty: 0n,
number: 12345n,
gasLimit: 30000000n,
gasUsed: 21000n,
timestamp: 1234567890n,
extraData: new Uint8Array(0),
mixHash: "0xabcd...",
nonce: new Uint8Array(8)
});
```
***
### from()
> **from**(`params`): [`UncleType`](#uncletype)
Defined in: [src/primitives/Uncle/index.ts:11](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Uncle/index.ts#L11)
#### Parameters
##### params
###### beneficiary
`string` | [`AddressType`](Address.mdx#addresstype)
###### difficulty
`string` | `number` | `bigint`
###### extraData
`Uint8Array`
###### gasLimit
`string` | `number` | `bigint`
###### gasUsed
`string` | `number` | `bigint`
###### logsBloom
`Uint8Array`
###### mixHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### nonce
`Uint8Array`
###### number
`number` | `bigint`
###### ommersHash
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### parentHash
`string` | [`BlockHashType`](BlockHash.mdx#blockhashtype)
###### receiptsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### stateRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
###### timestamp
`string` | `number` | `bigint`
###### transactionsRoot
`string` | [`HashType`](../index/namespaces/HashType.mdx#hashtype)
#### Returns
[`UncleType`](#uncletype)
# primitives/UserOperation
Source: https://voltaire.tevm.sh/generated-api/primitives/UserOperation
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/UserOperation
# primitives/UserOperation
## Type Aliases
### UserOperationType
> **UserOperationType** = `object` & `object`
Defined in: [src/primitives/UserOperation/UserOperationType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/UserOperationType.ts#L16)
UserOperation type - ERC-4337 v0.6 format
User operations enable account abstraction by separating transaction validation
from execution. Bundlers aggregate user operations and submit them to the
EntryPoint contract for execution.
#### Type Declaration
##### callData
> `readonly` **callData**: `Uint8Array`
Calldata to execute on the account
##### callGasLimit
> `readonly` **callGasLimit**: [`Type`](Uint.mdx#type)
Gas limit for the execution phase
##### initCode
> `readonly` **initCode**: `Uint8Array`
Account factory and initialization code for first-time deployment
##### maxFeePerGas
> `readonly` **maxFeePerGas**: [`Type`](Uint.mdx#type)
Maximum total fee per gas (EIP-1559)
##### maxPriorityFeePerGas
> `readonly` **maxPriorityFeePerGas**: [`Type`](Uint.mdx#type)
Maximum priority fee per gas (EIP-1559)
##### nonce
> `readonly` **nonce**: [`Type`](Uint.mdx#type)
Anti-replay nonce (key + sequence)
##### paymasterAndData
> `readonly` **paymasterAndData**: `Uint8Array`
Paymaster address and data (empty if self-paying)
##### preVerificationGas
> `readonly` **preVerificationGas**: [`Type`](Uint.mdx#type)
Fixed gas overhead for bundler compensation
##### sender
> `readonly` **sender**: [`AddressType`](Address.mdx#addresstype)
Smart account address initiating the operation
##### signature
> `readonly` **signature**: `Uint8Array`
Account signature over userOpHash
##### verificationGasLimit
> `readonly` **verificationGasLimit**: [`Type`](Uint.mdx#type)
Gas limit for the verification phase
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"UserOperation"`
#### See
* [https://eips.ethereum.org/EIPS/eip-4337](https://eips.ethereum.org/EIPS/eip-4337)
* [https://voltaire.tevm.sh/primitives/user-operation](https://voltaire.tevm.sh/primitives/user-operation) for UserOperation documentation
#### Since
0.0.0
## Variables
### UserOperation
> `const` **UserOperation**: `object`
Defined in: [src/primitives/UserOperation/index.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/index.ts#L32)
#### Type Declaration
##### from()
> **from**: (`params`) => [`UserOperationType`](#useroperationtype)
Create UserOperation from input object
###### Parameters
###### params
UserOperation parameters
###### callData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Calldata to execute
###### callGasLimit
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Gas for execution
###### initCode
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account initialization code
###### maxFeePerGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Max total fee per gas
###### maxPriorityFeePerGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Max priority fee per gas
###### nonce
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Anti-replay nonce
###### paymasterAndData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Paymaster address and data
###### preVerificationGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Fixed gas overhead
###### sender
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Smart account address
###### signature
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account signature
###### verificationGasLimit
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Gas for verification
###### Returns
[`UserOperationType`](#useroperationtype)
UserOperation
###### Example
```typescript theme={null}
const userOp = UserOperation.from({
sender: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
nonce: 0n,
initCode: "0x",
callData: "0x",
callGasLimit: 100000n,
verificationGasLimit: 200000n,
preVerificationGas: 50000n,
maxFeePerGas: 1000000000n,
maxPriorityFeePerGas: 1000000000n,
paymasterAndData: "0x",
signature: "0x",
});
```
##### hash()
> **hash**: (`userOp`, `entryPoint`, `chainId`) => `Uint8Array`
###### Parameters
###### userOp
[`UserOperationType`](#useroperationtype)
###### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
###### chainId
`number` | `bigint`
###### Returns
`Uint8Array`
##### pack()
> **pack**: (`userOp`) => [`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
###### Parameters
###### userOp
[`UserOperationType`](#useroperationtype)
###### Returns
[`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
## Functions
### \_hash()
> **\_hash**(`userOp`, `entryPoint`, `chainId`): `Uint8Array`\<`ArrayBufferLike`>
Defined in: [src/primitives/UserOperation/hash.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/hash.js#L21)
Compute userOpHash for signing
userOpHash = keccak256(abi.encode(userOp, entryPoint, chainId))
#### Parameters
##### userOp
[`UserOperationType`](#useroperationtype)
User operation
##### entryPoint
EntryPoint contract address
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### chainId
Chain ID
`number` | `bigint`
#### Returns
`Uint8Array`\<`ArrayBufferLike`>
32-byte hash for signing
#### Example
```typescript theme={null}
const hash = UserOperation.hash(userOp, ENTRYPOINT_V06, 1n);
const signature = await account.signMessage(hash);
```
***
### \_pack()
> **\_pack**(`userOp`): [`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
Defined in: [src/primitives/UserOperation/pack.js:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/pack.js#L14)
Pack UserOperation (v0.6) to PackedUserOperation (v0.7)
Packs gas limits and fees into bytes32 for v0.7 entry point.
#### Parameters
##### userOp
[`UserOperationType`](#useroperationtype)
User operation v0.6
#### Returns
[`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
Packed user operation v0.7
#### Example
```typescript theme={null}
const packedUserOp = UserOperation.pack(userOp);
```
***
### from()
> **from**(`params`): [`UserOperationType`](#useroperationtype)
Defined in: [src/primitives/UserOperation/from.js:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/from.js#L38)
Create UserOperation from input object
#### Parameters
##### params
UserOperation parameters
###### callData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Calldata to execute
###### callGasLimit
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Gas for execution
###### initCode
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account initialization code
###### maxFeePerGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Max total fee per gas
###### maxPriorityFeePerGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Max priority fee per gas
###### nonce
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Anti-replay nonce
###### paymasterAndData
`string` | `Uint8Array`\<`ArrayBufferLike`>
Paymaster address and data
###### preVerificationGas
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Fixed gas overhead
###### sender
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Smart account address
###### signature
`string` | `Uint8Array`\<`ArrayBufferLike`>
Account signature
###### verificationGasLimit
`string` | `number` | `bigint` | [`Type`](Uint.mdx#type)
Gas for verification
#### Returns
[`UserOperationType`](#useroperationtype)
UserOperation
#### Example
```typescript theme={null}
const userOp = UserOperation.from({
sender: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
nonce: 0n,
initCode: "0x",
callData: "0x",
callGasLimit: 100000n,
verificationGasLimit: 200000n,
preVerificationGas: 50000n,
maxFeePerGas: 1000000000n,
maxPriorityFeePerGas: 1000000000n,
paymasterAndData: "0x",
signature: "0x",
});
```
***
### hash()
> **hash**(`userOp`, `entryPoint`, `chainId`): `Uint8Array`
Defined in: [src/primitives/UserOperation/index.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/index.ts#L16)
#### Parameters
##### userOp
[`UserOperationType`](#useroperationtype)
##### entryPoint
`string` | `number` | `bigint` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
##### chainId
`number` | `bigint`
#### Returns
`Uint8Array`
***
### pack()
> **pack**(`userOp`): [`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
Defined in: [src/primitives/UserOperation/index.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/UserOperation/index.ts#L24)
#### Parameters
##### userOp
[`UserOperationType`](#useroperationtype)
#### Returns
[`PackedUserOperationType`](PackedUserOperation.mdx#packeduseroperationtype)
# primitives/ValidatorIndex
Source: https://voltaire.tevm.sh/generated-api/primitives/ValidatorIndex
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/ValidatorIndex
# primitives/ValidatorIndex
## Type Aliases
### ValidatorIndexType
> **ValidatorIndexType** = `number` & `object`
Defined in: [src/primitives/ValidatorIndex/ValidatorIndexType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ValidatorIndex/ValidatorIndexType.ts#L13)
ValidatorIndex type
Represents a validator's index in the beacon state registry.
Each validator has a unique, immutable index assigned when they activate.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ValidatorIndex"`
#### See
* [https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
* [https://github.com/ethereum/consensus-specs](https://github.com/ethereum/consensus-specs) for Consensus specifications
#### Since
0.0.0
## Variables
### ValidatorIndex
> `const` **ValidatorIndex**: `object`
Defined in: [src/primitives/ValidatorIndex/index.ts:9](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ValidatorIndex/index.ts#L9)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if ValidatorIndex values are equal
###### Parameters
###### a
[`ValidatorIndexType`](#validatorindextype)
First validator index
###### b
[`ValidatorIndexType`](#validatorindextype)
Second validator index
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const a = ValidatorIndex.from(123456);
const b = ValidatorIndex.from(123456);
const result = ValidatorIndex.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`ValidatorIndexType`](#validatorindextype)
Create ValidatorIndex from number, bigint, or string
###### Parameters
###### value
Validator index (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
###### Returns
[`ValidatorIndexType`](#validatorindextype)
ValidatorIndex value
###### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
###### Since
0.0.0
###### Throws
If value is negative, not an integer, or out of range
###### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const idx1 = ValidatorIndex.from(123456);
const idx2 = ValidatorIndex.from(123456n);
const idx3 = ValidatorIndex.from("0x1e240");
```
##### toNumber()
> **toNumber**: (`index`) => `number`
Convert ValidatorIndex to number
###### Parameters
###### index
[`ValidatorIndexType`](#validatorindextype)
ValidatorIndex value
###### Returns
`number`
Number representation
###### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const idx = ValidatorIndex.from(123456);
const num = ValidatorIndex.toNumber(idx); // 123456
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/ValidatorIndex/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ValidatorIndex/equals.js#L18)
Check if ValidatorIndex values are equal
#### Parameters
##### a
[`ValidatorIndexType`](#validatorindextype)
First validator index
##### b
[`ValidatorIndexType`](#validatorindextype)
Second validator index
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const a = ValidatorIndex.from(123456);
const b = ValidatorIndex.from(123456);
const result = ValidatorIndex.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`ValidatorIndexType`](#validatorindextype)
Defined in: [src/primitives/ValidatorIndex/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ValidatorIndex/from.js#L17)
Create ValidatorIndex from number, bigint, or string
#### Parameters
##### value
Validator index (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
#### Returns
[`ValidatorIndexType`](#validatorindextype)
ValidatorIndex value
#### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
#### Since
0.0.0
#### Throws
If value is negative, not an integer, or out of range
#### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const idx1 = ValidatorIndex.from(123456);
const idx2 = ValidatorIndex.from(123456n);
const idx3 = ValidatorIndex.from("0x1e240");
```
***
### toNumber()
> **toNumber**(`index`): `number`
Defined in: [src/primitives/ValidatorIndex/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/ValidatorIndex/toNumber.js#L16)
Convert ValidatorIndex to number
#### Parameters
##### index
[`ValidatorIndexType`](#validatorindextype)
ValidatorIndex value
#### Returns
`number`
Number representation
#### See
[https://voltaire.tevm.sh/primitives/validator-index](https://voltaire.tevm.sh/primitives/validator-index) for ValidatorIndex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as ValidatorIndex from './primitives/ValidatorIndex/index.js';
const idx = ValidatorIndex.from(123456);
const num = ValidatorIndex.toNumber(idx); // 123456
```
# primitives/Withdrawal
Source: https://voltaire.tevm.sh/generated-api/primitives/Withdrawal
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/Withdrawal
# primitives/Withdrawal
## Type Aliases
### WithdrawalType
> **WithdrawalType** = `object`
Defined in: [src/primitives/Withdrawal/WithdrawalType.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/WithdrawalType.ts#L16)
Withdrawal type - represents Ethereum withdrawal (post-merge)
Post-merge (Shanghai/Capella upgrade) withdrawal from beacon chain
validators to execution layer accounts
#### See
* [https://voltaire.tevm.sh/primitives/withdrawal](https://voltaire.tevm.sh/primitives/withdrawal) for Withdrawal documentation
* [https://eips.ethereum.org/EIPS/eip-4895](https://eips.ethereum.org/EIPS/eip-4895) for EIP-4895 specification
#### Since
0.0.0
#### Properties
##### address
> `readonly` **address**: [`AddressType`](Address.mdx#addresstype)
Defined in: [src/primitives/Withdrawal/WithdrawalType.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/WithdrawalType.ts#L22)
Address receiving withdrawal
##### amount
> `readonly` **amount**: [`GweiType`](../index/namespaces/BrandedGwei.mdx#gweitype)
Defined in: [src/primitives/Withdrawal/WithdrawalType.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/WithdrawalType.ts#L24)
Amount in Gwei
##### index
> `readonly` **index**: [`WithdrawalIndexType`](WithdrawalIndex.mdx#withdrawalindextype)
Defined in: [src/primitives/Withdrawal/WithdrawalType.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/WithdrawalType.ts#L18)
Withdrawal index (monotonically increasing)
##### validatorIndex
> `readonly` **validatorIndex**: [`ValidatorIndexType`](ValidatorIndex.mdx#validatorindextype)
Defined in: [src/primitives/Withdrawal/WithdrawalType.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/WithdrawalType.ts#L20)
Validator index on beacon chain
## Variables
### Withdrawal
> `const` **Withdrawal**: `object`
Defined in: [src/primitives/Withdrawal/index.ts:8](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/index.ts#L8)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if Withdrawal values are equal
###### Parameters
###### a
[`WithdrawalType`](#withdrawaltype)
First withdrawal
###### b
[`WithdrawalType`](#withdrawaltype)
Second withdrawal
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/withdrawal](https://voltaire.tevm.sh/primitives/withdrawal) for Withdrawal documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as Withdrawal from './primitives/Withdrawal/index.js';
const a = Withdrawal.from({ index: 1n, validatorIndex: 1, address: "0x...", amount: 100n });
const b = Withdrawal.from({ index: 1n, validatorIndex: 1, address: "0x...", amount: 100n });
const result = Withdrawal.equals(a, b); // true
```
##### from()
> **from**: (`params`) => [`WithdrawalType`](#withdrawaltype)
Create Withdrawal from components
###### Parameters
###### params
Withdrawal parameters
###### address
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Withdrawal recipient address
###### amount
`string` | `number` | `bigint` | [`GweiType`](../index/namespaces/BrandedGwei.mdx#gweitype)
Amount in Gwei
###### index
`string` | `number` | `bigint` | [`WithdrawalIndexType`](WithdrawalIndex.mdx#withdrawalindextype)
Global withdrawal counter
###### validatorIndex
`string` | `number` | `bigint` | [`ValidatorIndexType`](ValidatorIndex.mdx#validatorindextype)
Validator index
###### Returns
[`WithdrawalType`](#withdrawaltype)
Withdrawal
###### See
[https://voltaire.tevm.sh/primitives/withdrawal](https://voltaire.tevm.sh/primitives/withdrawal) for Withdrawal documentation
###### Since
0.0.0
###### Throws
If any parameter is invalid
###### Example
```javascript theme={null}
import * as Withdrawal from './primitives/Withdrawal/index.js';
const withdrawal = Withdrawal.from({
index: 1000000n,
validatorIndex: 123456,
address: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
amount: 32000000000n, // 32 ETH in Gwei
});
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/Withdrawal/equals.js:21](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/equals.js#L21)
Check if Withdrawal values are equal
#### Parameters
##### a
[`WithdrawalType`](#withdrawaltype)
First withdrawal
##### b
[`WithdrawalType`](#withdrawaltype)
Second withdrawal
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/withdrawal](https://voltaire.tevm.sh/primitives/withdrawal) for Withdrawal documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as Withdrawal from './primitives/Withdrawal/index.js';
const a = Withdrawal.from({ index: 1n, validatorIndex: 1, address: "0x...", amount: 100n });
const b = Withdrawal.from({ index: 1n, validatorIndex: 1, address: "0x...", amount: 100n });
const result = Withdrawal.equals(a, b); // true
```
***
### from()
> **from**(`params`): [`WithdrawalType`](#withdrawaltype)
Defined in: [src/primitives/Withdrawal/from.js:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/Withdrawal/from.js#L29)
Create Withdrawal from components
#### Parameters
##### params
Withdrawal parameters
###### address
`string` | `Uint8Array`\<`ArrayBufferLike`> | [`AddressType`](Address.mdx#addresstype)
Withdrawal recipient address
###### amount
`string` | `number` | `bigint` | [`GweiType`](../index/namespaces/BrandedGwei.mdx#gweitype)
Amount in Gwei
###### index
`string` | `number` | `bigint` | [`WithdrawalIndexType`](WithdrawalIndex.mdx#withdrawalindextype)
Global withdrawal counter
###### validatorIndex
`string` | `number` | `bigint` | [`ValidatorIndexType`](ValidatorIndex.mdx#validatorindextype)
Validator index
#### Returns
[`WithdrawalType`](#withdrawaltype)
Withdrawal
#### See
[https://voltaire.tevm.sh/primitives/withdrawal](https://voltaire.tevm.sh/primitives/withdrawal) for Withdrawal documentation
#### Since
0.0.0
#### Throws
If any parameter is invalid
#### Example
```javascript theme={null}
import * as Withdrawal from './primitives/Withdrawal/index.js';
const withdrawal = Withdrawal.from({
index: 1000000n,
validatorIndex: 123456,
address: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
amount: 32000000000n, // 32 ETH in Gwei
});
```
# primitives/WithdrawalIndex
Source: https://voltaire.tevm.sh/generated-api/primitives/WithdrawalIndex
Auto-generated API documentation
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / primitives/WithdrawalIndex
# primitives/WithdrawalIndex
## Type Aliases
### WithdrawalIndexType
> **WithdrawalIndexType** = `bigint` & `object`
Defined in: [src/primitives/WithdrawalIndex/WithdrawalIndexType.ts:13](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/WithdrawalIndexType.ts#L13)
WithdrawalIndex type
Represents the global withdrawal counter in the beacon chain (EIP-4895).
This counter increments monotonically for each withdrawal processed.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"WithdrawalIndex"`
#### See
* [https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
* [https://eips.ethereum.org/EIPS/eip-4895](https://eips.ethereum.org/EIPS/eip-4895) for EIP-4895 specification
#### Since
0.0.0
## Variables
### WithdrawalIndex
> `const` **WithdrawalIndex**: `object`
Defined in: [src/primitives/WithdrawalIndex/index.ts:10](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/index.ts#L10)
#### Type Declaration
##### equals()
> **equals**: (`a`, `b`) => `boolean`
Check if WithdrawalIndex values are equal
###### Parameters
###### a
[`WithdrawalIndexType`](#withdrawalindextype)
First withdrawal index
###### b
[`WithdrawalIndexType`](#withdrawalindextype)
Second withdrawal index
###### Returns
`boolean`
true if equal
###### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const a = WithdrawalIndex.from(1000000n);
const b = WithdrawalIndex.from(1000000n);
const result = WithdrawalIndex.equals(a, b); // true
```
##### from()
> **from**: (`value`) => [`WithdrawalIndexType`](#withdrawalindextype)
Create WithdrawalIndex from number, bigint, or string
###### Parameters
###### value
Withdrawal index (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
###### Returns
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
###### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
###### Since
0.0.0
###### Throws
If value is negative or invalid
###### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx1 = WithdrawalIndex.from(1000000n);
const idx2 = WithdrawalIndex.from(1000000);
const idx3 = WithdrawalIndex.from("0xf4240");
```
##### toBigInt()
> **toBigInt**: (`index`) => `bigint`
Convert WithdrawalIndex to bigint
###### Parameters
###### index
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
###### Returns
`bigint`
BigInt representation
###### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
###### Since
0.0.0
###### Throws
###### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx = WithdrawalIndex.from(1000000);
const big = WithdrawalIndex.toBigInt(idx); // 1000000n
```
##### toNumber()
> **toNumber**: (`index`) => `number`
Convert WithdrawalIndex to number
###### Parameters
###### index
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
###### Returns
`number`
Number representation
###### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
###### Since
0.0.0
###### Throws
If index exceeds safe integer range
###### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx = WithdrawalIndex.from(1000000n);
const num = WithdrawalIndex.toNumber(idx); // 1000000
```
## Functions
### equals()
> **equals**(`a`, `b`): `boolean`
Defined in: [src/primitives/WithdrawalIndex/equals.js:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/equals.js#L18)
Check if WithdrawalIndex values are equal
#### Parameters
##### a
[`WithdrawalIndexType`](#withdrawalindextype)
First withdrawal index
##### b
[`WithdrawalIndexType`](#withdrawalindextype)
Second withdrawal index
#### Returns
`boolean`
true if equal
#### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const a = WithdrawalIndex.from(1000000n);
const b = WithdrawalIndex.from(1000000n);
const result = WithdrawalIndex.equals(a, b); // true
```
***
### from()
> **from**(`value`): [`WithdrawalIndexType`](#withdrawalindextype)
Defined in: [src/primitives/WithdrawalIndex/from.js:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/from.js#L17)
Create WithdrawalIndex from number, bigint, or string
#### Parameters
##### value
Withdrawal index (number, bigint, or decimal/hex string)
`string` | `number` | `bigint`
#### Returns
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
#### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
#### Since
0.0.0
#### Throws
If value is negative or invalid
#### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx1 = WithdrawalIndex.from(1000000n);
const idx2 = WithdrawalIndex.from(1000000);
const idx3 = WithdrawalIndex.from("0xf4240");
```
***
### toBigInt()
> **toBigInt**(`index`): `bigint`
Defined in: [src/primitives/WithdrawalIndex/toBigInt.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/toBigInt.js#L16)
Convert WithdrawalIndex to bigint
#### Parameters
##### index
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
#### Returns
`bigint`
BigInt representation
#### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
#### Since
0.0.0
#### Throws
#### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx = WithdrawalIndex.from(1000000);
const big = WithdrawalIndex.toBigInt(idx); // 1000000n
```
***
### toNumber()
> **toNumber**(`index`): `number`
Defined in: [src/primitives/WithdrawalIndex/toNumber.js:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/WithdrawalIndex/toNumber.js#L16)
Convert WithdrawalIndex to number
#### Parameters
##### index
[`WithdrawalIndexType`](#withdrawalindextype)
WithdrawalIndex value
#### Returns
`number`
Number representation
#### See
[https://voltaire.tevm.sh/primitives/withdrawal-index](https://voltaire.tevm.sh/primitives/withdrawal-index) for WithdrawalIndex documentation
#### Since
0.0.0
#### Throws
If index exceeds safe integer range
#### Example
```javascript theme={null}
import * as WithdrawalIndex from './primitives/WithdrawalIndex/index.js';
const idx = WithdrawalIndex.from(1000000n);
const num = WithdrawalIndex.toNumber(idx); // 1000000
```
# Generated API Reference
Source: https://voltaire.tevm.sh/generated-api/provider/index
Auto-generated TypeScript API documentation from source code
[**@tevm/voltaire**](../index.mdx)
***
[@tevm/voltaire](../index.mdx) / provider
# provider
Provider - EIP-1193 Compliant Ethereum JSON-RPC Provider
EIP-1193 compliant provider implementations for Ethereum JSON-RPC communication.
Supports HTTP, WebSocket, and in-memory (EVM-based) transports.
## Features
* **EIP-1193 compliant** - Single `request()` method for all RPC calls
* **Strongly typed** - Full type safety with RpcSchema support
* **EventEmitter** - Standard event handling for blockchain events
* **Throws on error** - Clean error handling with RpcError
* **Multiple transports** - HTTP, WebSocket, or in-memory execution
## Quick Start
```typescript theme={null}
import { HttpProvider } from '@tevm/voltaire/provider';
const provider = new HttpProvider('https://eth.example.com');
// Make requests
const blockNumber = await provider.request({
method: 'eth_blockNumber',
params: []
});
// Listen to events
provider.on('chainChanged', (chainId) => {
console.log('Chain changed:', chainId);
});
```
## Available Providers
* **HttpProvider** - HTTP transport with EventEmitter
* **WebSocketProvider** - WebSocket transport with native pub/sub
* **InMemoryProvider** - Local EVM execution (coming with EVM docs)
## See
[https://voltaire.tevm.sh/provider](https://voltaire.tevm.sh/provider) for full documentation
## Namespaces
* [provider/eip6963](namespaces/provider/eip6963.mdx)
## Enumerations
### ProviderRpcErrorCode
Defined in: [src/provider/types.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L34)
EIP-1193 error codes
#### Enumeration Members
##### ChainDisconnected
> **ChainDisconnected**: `4901`
Defined in: [src/provider/types.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L44)
Provider disconnected from all chains
##### Disconnected
> **Disconnected**: `4900`
Defined in: [src/provider/types.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L42)
Provider disconnected from chains
##### Unauthorized
> **Unauthorized**: `4100`
Defined in: [src/provider/types.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L38)
Requested method/account not authorized
##### UnsupportedMethod
> **UnsupportedMethod**: `4200`
Defined in: [src/provider/types.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L40)
Provider doesn't support requested method
##### UserRejectedRequest
> **UserRejectedRequest**: `4001`
Defined in: [src/provider/types.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L36)
User rejected request
## Classes
### HttpProvider
Defined in: [src/provider/HttpProvider.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L64)
HTTP Provider implementation
EIP-1193 compliant provider using HTTP transport via fetch API.
Throws RpcError on failures.
#### Example
```typescript theme={null}
const provider = new HttpProvider({
url: 'https://eth.example.com',
timeout: 30000
});
const blockNumber = await provider.request({
method: 'eth_blockNumber',
params: []
});
```
#### Implements
* [`Provider`](#provider)
#### Constructors
##### Constructor
> **new HttpProvider**(`options`): [`HttpProvider`](#httpprovider)
Defined in: [src/provider/HttpProvider.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L74)
###### Parameters
###### options
`string` | [`HttpProviderOptions`](#httpprovideroptions)
###### Returns
[`HttpProvider`](#httpprovider)
#### Methods
##### on()
> **on**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/HttpProvider.ts:189](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L189)
Register event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`on`](#on-8)
##### removeListener()
> **removeListener**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/HttpProvider.ts:203](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L203)
Remove event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`removeListener`](#removelistener-8)
##### request()
> **request**(`args`): `Promise`\<`unknown`>
Defined in: [src/provider/HttpProvider.ts:151](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L151)
EIP-1193 request method
Submits JSON-RPC request and returns result or throws RpcError
###### Parameters
###### args
[`LegacyRequestArguments`](#legacyrequestarguments)
###### Returns
`Promise`\<`unknown`>
###### Implementation of
[`Provider`](#provider).[`request`](#request-6)
***
### InMemoryProvider
Defined in: [src/provider/InMemoryProvider.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L138)
In-Memory Provider implementation
Provides a fully functional in-memory Ethereum node for testing and development.
Uses Voltaire's EVM for transaction execution.
## Features
* **Local EVM execution** - Full transaction simulation without external node
* **State management** - In-memory state with snapshot/revert capabilities
* **Instant mining** - Configurable block production (auto/interval/manual)
* **Testing utilities** - Set balances, impersonate accounts, manipulate time
* **Zero latency** - No network requests, instant responses
#### Example
```typescript theme={null}
const provider = new InMemoryProvider({
chainId: 1,
accounts: [
{
address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
balance: '0x10000000000000000000000' // 100000 ETH
}
]
});
// Execute calls against local EVM
const result = await provider.request({
method: 'eth_call',
params: [{ to: '0x...', data: '0x...' }, 'latest']
});
```
#### Implements
* [`Provider`](#provider)
#### Constructors
##### Constructor
> **new InMemoryProvider**(`options`): [`InMemoryProvider`](#inmemoryprovider)
Defined in: [src/provider/InMemoryProvider.ts:183](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L183)
###### Parameters
###### options
[`InMemoryProviderOptions`](#inmemoryprovideroptions) = `{}`
###### Returns
[`InMemoryProvider`](#inmemoryprovider)
#### Properties
##### events
> **events**: `ProviderEvents`
Defined in: [src/provider/InMemoryProvider.ts:1112](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L1112)
#### Methods
##### destroy()
> **destroy**(): `void`
Defined in: [src/provider/InMemoryProvider.ts:1104](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L1104)
Cleanup resources
###### Returns
`void`
##### on()
> **on**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/InMemoryProvider.ts:1064](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L1064)
Register event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`on`](#on-8)
##### removeListener()
> **removeListener**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/InMemoryProvider.ts:1078](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L1078)
Remove event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`removeListener`](#removelistener-8)
##### request()
> **request**(`args`): `Promise`\<`unknown`>
Defined in: [src/provider/InMemoryProvider.ts:578](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L578)
EIP-1193 request method
###### Parameters
###### args
[`LegacyRequestArguments`](#legacyrequestarguments)
###### Returns
`Promise`\<`unknown`>
###### Implementation of
[`Provider`](#provider).[`request`](#request-6)
***
### ProviderRpcError
Defined in: [src/provider/events/ProviderRpcError.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L28)
Provider RPC error
Extends Error with numeric code and optional data.
Codes follow EIP-1193 and JSON-RPC 2.0 specifications.
#### Example
```typescript theme={null}
// Standard EIP-1193 error
throw new ProviderRpcError(4001, 'User rejected request');
// With additional data
throw new ProviderRpcError(
4200,
'Unsupported method',
{ method: 'eth_customMethod' }
);
```
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new ProviderRpcError**(`code`, `message`, `data?`): [`ProviderRpcError`](#providerrpcerror)
Defined in: [src/provider/events/ProviderRpcError.ts:35](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L35)
###### Parameters
###### code
`number`
###### message
`string`
###### data?
`unknown`
###### Returns
[`ProviderRpcError`](#providerrpcerror)
###### Overrides
`Error.constructor`
#### Properties
##### code
> **code**: `number`
Defined in: [src/provider/events/ProviderRpcError.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L30)
Numeric error code (EIP-1193 or JSON-RPC 2.0)
##### data?
> `optional` **data**: `unknown`
Defined in: [src/provider/events/ProviderRpcError.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L33)
Optional error data
***
### WebSocketProvider
Defined in: [src/provider/WebSocketProvider.ts:55](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L55)
WebSocket Provider implementation
Implements Provider interface using WebSocket transport for real-time
communication. Supports native pub/sub subscriptions for events.
#### Example
```typescript theme={null}
const provider = new WebSocketProvider({
url: 'wss://eth.example.com',
reconnect: true
});
await provider.connect();
const blockNumber = await provider.eth_blockNumber();
console.log('Block:', blockNumber.result);
```
#### Implements
* [`Provider`](#provider)
#### Constructors
##### Constructor
> **new WebSocketProvider**(`options`): [`WebSocketProvider`](#websocketprovider)
Defined in: [src/provider/WebSocketProvider.ts:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L74)
###### Parameters
###### options
`string` | [`WebSocketProviderOptions`](#websocketprovideroptions)
###### Returns
[`WebSocketProvider`](#websocketprovider)
#### Properties
##### events
> **events**: `ProviderEvents`
Defined in: [src/provider/WebSocketProvider.ts:822](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L822)
#### Methods
##### connect()
> **connect**(): `Promise`\<`void`>
Defined in: [src/provider/WebSocketProvider.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L92)
Connect to WebSocket server
###### Returns
`Promise`\<`void`>
##### debug\_getRawBlock()
> **debug\_getRawBlock**(`blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:669](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L669)
###### Parameters
###### blockTag
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### debug\_traceBlockByHash()
> **debug\_traceBlockByHash**(`blockHash`, `traceOptions?`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:643](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L643)
###### Parameters
###### blockHash
`string`
###### traceOptions?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### debug\_traceBlockByNumber()
> **debug\_traceBlockByNumber**(`blockTag`, `traceOptions?`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:632](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L632)
###### Parameters
###### blockTag
`string`
###### traceOptions?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### debug\_traceCall()
> **debug\_traceCall**(`params`, `blockTag`, `traceOptions?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:654](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L654)
###### Parameters
###### params
`any`
###### blockTag
`string` = `"latest"`
###### traceOptions?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### debug\_traceTransaction()
> **debug\_traceTransaction**(`txHash`, `traceOptions?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:621](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L621)
###### Parameters
###### txHash
`string`
###### traceOptions?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### disconnect()
> **disconnect**(): `void`
Defined in: [src/provider/WebSocketProvider.ts:178](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L178)
Disconnect from WebSocket server
###### Returns
`void`
##### engine\_exchangeCapabilities()
> **engine\_exchangeCapabilities**(`capabilities`, `options?`): `Promise`\<`Response`\<`string`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:769](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L769)
###### Parameters
###### capabilities
`string`\[]
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`\[]>>
##### engine\_exchangeTransitionConfigurationV1()
> **engine\_exchangeTransitionConfigurationV1**(`config`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:780](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L780)
###### Parameters
###### config
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_forkchoiceUpdatedV1()
> **engine\_forkchoiceUpdatedV1**(`forkchoiceState`, `payloadAttributes?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:703](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L703)
###### Parameters
###### forkchoiceState
`any`
###### payloadAttributes?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_forkchoiceUpdatedV2()
> **engine\_forkchoiceUpdatedV2**(`forkchoiceState`, `payloadAttributes?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:717](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L717)
###### Parameters
###### forkchoiceState
`any`
###### payloadAttributes?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_forkchoiceUpdatedV3()
> **engine\_forkchoiceUpdatedV3**(`forkchoiceState`, `payloadAttributes?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:731](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L731)
###### Parameters
###### forkchoiceState
`any`
###### payloadAttributes?
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_getBlobsV1()
> **engine\_getBlobsV1**(`blobVersionedHashes`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:760](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L760)
###### Parameters
###### blobVersionedHashes
`string`\[]
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### engine\_getPayloadBodiesByHashV1()
> **engine\_getPayloadBodiesByHashV1**(`blockHashes`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:793](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L793)
###### Parameters
###### blockHashes
`string`\[]
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### engine\_getPayloadBodiesByRangeV1()
> **engine\_getPayloadBodiesByRangeV1**(`start`, `count`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:805](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L805)
###### Parameters
###### start
`string`
###### count
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### engine\_getPayloadV1()
> **engine\_getPayloadV1**(`payloadId`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:745](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L745)
###### Parameters
###### payloadId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_getPayloadV2()
> **engine\_getPayloadV2**(`payloadId`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:750](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L750)
###### Parameters
###### payloadId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_getPayloadV3()
> **engine\_getPayloadV3**(`payloadId`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:755](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L755)
###### Parameters
###### payloadId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_newPayloadV1()
> **engine\_newPayloadV1**(`payload`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:678](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L678)
###### Parameters
###### payload
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_newPayloadV2()
> **engine\_newPayloadV2**(`payload`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:684](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L684)
###### Parameters
###### payload
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### engine\_newPayloadV3()
> **engine\_newPayloadV3**(`payload`, `expectedBlobVersionedHashes?`, `parentBeaconBlockRoot?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:689](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L689)
###### Parameters
###### payload
`any`
###### expectedBlobVersionedHashes?
`string`\[]
###### parentBeaconBlockRoot?
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_accounts()
> **eth\_accounts**(`options?`): `Promise`\<`Response`\<`string`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:326](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L326)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`\[]>>
##### eth\_blobBaseFee()
> **eth\_blobBaseFee**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:330](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L330)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_blockNumber()
> **eth\_blockNumber**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:334](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L334)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_call()
> **eth\_call**(`params`, `blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:339](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L339)
###### Parameters
###### params
`any`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_chainId()
> **eth\_chainId**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:343](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L343)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_coinbase()
> **eth\_coinbase**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:347](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L347)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_createAccessList()
> **eth\_createAccessList**(`params`, `blockTag`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:351](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L351)
###### Parameters
###### params
`any`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_estimateGas()
> **eth\_estimateGas**(`params`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:366](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L366)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_feeHistory()
> **eth\_feeHistory**(`blockCount`, `newestBlock`, `rewardPercentiles?`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:370](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L370)
###### Parameters
###### blockCount
`string`
###### newestBlock
`string`
###### rewardPercentiles?
`number`\[]
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_gasPrice()
> **eth\_gasPrice**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:383](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L383)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getBalance()
> **eth\_getBalance**(`address`, `blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:387](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L387)
###### Parameters
###### address
`string`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getBlockByHash()
> **eth\_getBlockByHash**(`blockHash`, `fullTransactions`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:399](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L399)
###### Parameters
###### blockHash
`string`
###### fullTransactions
`boolean` = `false`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getBlockByNumber()
> **eth\_getBlockByNumber**(`blockTag`, `fullTransactions`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:412](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L412)
###### Parameters
###### blockTag
`string`
###### fullTransactions
`boolean` = `false`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getBlockReceipts()
> **eth\_getBlockReceipts**(`blockTag`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:425](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L425)
###### Parameters
###### blockTag
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### eth\_getBlockTransactionCountByHash()
> **eth\_getBlockTransactionCountByHash**(`blockHash`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:430](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L430)
###### Parameters
###### blockHash
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getBlockTransactionCountByNumber()
> **eth\_getBlockTransactionCountByNumber**(`blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:441](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L441)
###### Parameters
###### blockTag
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getCode()
> **eth\_getCode**(`address`, `blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:452](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L452)
###### Parameters
###### address
`string`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getFilterChanges()
> **eth\_getFilterChanges**(`filterId`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:456](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L456)
###### Parameters
###### filterId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### eth\_getFilterLogs()
> **eth\_getFilterLogs**(`filterId`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:461](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L461)
###### Parameters
###### filterId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### eth\_getLogs()
> **eth\_getLogs**(`params`, `options?`): `Promise`\<`Response`\<`any`\[]>>
Defined in: [src/provider/WebSocketProvider.ts:467](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L467)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`\[]>>
##### eth\_getProof()
> **eth\_getProof**(`address`, `storageKeys`, `blockTag`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:472](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L472)
###### Parameters
###### address
`string`
###### storageKeys
`string`\[]
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getStorageAt()
> **eth\_getStorageAt**(`address`, `position`, `blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:486](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L486)
###### Parameters
###### address
`string`
###### position
`string`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getTransactionByBlockHashAndIndex()
> **eth\_getTransactionByBlockHashAndIndex**(`blockHash`, `index`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:499](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L499)
###### Parameters
###### blockHash
`string`
###### index
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getTransactionByBlockNumberAndIndex()
> **eth\_getTransactionByBlockNumberAndIndex**(`blockTag`, `index`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:512](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L512)
###### Parameters
###### blockTag
`string`
###### index
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getTransactionByHash()
> **eth\_getTransactionByHash**(`txHash`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:525](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L525)
###### Parameters
###### txHash
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getTransactionCount()
> **eth\_getTransactionCount**(`address`, `blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:530](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L530)
###### Parameters
###### address
`string`
###### blockTag
`string` = `"latest"`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getTransactionReceipt()
> **eth\_getTransactionReceipt**(`txHash`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:542](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L542)
###### Parameters
###### txHash
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_getUncleCountByBlockHash()
> **eth\_getUncleCountByBlockHash**(`blockHash`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:547](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L547)
###### Parameters
###### blockHash
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_getUncleCountByBlockNumber()
> **eth\_getUncleCountByBlockNumber**(`blockTag`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:555](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L555)
###### Parameters
###### blockTag
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_maxPriorityFeePerGas()
> **eth\_maxPriorityFeePerGas**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:563](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L563)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_newBlockFilter()
> **eth\_newBlockFilter**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:567](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L567)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_newFilter()
> **eth\_newFilter**(`params`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:572](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L572)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_newPendingTransactionFilter()
> **eth\_newPendingTransactionFilter**(`options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:576](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L576)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_sendRawTransaction()
> **eth\_sendRawTransaction**(`signedTx`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:584](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L584)
###### Parameters
###### signedTx
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_sendTransaction()
> **eth\_sendTransaction**(`params`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:589](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L589)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_sign()
> **eth\_sign**(`address`, `data`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:593](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L593)
###### Parameters
###### address
`string`
###### data
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_signTransaction()
> **eth\_signTransaction**(`params`, `options?`): `Promise`\<`Response`\<`string`>>
Defined in: [src/provider/WebSocketProvider.ts:598](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L598)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`string`>>
##### eth\_simulateV1()
> **eth\_simulateV1**(`params`, `options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:603](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L603)
###### Parameters
###### params
`any`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_syncing()
> **eth\_syncing**(`options?`): `Promise`\<`Response`\<`any`>>
Defined in: [src/provider/WebSocketProvider.ts:608](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L608)
###### Parameters
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`any`>>
##### eth\_uninstallFilter()
> **eth\_uninstallFilter**(`filterId`, `options?`): `Promise`\<`Response`\<`boolean`>>
Defined in: [src/provider/WebSocketProvider.ts:613](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L613)
###### Parameters
###### filterId
`string`
###### options?
[`RequestOptions`](#requestoptions)
###### Returns
`Promise`\<`Response`\<`boolean`>>
##### on()
> **on**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/WebSocketProvider.ts:283](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L283)
Register event listener (EIP-1193)
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`on`](#on-8)
##### removeListener()
> **removeListener**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/WebSocketProvider.ts:298](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L298)
Remove event listener (EIP-1193)
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
###### listener
(...`args`) => `void`
###### Returns
`this`
###### Implementation of
[`Provider`](#provider).[`removeListener`](#removelistener-8)
##### request()
> **request**(`args`): `Promise`\<`unknown`>
Defined in: [src/provider/WebSocketProvider.ts:194](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L194)
EIP-1193 request method (public interface)
Submits JSON-RPC request and returns result or throws RpcError
###### Parameters
###### args
[`LegacyRequestArguments`](#legacyrequestarguments)
###### Returns
`Promise`\<`unknown`>
###### Implementation of
[`Provider`](#provider).[`request`](#request-6)
## Interfaces
### EIP1193EventEmitter
Defined in: [src/provider/events/EIP1193Events.ts:123](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L123)
Generic event emitter interface
#### Type Parameters
##### TEventMap
`TEventMap` *extends* `Record`\<`string`, (...`args`) => `void`> = [`EIP1193EventMap`](#eip1193eventmap)
Event map defining available events
#### Methods
##### emit()
> **emit**(`eventName`, ...`args`): `boolean`
Defined in: [src/provider/events/EIP1193Events.ts:148](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L148)
**`Internal`**
Emit event (internal use)
###### Parameters
###### eventName
keyof `TEventMap`
###### args
...`any`\[]
###### Returns
`boolean`
##### on()
> **on**\<`TEvent`>(`event`, `listener`): `this`
Defined in: [src/provider/events/EIP1193Events.ts:130](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L130)
Register event listener
###### Type Parameters
###### TEvent
`TEvent` *extends* `string` | `number` | `symbol`
###### Parameters
###### event
`TEvent`
###### listener
`TEventMap`\[`TEvent`]
###### Returns
`this`
##### removeListener()
> **removeListener**\<`TEvent`>(`event`, `listener`): `this`
Defined in: [src/provider/events/EIP1193Events.ts:138](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L138)
Remove event listener
###### Type Parameters
###### TEvent
`TEvent` *extends* `string` | `number` | `symbol`
###### Parameters
###### event
`TEvent`
###### listener
`TEventMap`\[`TEvent`]
###### Returns
`this`
***
### EIP1193EventMap
Defined in: [src/provider/events/EIP1193Events.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L38)
Standard EIP-1193 event map
Defines the five standard events specified in EIP-1193.
Providers MAY extend this with custom events.
#### Example
```typescript theme={null}
// Standard events only
type StandardProvider = {
on(
event: TEvent,
listener: EIP1193EventMap[TEvent]
): void;
};
// Extended events
type ExtendedEventMap = EIP1193EventMap & {
newBlock(block: Block): void;
newTransaction(tx: Transaction): void;
};
```
#### Extends
* `Record`\<`string`, (...`args`) => `void`>
#### Indexable
\[`key`: `string`]: (...`args`) => `void`
#### Methods
##### accountsChanged()
> **accountsChanged**(`accounts`): `void`
Defined in: [src/provider/events/EIP1193Events.ts:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L99)
Emitted when available accounts change
###### Parameters
###### accounts
`string`\[]
New accounts array (per eth\_accounts)
###### Returns
`void`
###### Example
```typescript theme={null}
provider.on('accountsChanged', (accounts) => {
if (accounts.length === 0) {
console.log('Disconnected');
} else {
console.log('Active account:', accounts[0]);
}
});
```
##### chainChanged()
> **chainChanged**(`chainId`): `void`
Defined in: [src/provider/events/EIP1193Events.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L81)
Emitted when active chain changes
###### Parameters
###### chainId
`string`
New chain ID (hex string per eth\_chainId)
###### Returns
`void`
###### Example
```typescript theme={null}
provider.on('chainChanged', (chainId) => {
console.log('Switched to chain:', parseInt(chainId, 16));
});
```
##### connect()
> **connect**(`connectInfo`): `void`
Defined in: [src/provider/events/EIP1193Events.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L53)
Emitted when Provider connects to a chain
###### Parameters
###### connectInfo
[`ProviderConnectInfo`](#providerconnectinfo)
Chain connection information
###### Returns
`void`
###### Example
```typescript theme={null}
provider.on('connect', ({ chainId }) => {
console.log('Connected to chain:', chainId);
});
```
##### disconnect()
> **disconnect**(`error`): `void`
Defined in: [src/provider/events/EIP1193Events.ts:67](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L67)
Emitted when Provider disconnects from ALL chains
###### Parameters
###### error
[`ProviderRpcError`](#providerrpcerror)
Disconnect error (code from CloseEvent spec)
###### Returns
`void`
###### Example
```typescript theme={null}
provider.on('disconnect', (error) => {
console.error('Disconnected:', error.message, error.code);
});
```
##### message()
> **message**(`message`): `void`
Defined in: [src/provider/events/EIP1193Events.ts:115](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Events.ts#L115)
Emitted for arbitrary notifications (subscriptions, etc)
###### Parameters
###### message
[`ProviderMessage`](#providermessage)
Provider message
###### Returns
`void`
###### Example
```typescript theme={null}
provider.on('message', ({ type, data }) => {
if (type === 'eth_subscription') {
console.log('Subscription update:', data);
}
});
```
***
### EIP1193RequestOptions
Defined in: [src/provider/request/EIP1193RequestOptions.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/EIP1193RequestOptions.ts#L20)
Optional request configuration
#### Example
```typescript theme={null}
const result = await provider.request(
{ method: 'eth_blockNumber' },
{ retryCount: 3, retryDelay: 1000 }
);
```
#### Properties
##### retryCount?
> `optional` **retryCount**: `number`
Defined in: [src/provider/request/EIP1193RequestOptions.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/EIP1193RequestOptions.ts#L22)
Max number of retries (default: 0)
##### retryDelay?
> `optional` **retryDelay**: `number`
Defined in: [src/provider/request/EIP1193RequestOptions.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/EIP1193RequestOptions.ts#L24)
Base delay between retries in ms (default: 0)
##### timeout?
> `optional` **timeout**: `number`
Defined in: [src/provider/request/EIP1193RequestOptions.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/EIP1193RequestOptions.ts#L26)
Request timeout in ms (optional)
***
### EthSubscription
Defined in: [src/provider/events/EIP1193Provider.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L36)
Ethereum subscription message
Specialized message for eth\_subscribe notifications
#### Extends
* [`ProviderMessage`](#providermessage)
#### Properties
##### data
> `readonly` **data**: `object`
Defined in: [src/provider/events/EIP1193Provider.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L38)
Message payload
###### result
> **result**: `unknown`
###### subscription
> **subscription**: `string`
###### Overrides
[`ProviderMessage`](#providermessage).[`data`](#data-2)
##### type
> `readonly` **type**: `"eth_subscription"`
Defined in: [src/provider/events/EIP1193Provider.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L37)
Message type identifier
###### Overrides
[`ProviderMessage`](#providermessage).[`type`](#type-1)
***
### HttpProviderOptions
Defined in: [src/provider/HttpProvider.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L32)
HTTP configuration options
#### Properties
##### headers?
> `optional` **headers**: `Record`\<`string`, `string`>
Defined in: [src/provider/HttpProvider.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L36)
Optional HTTP headers
##### retry?
> `optional` **retry**: `number`
Defined in: [src/provider/HttpProvider.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L40)
Default retry attempts
##### retryDelay?
> `optional` **retryDelay**: `number`
Defined in: [src/provider/HttpProvider.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L42)
Default retry delay in ms
##### timeout?
> `optional` **timeout**: `number`
Defined in: [src/provider/HttpProvider.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L38)
Default request timeout in ms
##### url
> **url**: `string`
Defined in: [src/provider/HttpProvider.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/HttpProvider.ts#L34)
JSON-RPC endpoint URL
***
### InMemoryProviderOptions
Defined in: [src/provider/InMemoryProvider.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L28)
In-Memory Provider configuration options
#### Properties
##### accounts?
> `optional` **accounts**: `object`\[]
Defined in: [src/provider/InMemoryProvider.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L36)
Initial accounts with balances
###### address
> **address**: `string`
###### balance
> **balance**: `string`
###### privateKey?
> `optional` **privateKey**: `string`
##### baseFeePerGas?
> `optional` **baseFeePerGas**: `bigint`
Defined in: [src/provider/InMemoryProvider.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L46)
Base fee per gas (default: 1000000000 = 1 gwei)
##### blockGasLimit?
> `optional` **blockGasLimit**: `bigint`
Defined in: [src/provider/InMemoryProvider.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L44)
Block gas limit (default: 30000000)
##### blockNumber?
> `optional` **blockNumber**: `bigint`
Defined in: [src/provider/InMemoryProvider.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L42)
Initial block number (default: 0)
##### chainId?
> `optional` **chainId**: `number`
Defined in: [src/provider/InMemoryProvider.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L30)
Chain ID (default: 1)
##### mining?
> `optional` **mining**: `"interval"` | `"auto"` | `"manual"`
Defined in: [src/provider/InMemoryProvider.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L32)
Mining mode: auto, interval, or manual (default: auto)
##### miningInterval?
> `optional` **miningInterval**: `number`
Defined in: [src/provider/InMemoryProvider.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/InMemoryProvider.ts#L34)
Mining interval in ms (when mode is 'interval')
***
### LegacyProviderConnectInfo
Defined in: [src/provider/types.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L78)
EIP-1193 chain information for connect event
#### Properties
##### chainId
> **chainId**: `string`
Defined in: [src/provider/types.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L80)
Chain ID as hex string
***
### LegacyProviderEventMap
Defined in: [src/provider/types.ts:86](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L86)
EIP-1193 provider events
#### Properties
##### accountsChanged
> **accountsChanged**: \[`string`\[]]
Defined in: [src/provider/types.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L88)
Emitted when accounts change
##### chainChanged
> **chainChanged**: \[`string`]
Defined in: [src/provider/types.ts:90](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L90)
Emitted when chain changes
##### connect
> **connect**: \[[`LegacyProviderConnectInfo`](#legacyproviderconnectinfo)]
Defined in: [src/provider/types.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L92)
Emitted when provider connects
##### disconnect
> **disconnect**: \[[`RpcError`](#rpcerror)]
Defined in: [src/provider/types.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L94)
Emitted when provider disconnects
##### message
> **message**: \[`object`]
Defined in: [src/provider/types.ts:96](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L96)
Emitted for custom messages
***
### LegacyRequestArguments
Defined in: [src/provider/types.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L12)
EIP-1193 request arguments
#### Properties
##### method
> `readonly` **method**: `string`
Defined in: [src/provider/types.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L14)
JSON-RPC method name
##### params?
> `readonly` `optional` **params**: `object` | readonly `unknown`\[]
Defined in: [src/provider/types.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L16)
Method parameters (array or object)
***
### Provider
Defined in: [src/provider/Provider.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/Provider.ts#L40)
EIP-1193 Provider interface for Ethereum JSON-RPC communication
Compliant with EIP-1193 specification:
* Single request() method for all RPC calls
* EventEmitter for blockchain events (accountsChanged, chainChanged, etc.)
* Throws RpcError on failures (does not return error objects)
#### Example
```typescript theme={null}
const provider: Provider = new HttpProvider('https://eth.example.com');
// Make requests
const blockNumber = await provider.request({
method: 'eth_blockNumber',
params: []
});
// Listen to events
provider.on('chainChanged', (chainId) => {
console.log('Chain changed:', chainId);
});
```
#### Methods
##### on()
> **on**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/Provider.ts:57](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/Provider.ts#L57)
Register event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
Event name
###### listener
(...`args`) => `void`
Event listener callback
###### Returns
`this`
Provider instance for chaining
##### removeListener()
> **removeListener**\<`E`>(`event`, `listener`): `this`
Defined in: [src/provider/Provider.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/Provider.ts#L69)
Remove event listener
###### Type Parameters
###### E
`E` *extends* keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
###### Parameters
###### event
`E`
Event name
###### listener
(...`args`) => `void`
Event listener callback to remove
###### Returns
`this`
Provider instance for chaining
##### request()
> **request**(`args`): `Promise`\<`unknown`>
Defined in: [src/provider/Provider.ts:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/Provider.ts#L48)
Submit JSON-RPC request to provider
###### Parameters
###### args
[`LegacyRequestArguments`](#legacyrequestarguments)
Request arguments containing method and params
###### Returns
`Promise`\<`unknown`>
Promise resolving to the result
###### Throws
RpcError on failure
***
### ProviderConnectInfo
Defined in: [src/provider/events/EIP1193Provider.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L14)
Connection information
Provided in 'connect' event
#### Properties
##### chainId
> `readonly` **chainId**: `string`
Defined in: [src/provider/events/EIP1193Provider.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L16)
Chain ID as hex string (per eth\_chainId)
***
### ProviderMessage
Defined in: [src/provider/events/EIP1193Provider.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L24)
Provider message
Used for 'message' event (subscriptions, notifications)
#### Extended by
* [`EthSubscription`](#ethsubscription)
#### Properties
##### data
> `readonly` **data**: `unknown`
Defined in: [src/provider/events/EIP1193Provider.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L28)
Message payload
##### type
> `readonly` **type**: `string`
Defined in: [src/provider/events/EIP1193Provider.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/EIP1193Provider.ts#L26)
Message type identifier
***
### RequestArguments
Defined in: [src/provider/request/RequestArguments.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/RequestArguments.ts#L29)
EIP-1193 request arguments
#### Example
```typescript theme={null}
const args: RequestArguments = {
method: 'eth_call',
params: [{ to: '0x...', data: '0x...' }, 'latest']
};
```
#### Type Parameters
##### TRpcSchema
`TRpcSchema` *extends* [`RpcSchema`](#rpcschema)
RPC schema
##### TMethod
`TMethod` *extends* [`RpcMethodNames`](#rpcmethodnames)\<`TRpcSchema`> = [`RpcMethodNames`](#rpcmethodnames)\<`TRpcSchema`>
Specific method name
#### Properties
##### method
> `readonly` **method**: `TMethod`
Defined in: [src/provider/request/RequestArguments.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/RequestArguments.ts#L33)
##### params?
> `readonly` `optional` **params**: [`RpcMethodParameters`](#rpcmethodparameters)\<`TRpcSchema`, `TMethod`>
Defined in: [src/provider/request/RequestArguments.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/RequestArguments.ts#L34)
***
### RequestOptions
Defined in: [src/provider/types.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L50)
Optional configuration for provider requests
#### Properties
##### retry?
> `optional` **retry**: `number`
Defined in: [src/provider/types.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L54)
Number of retry attempts on failure
##### retryDelay?
> `optional` **retryDelay**: `number`
Defined in: [src/provider/types.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L56)
Delay between retries in milliseconds
##### timeout?
> `optional` **timeout**: `number`
Defined in: [src/provider/types.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L52)
Request timeout in milliseconds
***
### RpcError
Defined in: [src/provider/types.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L22)
JSON-RPC error response
#### Properties
##### code
> **code**: `number`
Defined in: [src/provider/types.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L24)
Error code (EIP-1193 or JSON-RPC 2.0)
##### data?
> `optional` **data**: `unknown`
Defined in: [src/provider/types.ts:28](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L28)
Optional error data
##### message
> **message**: `string`
Defined in: [src/provider/types.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L26)
Human-readable error message
***
### TypedProvider
Defined in: [src/provider/TypedProvider.ts:30](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/TypedProvider.ts#L30)
Generic Ethereum Provider interface
#### Example
```typescript theme={null}
import type { TypedProvider, VoltaireRpcSchema, EIP1193EventMap } from './provider/index.js';
// Provider with Voltaire's full JSON-RPC schema
type VoltaireProvider = TypedProvider;
// Provider with custom schema
type CustomProvider = TypedProvider;
```
#### Type Parameters
##### TRpcSchema
`TRpcSchema` *extends* [`RpcSchema`](#rpcschema) = [`RpcSchema`](#rpcschema)
RPC schema defining supported methods
##### TEventMap
`TEventMap` *extends* `Record`\<`string`, (...`args`) => `void`> = [`EIP1193EventMap`](#eip1193eventmap)
Event map defining supported events (defaults to standard EIP-1193)
#### Properties
##### request
> **request**: [`EIP1193RequestFn`](#eip1193requestfn)\<`TRpcSchema`>
Defined in: [src/provider/TypedProvider.ts:50](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/TypedProvider.ts#L50)
Execute JSON-RPC request
###### Param
Request arguments (method + params)
###### Param
Optional request configuration (retry, timeout)
###### Returns
Promise resolving to method-specific return type
###### Example
```typescript theme={null}
const blockNumber = await provider.request({
method: 'eth_blockNumber',
params: []
});
```
#### Methods
##### on()
> **on**\<`TEvent`>(`event`, `listener`): `this`
Defined in: [src/provider/TypedProvider.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/TypedProvider.ts#L65)
Register event listener
###### Type Parameters
###### TEvent
`TEvent` *extends* `string` | `number` | `symbol`
###### Parameters
###### event
`TEvent`
Event name
###### listener
`TEventMap`\[`TEvent`]
Event handler
###### Returns
`this`
###### Example
```typescript theme={null}
provider.on('chainChanged', (chainId: string) => {
console.log('Chain changed to:', chainId);
});
```
##### removeListener()
> **removeListener**\<`TEvent`>(`event`, `listener`): `this`
Defined in: [src/provider/TypedProvider.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/TypedProvider.ts#L76)
Remove event listener
###### Type Parameters
###### TEvent
`TEvent` *extends* `string` | `number` | `symbol`
###### Parameters
###### event
`TEvent`
Event name
###### listener
`TEventMap`\[`TEvent`]
Event handler to remove
###### Returns
`this`
***
### WebSocketProviderOptions
Defined in: [src/provider/WebSocketProvider.ts:23](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L23)
WebSocket configuration options
#### Properties
##### maxReconnectAttempts?
> `optional` **maxReconnectAttempts**: `number`
Defined in: [src/provider/WebSocketProvider.ts:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L33)
Max reconnect attempts (0 = infinite)
##### protocols?
> `optional` **protocols**: `string` | `string`\[]
Defined in: [src/provider/WebSocketProvider.ts:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L27)
WebSocket protocols
##### reconnect?
> `optional` **reconnect**: `boolean`
Defined in: [src/provider/WebSocketProvider.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L29)
Reconnect automatically on disconnect
##### reconnectDelay?
> `optional` **reconnectDelay**: `number`
Defined in: [src/provider/WebSocketProvider.ts:31](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L31)
Reconnect delay in ms
##### url
> **url**: `string`
Defined in: [src/provider/WebSocketProvider.ts:25](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/WebSocketProvider.ts#L25)
WebSocket endpoint URL
## Type Aliases
### BlockTag
> **BlockTag** = `"latest"` | `"earliest"` | `"pending"` | `"safe"` | `"finalized"` | `string`
Defined in: [src/provider/types.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L62)
Block tag for specifying block context
***
### DerivedRpcSchema
> **DerivedRpcSchema**\<`TBase`, `TOverride`> = `TOverride` *extends* [`RpcSchema`](#rpcschema) ? `TOverride` : `TBase` *extends* [`RpcSchema`](#rpcschema) ? `TBase` : [`RpcSchema`](#rpcschema)
Defined in: [src/provider/schemas/DerivedRpcSchema.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/schemas/DerivedRpcSchema.ts#L38)
Derive RPC schema from base and override
Allows extending a base schema with additional methods or overriding existing ones.
#### Type Parameters
##### TBase
`TBase` *extends* [`RpcSchema`](#rpcschema) | `undefined`
Base schema
##### TOverride
`TOverride` *extends* [`RpcSchemaOverride`](#rpcschemaoverride) = `undefined`
Override schema (optional)
#### Example
```typescript theme={null}
type BaseSchema = readonly [
{ Method: 'eth_blockNumber', Parameters: [], ReturnType: string }
];
type CustomSchema = readonly [
{ Method: 'custom_method', Parameters: [string], ReturnType: number }
];
type Combined = DerivedRpcSchema;
// Result: both eth_blockNumber and custom_method are available
```
***
### EIP1193Provider
> **EIP1193Provider** = [`TypedProvider`](#typedprovider)\<[`RpcSchema`](#rpcschema), [`EIP1193EventMap`](#eip1193eventmap)>
Defined in: [src/provider/TypedProvider.ts:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/TypedProvider.ts#L87)
Standard EIP-1193 provider type alias
Uses generic RpcSchema (any methods) with standard EIP-1193 events
***
### EIP1193RequestFn()
> **EIP1193RequestFn**\<`TRpcSchema`> = \<`TMethod`>(`args`, `options?`) => `Promise`\<[`RpcMethodReturnType`](#rpcmethodreturntype)\<`TRpcSchema`, `TMethod`>>
Defined in: [src/provider/request/EIP1193RequestFn.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/request/EIP1193RequestFn.ts#L45)
Type-safe EIP-1193 request function
#### Type Parameters
##### TRpcSchema
`TRpcSchema` *extends* [`RpcSchema`](#rpcschema)
RPC schema defining supported methods
Generic request function that:
* Accepts method name and parameters
* Returns Promise with method-specific return type
* Supports optional request configuration
#### Type Parameters
##### TMethod
`TMethod` *extends* [`RpcMethodNames`](#rpcmethodnames)\<`TRpcSchema`>
#### Parameters
##### args
[`RequestArguments`](#requestarguments)\<`TRpcSchema`, `TMethod`>
##### options?
[`EIP1193RequestOptions`](#eip1193requestoptions)
#### Returns
`Promise`\<[`RpcMethodReturnType`](#rpcmethodreturntype)\<`TRpcSchema`, `TMethod`>>
#### Example
```typescript theme={null}
const request: EIP1193RequestFn = async (args, options) => {
// Implementation
};
// Type-safe: return type inferred as string
const blockNumber = await request({
method: 'eth_blockNumber'
});
// Type-safe: params validated, return type inferred
const balance = await request({
method: 'eth_getBalance',
params: ['0x123...', 'latest']
});
```
***
### ProviderEvent
> **ProviderEvent** = keyof [`LegacyProviderEventMap`](#legacyprovidereventmap)
Defined in: [src/provider/types.ts:102](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L102)
Event names for EIP-1193 provider
***
### ProviderEventListener()
> **ProviderEventListener** = (...`args`) => `void`
Defined in: [src/provider/types.ts:73](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/types.ts#L73)
EIP-1193 event listener
#### Parameters
##### args
...`unknown`\[]
#### Returns
`void`
***
### RpcMethodNames
> **RpcMethodNames**\<`TSchema`> = `TSchema`\[`number`]\[`"Method"`]
Defined in: [src/provider/RpcSchema.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/RpcSchema.ts#L49)
Extract method names from schema
#### Type Parameters
##### TSchema
`TSchema` *extends* [`RpcSchema`](#rpcschema)
#### Example
```typescript theme={null}
type Methods = RpcMethodNames;
// => 'eth_blockNumber' | 'eth_call' | 'debug_traceTransaction' | ...
```
***
### RpcMethodParameters
> **RpcMethodParameters**\<`TSchema`, `TMethod`> = `Extract`\<`TSchema`\[`number`], \{ `Method`: `TMethod`; }>\[`"Parameters"`]
Defined in: [src/provider/RpcSchema.ts:61](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/RpcSchema.ts#L61)
Extract parameters for specific method
#### Type Parameters
##### TSchema
`TSchema` *extends* [`RpcSchema`](#rpcschema)
##### TMethod
`TMethod` *extends* [`RpcMethodNames`](#rpcmethodnames)\<`TSchema`>
#### Example
```typescript theme={null}
type CallParams = RpcMethodParameters;
// => [{ to: string, data: string, ... }, string]
```
***
### RpcMethodReturnType
> **RpcMethodReturnType**\<`TSchema`, `TMethod`> = `Extract`\<`TSchema`\[`number`], \{ `Method`: `TMethod`; }>\[`"ReturnType"`]
Defined in: [src/provider/RpcSchema.ts:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/RpcSchema.ts#L75)
Extract return type for specific method
#### Type Parameters
##### TSchema
`TSchema` *extends* [`RpcSchema`](#rpcschema)
##### TMethod
`TMethod` *extends* [`RpcMethodNames`](#rpcmethodnames)\<`TSchema`>
#### Example
```typescript theme={null}
type CallReturn = RpcMethodReturnType;
// => string (hex-encoded bytes)
```
***
### RpcSchema
> **RpcSchema** = readonly `object`\[]
Defined in: [src/provider/RpcSchema.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/RpcSchema.ts#L34)
Base RPC schema type
Readonly array of method definitions. Each entry maps:
* Method: JSON-RPC method name
* Parameters: Input parameter types (optional)
* ReturnType: Expected return type
#### Example
```typescript theme={null}
const MySchema = [
{
Method: 'eth_blockNumber',
Parameters: [],
ReturnType: string
},
{
Method: 'eth_call',
Parameters: [{ to: string, data: string }, string],
ReturnType: string
}
] as const satisfies RpcSchema;
```
***
### RpcSchemaOverride
> **RpcSchemaOverride** = [`RpcSchema`](#rpcschema) | `undefined`
Defined in: [src/provider/schemas/DerivedRpcSchema.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/schemas/DerivedRpcSchema.ts#L14)
Schema override type
***
### VoltaireRpcSchema
> **VoltaireRpcSchema** = readonly \[\{ `Method`: `"eth_accounts"`; `Parameters`: \[]; `ReturnType`: `string`\[]; }, \{ `Method`: `"eth_blobBaseFee"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_blockNumber"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_call"`; `Parameters`: \[\{ `data?`: `string`; `from?`: `string`; `gas?`: `string`; `gasPrice?`: `string`; `to`: `string`; `value?`: `string`; }, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_chainId"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_coinbase"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_createAccessList"`; `Parameters`: \[\{ `data?`: `string`; `from?`: `string`; `gas?`: `string`; `gasPrice?`: `string`; `to`: `string`; `value?`: `string`; }, `string`]; `ReturnType`: \{ `accessList`: `object`\[]; `gasUsed`: `string`; }; }, \{ `Method`: `"eth_estimateGas"`; `Parameters`: \[\{ `data?`: `string`; `from?`: `string`; `gas?`: `string`; `gasPrice?`: `string`; `to?`: `string`; `value?`: `string`; }, `string`?]; `ReturnType`: `string`; }, \{ `Method`: `"eth_feeHistory"`; `Parameters`: \[`string`, `string`, `number`\[]?]; `ReturnType`: \{ `baseFeePerGas`: `string`\[]; `gasUsedRatio`: `number`\[]; `oldestBlock`: `string`; `reward?`: `string`\[]\[]; }; }, \{ `Method`: `"eth_gasPrice"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getBalance"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getBlockByHash"`; `Parameters`: \[`string`, `boolean`]; `ReturnType`: [`BlockType`](../primitives/Block.mdx#blocktype) | `null`; }, \{ `Method`: `"eth_getBlockByNumber"`; `Parameters`: \[`string`, `boolean`]; `ReturnType`: [`BlockType`](../primitives/Block.mdx#blocktype) | `null`; }, \{ `Method`: `"eth_getBlockReceipts"`; `Parameters`: \[`string`]; `ReturnType`: [`ReceiptType`](../primitives/Receipt.mdx#receipttype)\[] | `null`; }, \{ `Method`: `"eth_getBlockTransactionCountByHash"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getBlockTransactionCountByNumber"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getCode"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getFilterChanges"`; `Parameters`: \[`string`]; `ReturnType`: [`EventLogType`](../primitives/EventLog.mdx#eventlogtype)\[] | `string`\[]; }, \{ `Method`: `"eth_getFilterLogs"`; `Parameters`: \[`string`]; `ReturnType`: [`EventLogType`](../primitives/EventLog.mdx#eventlogtype)\[]; }, \{ `Method`: `"eth_getLogs"`; `Parameters`: \[\{ `address?`: `string` | `string`\[]; `blockHash?`: `string`; `fromBlock?`: `string`; `toBlock?`: `string`; `topics?`: (`string` | `string`\[] | `null`)\[]; }]; `ReturnType`: [`EventLogType`](../primitives/EventLog.mdx#eventlogtype)\[]; }, \{ `Method`: `"eth_getProof"`; `Parameters`: \[`string`, `string`\[], `string`]; `ReturnType`: \{ `accountProof`: `string`\[]; `balance`: `string`; `codeHash`: `string`; `nonce`: `string`; `storageHash`: `string`; `storageProof`: `object`\[]; }; }, \{ `Method`: `"eth_getStorageAt"`; `Parameters`: \[`string`, `string`, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getTransactionByBlockHashAndIndex"`; `Parameters`: \[`string`, `string`]; `ReturnType`: [`Any`](../primitives/Transaction/index.mdx#any) | `null`; }, \{ `Method`: `"eth_getTransactionByBlockNumberAndIndex"`; `Parameters`: \[`string`, `string`]; `ReturnType`: [`Any`](../primitives/Transaction/index.mdx#any) | `null`; }, \{ `Method`: `"eth_getTransactionByHash"`; `Parameters`: \[`string`]; `ReturnType`: [`Any`](../primitives/Transaction/index.mdx#any) | `null`; }, \{ `Method`: `"eth_getTransactionCount"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getTransactionReceipt"`; `Parameters`: \[`string`]; `ReturnType`: [`ReceiptType`](../primitives/Receipt.mdx#receipttype) | `null`; }, \{ `Method`: `"eth_getUncleByBlockHashAndIndex"`; `Parameters`: \[`string`, `string`]; `ReturnType`: [`BlockType`](../primitives/Block.mdx#blocktype) | `null`; }, \{ `Method`: `"eth_getUncleByBlockNumberAndIndex"`; `Parameters`: \[`string`, `string`]; `ReturnType`: [`BlockType`](../primitives/Block.mdx#blocktype) | `null`; }, \{ `Method`: `"eth_getUncleCountByBlockHash"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getUncleCountByBlockNumber"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_getWork"`; `Parameters`: \[]; `ReturnType`: \[`string`, `string`, `string`]; }, \{ `Method`: `"eth_hashrate"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_maxPriorityFeePerGas"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_mining"`; `Parameters`: \[]; `ReturnType`: `boolean`; }, \{ `Method`: `"eth_newBlockFilter"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_newFilter"`; `Parameters`: \[\{ `address?`: `string` | `string`\[]; `fromBlock?`: `string`; `toBlock?`: `string`; `topics?`: (`string` | `string`\[] | `null`)\[]; }]; `ReturnType`: `string`; }, \{ `Method`: `"eth_newPendingTransactionFilter"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_protocolVersion"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"eth_sendRawTransaction"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_sendTransaction"`; `Parameters`: \[\{ `data?`: `string`; `from`: `string`; `gas?`: `string`; `gasPrice?`: `string`; `nonce?`: `string`; `to?`: `string`; `value?`: `string`; }]; `ReturnType`: `string`; }, \{ `Method`: `"eth_sign"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_signTransaction"`; `Parameters`: \[\{ `data?`: `string`; `from`: `string`; `gas?`: `string`; `gasPrice?`: `string`; `nonce?`: `string`; `to?`: `string`; `value?`: `string`; }]; `ReturnType`: `string`; }, \{ `Method`: `"eth_simulateV1"`; `Parameters`: \[`unknown`, `string`?]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"eth_submitHashrate"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"eth_submitWork"`; `Parameters`: \[`string`, `string`, `string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"eth_subscribe"`; `Parameters`: \[`string`, `...unknown[]`]; `ReturnType`: `string`; }, \{ `Method`: `"eth_syncing"`; `Parameters`: \[]; `ReturnType`: `false` | \{ `currentBlock`: `string`; `highestBlock`: `string`; `startingBlock`: `string`; }; }, \{ `Method`: `"eth_uninstallFilter"`; `Parameters`: \[`string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"eth_unsubscribe"`; `Parameters`: \[`string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"debug_getBadBlocks"`; `Parameters`: \[]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"debug_getRawBlock"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"debug_getRawHeader"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"debug_getRawReceipts"`; `Parameters`: \[`string`]; `ReturnType`: `string`\[]; }, \{ `Method`: `"debug_getRawTransaction"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"engine_exchangeCapabilities"`; `Parameters`: \[`string`\[]]; `ReturnType`: `string`\[]; }, \{ `Method`: `"engine_exchangeTransitionConfigurationV1"`; `Parameters`: \[`unknown`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_forkchoiceUpdatedV1"`; `Parameters`: \[`unknown`, `unknown`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_forkchoiceUpdatedV2"`; `Parameters`: \[`unknown`, `unknown`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_forkchoiceUpdatedV3"`; `Parameters`: \[`unknown`, `unknown`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getBlobsV1"`; `Parameters`: \[`string`\[]]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"engine_getBlobsV2"`; `Parameters`: \[`string`\[]]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"engine_getPayloadBodiesByHashV1"`; `Parameters`: \[`string`\[]]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"engine_getPayloadBodiesByRangeV1"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `unknown`\[]; }, \{ `Method`: `"engine_getPayloadV1"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getPayloadV2"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getPayloadV3"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getPayloadV4"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getPayloadV5"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_getPayloadV6"`; `Parameters`: \[`string`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_newPayloadV1"`; `Parameters`: \[`unknown`]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_newPayloadV2"`; `Parameters`: \[`unknown`, `string`\[]?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_newPayloadV3"`; `Parameters`: \[`unknown`, `string`\[]?, `string`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_newPayloadV4"`; `Parameters`: \[`unknown`, `string`\[]?, `string`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"engine_newPayloadV5"`; `Parameters`: \[`unknown`, `string`\[]?, `string`?]; `ReturnType`: `unknown`; }, \{ `Method`: `"web3_clientVersion"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"web3_sha3"`; `Parameters`: \[`string`]; `ReturnType`: `string`; }, \{ `Method`: `"net_version"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"net_listening"`; `Parameters`: \[]; `ReturnType`: `boolean`; }, \{ `Method`: `"net_peerCount"`; `Parameters`: \[]; `ReturnType`: `string`; }, \{ `Method`: `"txpool_status"`; `Parameters`: \[]; `ReturnType`: \{ `pending`: `string`; `queued`: `string`; }; }, \{ `Method`: `"txpool_content"`; `Parameters`: \[]; `ReturnType`: \{ `pending`: `Record`\<`string`, `Record`\<`string`, `unknown`>>; `queued`: `Record`\<`string`, `Record`\<`string`, `unknown`>>; }; }, \{ `Method`: `"txpool_inspect"`; `Parameters`: \[]; `ReturnType`: \{ `pending`: `Record`\<`string`, `Record`\<`string`, `string`>>; `queued`: `Record`\<`string`, `Record`\<`string`, `string`>>; }; }, \{ `Method`: `"anvil_impersonateAccount"`; `Parameters`: \[`string`]; `ReturnType`: `null`; }, \{ `Method`: `"anvil_stopImpersonatingAccount"`; `Parameters`: \[`string`]; `ReturnType`: `null`; }, \{ `Method`: `"anvil_setBalance"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `null`; }, \{ `Method`: `"anvil_setCode"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `null`; }, \{ `Method`: `"anvil_setNonce"`; `Parameters`: \[`string`, `string`]; `ReturnType`: `null`; }, \{ `Method`: `"anvil_setStorageAt"`; `Parameters`: \[`string`, `string`, `string`]; `ReturnType`: `null`; }, \{ `Method`: `"evm_increaseTime"`; `Parameters`: \[`number`]; `ReturnType`: `string`; }, \{ `Method`: `"evm_mine"`; `Parameters`: \[\{ `blocks?`: `number`; `timestamp?`: `number`; }?]; `ReturnType`: `string`; }, \{ `Method`: `"evm_revert"`; `Parameters`: \[`string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"evm_setAutomine"`; `Parameters`: \[`boolean`]; `ReturnType`: `null`; }, \{ `Method`: `"evm_setBlockGasLimit"`; `Parameters`: \[`string`]; `ReturnType`: `boolean`; }, \{ `Method`: `"evm_setIntervalMining"`; `Parameters`: \[`number`]; `ReturnType`: `null`; }, \{ `Method`: `"evm_setNextBlockTimestamp"`; `Parameters`: \[`number`]; `ReturnType`: `null`; }, \{ `Method`: `"evm_snapshot"`; `Parameters`: \[]; `ReturnType`: `string`; }]
Defined in: [src/provider/schemas/VoltaireRpcSchema.ts:41](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/schemas/VoltaireRpcSchema.ts#L41)
Voltaire's default RPC schema
Combines all JSON-RPC methods from:
* eth namespace (52 methods)
* debug namespace
* engine namespace
* web3 namespace
* net namespace
* txpool namespace
* anvil namespace (test methods)
#### Example
```typescript theme={null}
import type { TypedProvider, VoltaireRpcSchema } from './provider/index.js';
type VoltaireProvider = TypedProvider;
const provider: VoltaireProvider = {
request: async ({ method, params }) => {
// Implementation
},
on: (event, listener) => provider,
removeListener: (event, listener) => provider,
};
```
## Variables
### EIP1193ErrorCode
> `const` **EIP1193ErrorCode**: `object`
Defined in: [src/provider/events/ProviderRpcError.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L46)
Standard EIP-1193 error codes
#### Type Declaration
##### ChainDisconnected
> `readonly` **ChainDisconnected**: `4901` = `4901`
Provider not connected to requested chain
##### Disconnected
> `readonly` **Disconnected**: `4900` = `4900`
Provider disconnected from all chains
##### Unauthorized
> `readonly` **Unauthorized**: `4100` = `4100`
Method/account not authorized
##### UnsupportedMethod
> `readonly` **UnsupportedMethod**: `4200` = `4200`
Method not supported
##### UserRejectedRequest
> `readonly` **UserRejectedRequest**: `4001` = `4001`
User rejected the request
***
### JsonRpcErrorCode
> `const` **JsonRpcErrorCode**: `object`
Defined in: [src/provider/events/ProviderRpcError.ts:62](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/events/ProviderRpcError.ts#L62)
JSON-RPC 2.0 error codes
#### Type Declaration
##### InternalError
> `readonly` **InternalError**: `-32603` = `-32603`
Internal error
##### InvalidParams
> `readonly` **InvalidParams**: `-32602` = `-32602`
Invalid parameters
##### InvalidRequest
> `readonly` **InvalidRequest**: `-32600` = `-32600`
Invalid request object
##### MethodNotFound
> `readonly` **MethodNotFound**: `-32601` = `-32601`
Method not found
##### ParseError
> `readonly` **ParseError**: `-32700` = `-32700`
Invalid JSON
## Functions
### fromEvm()
> **fromEvm**(`evmOrOptions`): [`Provider`](#provider)
Defined in: [src/provider/fromEvm.ts:189](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/fromEvm.ts#L189)
Create a Provider from an EVM host-like object.
Accepts either a BrandedHost directly or an object with a `host` property.
#### Parameters
##### evmOrOptions
[`BrandedHost`](../evm/index.mdx#brandedhost) | `FromEvmOptions`
#### Returns
[`Provider`](#provider)
# provider/eip6963
Source: https://voltaire.tevm.sh/generated-api/provider/namespaces/provider/eip6963
Auto-generated API documentation
[**@tevm/voltaire**](../../../index.mdx)
***
[@tevm/voltaire](../../../index.mdx) / [provider](../../index.mdx) / provider/eip6963
# provider/eip6963
EIP-6963: Multi Injected Provider Discovery
Enables dapps to discover multiple wallet providers and wallets to announce themselves.
## Dapp Usage (Consumer)
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// Subscribe to wallet announcements
const unsubscribe = EIP6963.subscribe((providers) => {
for (const { info, provider } of providers) {
console.log(`Found: ${info.name} (${info.rdns})`);
}
});
// Find specific wallet
const metamask = EIP6963.findProvider({ rdns: 'io.metamask' });
// Cleanup
unsubscribe();
```
## Wallet Usage (Producer)
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const unsubscribe = EIP6963.announce({
info: {
uuid: crypto.randomUUID(),
name: "My Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.mywallet"
},
provider: myProvider
});
```
## See
[https://eips.ethereum.org/EIPS/eip-6963](https://eips.ethereum.org/EIPS/eip-6963)
## Classes
### EIP6963Error
Defined in: [src/provider/eip6963/errors.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L14)
Base error for all EIP-6963 operations
#### Extends
* [`PrimitiveError`](../../../index/index.mdx#primitiveerror)
#### Extended by
* [`InvalidArgumentError`](#invalidargumenterror)
* [`InvalidFieldError`](#invalidfielderror)
* [`InvalidIconError`](#invalidiconerror)
* [`InvalidProviderError`](#invalidprovidererror)
* [`InvalidRdnsError`](#invalidrdnserror)
* [`InvalidUuidError`](#invaliduuiderror)
* [`MissingFieldError`](#missingfielderror)
* [`NotImplementedError`](#notimplementederror)
* [`UnsupportedEnvironmentError`](#unsupportedenvironmenterror)
#### Constructors
##### Constructor
> **new EIP6963Error**(`message`, `options?`): [`EIP6963Error`](#eip6963error)
Defined in: [src/provider/eip6963/errors.ts:15](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L15)
###### Parameters
###### message
`string`
###### options?
###### cause?
`Error`
###### code?
`string`
###### context?
`Record`\<`string`, `unknown`>
###### docsPath?
`string`
###### Returns
[`EIP6963Error`](#eip6963error)
###### Overrides
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`constructor`](../../../index/index.mdx#constructor-16)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`cause`](../../../index/index.mdx#cause-16)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`code`](../../../index/index.mdx#code-16)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`context`](../../../index/index.mdx#context-16)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`docsPath`](../../../index/index.mdx#docspath-16)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`getErrorChain`](../../../index/index.mdx#geterrorchain-32)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`PrimitiveError`](../../../index/index.mdx#primitiveerror).[`toJSON`](../../../index/index.mdx#tojson-32)
***
### InvalidArgumentError
Defined in: [src/provider/eip6963/errors.ts:152](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L152)
Thrown when function argument is invalid
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidArgumentError**(`functionName`, `expected`, `got`): [`InvalidArgumentError`](#invalidargumenterror)
Defined in: [src/provider/eip6963/errors.ts:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L155)
###### Parameters
###### functionName
`string`
###### expected
`string`
###### got
`string`
###### Returns
[`InvalidArgumentError`](#invalidargumenterror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### argument
> `readonly` **argument**: `string`
Defined in: [src/provider/eip6963/errors.ts:153](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L153)
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### InvalidFieldError
Defined in: [src/provider/eip6963/errors.ts:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L124)
Thrown when field value is invalid (e.g., empty string)
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidFieldError**(`objectType`, `field`, `reason`): [`InvalidFieldError`](#invalidfielderror)
Defined in: [src/provider/eip6963/errors.ts:127](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L127)
###### Parameters
###### objectType
`string`
###### field
`string`
###### reason
`string`
###### Returns
[`InvalidFieldError`](#invalidfielderror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### field
> `readonly` **field**: `string`
Defined in: [src/provider/eip6963/errors.ts:125](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L125)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### InvalidIconError
Defined in: [src/provider/eip6963/errors.ts:88](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L88)
Thrown when icon format is invalid
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidIconError**(`icon`): [`InvalidIconError`](#invalidiconerror)
Defined in: [src/provider/eip6963/errors.ts:91](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L91)
###### Parameters
###### icon
`string`
###### Returns
[`InvalidIconError`](#invalidiconerror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### icon
> `readonly` **icon**: `string`
Defined in: [src/provider/eip6963/errors.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L89)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### InvalidProviderError
Defined in: [src/provider/eip6963/errors.ts:140](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L140)
Thrown when provider is invalid (missing request method)
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidProviderError**(): [`InvalidProviderError`](#invalidprovidererror)
Defined in: [src/provider/eip6963/errors.ts:141](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L141)
###### Returns
[`InvalidProviderError`](#invalidprovidererror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### InvalidRdnsError
Defined in: [src/provider/eip6963/errors.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L69)
Thrown when RDNS format is invalid
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidRdnsError**(`rdns`): [`InvalidRdnsError`](#invalidrdnserror)
Defined in: [src/provider/eip6963/errors.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L72)
###### Parameters
###### rdns
`string`
###### Returns
[`InvalidRdnsError`](#invalidrdnserror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### rdns
> `readonly` **rdns**: `string`
Defined in: [src/provider/eip6963/errors.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L70)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### InvalidUuidError
Defined in: [src/provider/eip6963/errors.ts:53](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L53)
Thrown when UUID format is invalid
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new InvalidUuidError**(`uuid`): [`InvalidUuidError`](#invaliduuiderror)
Defined in: [src/provider/eip6963/errors.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L56)
###### Parameters
###### uuid
`string`
###### Returns
[`InvalidUuidError`](#invaliduuiderror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### uuid
> `readonly` **uuid**: `string`
Defined in: [src/provider/eip6963/errors.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L54)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### MissingFieldError
Defined in: [src/provider/eip6963/errors.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L108)
Thrown when required field is missing
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new MissingFieldError**(`objectType`, `field`): [`MissingFieldError`](#missingfielderror)
Defined in: [src/provider/eip6963/errors.ts:111](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L111)
###### Parameters
###### objectType
`string`
###### field
`string`
###### Returns
[`MissingFieldError`](#missingfielderror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### field
> `readonly` **field**: `string`
Defined in: [src/provider/eip6963/errors.ts:109](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L109)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### NotImplementedError
Defined in: [src/provider/eip6963/errors.ts:168](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L168)
Thrown when method is not yet implemented
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new NotImplementedError**(`methodName`): [`NotImplementedError`](#notimplementederror)
Defined in: [src/provider/eip6963/errors.ts:169](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L169)
###### Parameters
###### methodName
`string`
###### Returns
[`NotImplementedError`](#notimplementederror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
***
### UnsupportedEnvironmentError
Defined in: [src/provider/eip6963/errors.ts:37](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L37)
Thrown when EIP-6963 is used in unsupported environment
#### Extends
* [`EIP6963Error`](#eip6963error)
#### Constructors
##### Constructor
> **new UnsupportedEnvironmentError**(`platform`): [`UnsupportedEnvironmentError`](#unsupportedenvironmenterror)
Defined in: [src/provider/eip6963/errors.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L40)
###### Parameters
###### platform
`string`
###### Returns
[`UnsupportedEnvironmentError`](#unsupportedenvironmenterror)
###### Overrides
[`EIP6963Error`](#eip6963error).[`constructor`](#constructor)
#### Properties
##### cause?
> `optional` **cause**: `Error`
Defined in: [src/primitives/errors/AbstractError.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L56)
Root cause of this error (for error chaining)
###### Inherited from
[`EIP6963Error`](#eip6963error).[`cause`](#cause)
##### code
> **code**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L39)
Machine-readable error code for programmatic handling
###### Example
```ts theme={null}
'INVALID_FORMAT', 'INVALID_LENGTH'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`code`](#code)
##### context?
> `optional` **context**: `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L45)
Additional context metadata for debugging
###### Example
```ts theme={null}
{ value: '0x123', expected: '20 bytes' }
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`context`](#context)
##### docsPath?
> `optional` **docsPath**: `string`
Defined in: [src/primitives/errors/AbstractError.ts:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L51)
Path to documentation for this error
###### Example
```ts theme={null}
'/primitives/address/from-hex#error-handling'
```
###### Inherited from
[`EIP6963Error`](#eip6963error).[`docsPath`](#docspath)
##### platform
> `readonly` **platform**: `string`
Defined in: [src/provider/eip6963/errors.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/errors.ts#L38)
#### Methods
##### getErrorChain()
> **getErrorChain**(): `string`
Defined in: [src/primitives/errors/AbstractError.ts:94](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L94)
Get full error chain as string for logging
###### Returns
`string`
###### Inherited from
[`EIP6963Error`](#eip6963error).[`getErrorChain`](#geterrorchain)
##### toJSON()
> **toJSON**(): `Record`\<`string`, `unknown`>
Defined in: [src/primitives/errors/AbstractError.ts:110](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/primitives/errors/AbstractError.ts#L110)
Serialize error to JSON for logging/telemetry
###### Returns
`Record`\<`string`, `unknown`>
###### Inherited from
[`EIP6963Error`](#eip6963error).[`toJSON`](#tojson)
## Type Aliases
### Platform
> **Platform** = `"browser"` | `"node"` | `"bun"` | `"worker"` | `"unknown"`
Defined in: [src/provider/eip6963/types.ts:92](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L92)
Platform detection result
***
### ProviderDetailInput
> **ProviderDetailInput** = `object`
Defined in: [src/provider/eip6963/types.ts:79](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L79)
Input type for ProviderDetail constructor
#### Properties
##### info
> **info**: [`ProviderInfoInput`](#providerinfoinput)
Defined in: [src/provider/eip6963/types.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L80)
##### provider
> **provider**: [`EIP1193Provider`](../../index.mdx#eip1193provider)
Defined in: [src/provider/eip6963/types.ts:81](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L81)
***
### ProviderDetailType
> **ProviderDetailType** = `Readonly`\<\{ `info`: [`ProviderInfoType`](#providerinfotype); `provider`: [`EIP1193Provider`](../../index.mdx#eip1193provider); }> & `object`
Defined in: [src/provider/eip6963/types.ts:69](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L69)
Complete provider announcement
Combines provider metadata with the actual EIP-1193 provider instance.
All instances are frozen and immutable.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ProviderDetail"`
#### Example
```typescript theme={null}
const detail: ProviderDetailType = EIP6963.ProviderDetail({
info: {
uuid: "350670db-19fa-4704-a166-e52e178b59d2",
name: "Example Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.example.wallet"
},
provider: window.ethereum
});
```
***
### ProviderInfoInput
> **ProviderInfoInput** = `object`
Defined in: [src/provider/eip6963/types.ts:43](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L43)
Input type for ProviderInfo constructor
#### Properties
##### icon
> **icon**: `string`
Defined in: [src/provider/eip6963/types.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L46)
##### name
> **name**: `string`
Defined in: [src/provider/eip6963/types.ts:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L45)
##### rdns
> **rdns**: `string`
Defined in: [src/provider/eip6963/types.ts:47](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L47)
##### uuid
> **uuid**: `string`
Defined in: [src/provider/eip6963/types.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L44)
***
### ProviderInfoType
> **ProviderInfoType** = `Readonly`\<\{ `icon`: `string`; `name`: `string`; `rdns`: `string`; `uuid`: `string`; }> & `object`
Defined in: [src/provider/eip6963/types.ts:29](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L29)
Wallet provider metadata
Contains identifying information about an EIP-1193 provider.
All instances are frozen and immutable.
#### Type Declaration
##### \[brand]
> `readonly` **\[brand]**: `"ProviderInfo"`
#### Example
```typescript theme={null}
const info: ProviderInfoType = EIP6963.ProviderInfo({
uuid: "350670db-19fa-4704-a166-e52e178b59d2",
name: "Example Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.example.wallet"
});
```
***
### ProviderListener()
> **ProviderListener** = (`providers`) => `void`
Defined in: [src/provider/eip6963/types.ts:87](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/types.ts#L87)
Listener function for provider announcements
#### Parameters
##### providers
[`ProviderDetailType`](#providerdetailtype)\[]
#### Returns
`void`
## Variables
### DATA\_URI\_REGEX
> `const` **DATA\_URI\_REGEX**: `RegExp`
Defined in: [src/provider/eip6963/validators.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L33)
Data URI format regex for images
***
### RDNS\_REGEX
> `const` **RDNS\_REGEX**: `RegExp`
Defined in: [src/provider/eip6963/validators.js:27](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L27)
Reverse DNS format regex
***
### UUID\_V4\_REGEX
> `const` **UUID\_V4\_REGEX**: `RegExp`
Defined in: [src/provider/eip6963/validators.js:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L20)
UUIDv4 format regex
## Functions
### \_reset()
> **\_reset**(): `void`
Defined in: [src/provider/eip6963/state.js:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/state.js#L52)
Clear all state (for testing)
#### Returns
`void`
***
### announce()
> **announce**(`detail`): () => `void`
Defined in: [src/provider/eip6963/announce.js:51](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/announce.js#L51)
Announce a wallet provider
For wallet implementations: announces the provider to dapps and
automatically re-announces when dapps request providers.
#### Parameters
##### detail
[`ProviderDetailInput`](#providerdetailinput)
Provider info and instance
#### Returns
Unsubscribe function to stop announcing
> (): `void`
##### Returns
`void`
#### Throws
If not in browser
#### Throws
If detail is missing info or provider
#### Throws
If provider.request is not a function
#### Throws
If info.uuid is not valid UUIDv4
#### Throws
If info.rdns is not valid reverse DNS
#### Throws
If info.icon is not valid data URI
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// In wallet extension
const unsubscribe = EIP6963.announce({
info: {
uuid: crypto.randomUUID(),
name: "My Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.mywallet"
},
provider: myProvider
});
// On extension unload
unsubscribe();
```
***
### assertBrowser()
> **assertBrowser**(): `void`
Defined in: [src/provider/eip6963/getPlatform.js:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/getPlatform.js#L76)
Assert that we're in a browser environment
#### Returns
`void`
#### Throws
If not in browser
#### Example
```typescript theme={null}
import { assertBrowser } from '@voltaire/provider/eip6963';
assertBrowser(); // Throws if not in browser
```
***
### findProvider()
> **findProvider**(`options`): [`ProviderDetailType`](#providerdetailtype) | `undefined`
Defined in: [src/provider/eip6963/findProvider.js:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/findProvider.js#L42)
Find a provider by its reverse DNS identifier
Searches the discovered providers for one matching the given rdns.
Note that this requires subscribe() to have been called at least once
to start discovery.
#### Parameters
##### options
Search options
###### rdns
`string`
#### Returns
[`ProviderDetailType`](#providerdetailtype) | `undefined`
Matching provider or undefined
#### Throws
If not in browser
#### Throws
If options.rdns is missing
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// Start discovery
const unsubscribe = EIP6963.subscribe(() => {});
// Find MetaMask
const metamask = EIP6963.findProvider({ rdns: 'io.metamask' });
if (metamask) {
const accounts = await metamask.provider.request({
method: 'eth_requestAccounts'
});
console.log('Connected:', accounts[0]);
}
unsubscribe();
```
***
### getPlatform()
> **getPlatform**(): `"browser"` | `"node"` | `"bun"` | `"worker"` | `"unknown"`
Defined in: [src/provider/eip6963/getPlatform.js:33](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/getPlatform.js#L33)
Detect the current platform
#### Returns
`"browser"` | `"node"` | `"bun"` | `"worker"` | `"unknown"`
The detected platform
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const platform = EIP6963.getPlatform();
if (platform === 'browser') {
// Safe to use EIP-6963
}
```
***
### getProviders()
> **getProviders**(): [`ProviderDetailType`](#providerdetailtype)\[]
Defined in: [src/provider/eip6963/getProviders.js:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/getProviders.js#L34)
Get snapshot of all currently discovered providers
Returns the current state of discovered providers without subscribing
to future updates. Note that this requires subscribe() to have been
called at least once to start discovery.
#### Returns
[`ProviderDetailType`](#providerdetailtype)\[]
Array of discovered providers
#### Throws
If not in browser
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// Start discovery
const unsubscribe = EIP6963.subscribe(() => {});
// Get current snapshot
const providers = EIP6963.getProviders();
console.log(`Found ${providers.length} wallets`);
unsubscribe();
```
***
### ProviderDetail()
> **ProviderDetail**(`input`): [`ProviderDetailType`](#providerdetailtype)
Defined in: [src/provider/eip6963/ProviderDetail.js:48](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/ProviderDetail.js#L48)
Create a validated ProviderDetail object
Validates info and provider, then returns a frozen, branded object.
#### Parameters
##### input
[`ProviderDetailInput`](#providerdetailinput)
Provider detail fields
#### Returns
[`ProviderDetailType`](#providerdetailtype)
Frozen, branded ProviderDetail
#### Throws
If info or provider is missing
#### Throws
If provider.request is not a function
#### Throws
If info.uuid is not valid UUIDv4
#### Throws
If info.rdns is not valid reverse DNS
#### Throws
If info.icon is not valid data URI
#### Throws
If info.name is empty
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const detail = EIP6963.ProviderDetail({
info: {
uuid: "350670db-19fa-4704-a166-e52e178b59d2",
name: "Example Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.example.wallet"
},
provider: window.ethereum
});
// Use the provider
const accounts = await detail.provider.request({
method: 'eth_accounts'
});
```
***
### ProviderInfo()
> **ProviderInfo**(`input`): [`ProviderInfoType`](#providerinfotype)
Defined in: [src/provider/eip6963/ProviderInfo.js:45](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/ProviderInfo.js#L45)
Create a validated ProviderInfo object
Validates all fields and returns a frozen, branded object.
#### Parameters
##### input
[`ProviderInfoInput`](#providerinfoinput)
Provider info fields
#### Returns
[`ProviderInfoType`](#providerinfotype)
Frozen, branded ProviderInfo
#### Throws
If any required field is missing
#### Throws
If uuid is not valid UUIDv4
#### Throws
If rdns is not valid reverse DNS
#### Throws
If icon is not valid data URI
#### Throws
If name is empty
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const info = EIP6963.ProviderInfo({
uuid: "350670db-19fa-4704-a166-e52e178b59d2",
name: "Example Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.example.wallet"
});
console.log(info.name); // "Example Wallet"
console.log(Object.isFrozen(info)); // true
```
***
### subscribe()
> **subscribe**(`listener`): () => `void`
Defined in: [src/provider/eip6963/subscribe.js:75](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/subscribe.js#L75)
Subscribe to wallet provider announcements
Listens for EIP-6963 provider announcements and calls the listener
with the current list of discovered providers. Automatically handles
deduplication by UUID (same UUID updates existing entry).
#### Parameters
##### listener
[`ProviderListener`](#providerlistener)
Called with providers array on each change
#### Returns
Unsubscribe function
> (): `void`
##### Returns
`void`
#### Throws
If not in browser
#### Throws
If listener is not a function
#### Example
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const unsubscribe = EIP6963.subscribe((providers) => {
console.log('Discovered wallets:', providers.length);
for (const { info, provider } of providers) {
console.log(`- ${info.name} (${info.rdns})`);
}
});
// Later, cleanup
unsubscribe();
```
***
### validateIcon()
> **validateIcon**(`icon`): `void`
Defined in: [src/provider/eip6963/validators.js:99](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L99)
Validate icon is a valid data URI
#### Parameters
##### icon
`string`
The icon data URI to validate
#### Returns
`void`
#### Throws
If icon is missing
#### Throws
If icon is not a valid data URI
#### Example
```typescript theme={null}
validateIcon("data:image/svg+xml;base64,PHN2Zy..."); // OK
validateIcon("https://example.com/icon.png"); // Throws InvalidIconError
```
***
### validateName()
> **validateName**(`name`): `void`
Defined in: [src/provider/eip6963/validators.js:143](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L143)
Validate name is non-empty string
#### Parameters
##### name
`string`
The name to validate
#### Returns
`void`
#### Throws
If name is missing
#### Throws
If name is empty
***
### validateProvider()
> **validateProvider**(`provider`): `void`
Defined in: [src/provider/eip6963/validators.js:124](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L124)
Validate provider has request method
#### Parameters
##### provider
`unknown`
The provider to validate
#### Returns
`void`
#### Throws
If provider is missing
#### Throws
If provider.request is not a function
#### Example
```typescript theme={null}
validateProvider(window.ethereum); // OK if has request()
validateProvider({}); // Throws InvalidProviderError
```
***
### validateRdns()
> **validateRdns**(`rdns`): `void`
Defined in: [src/provider/eip6963/validators.js:74](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L74)
Validate RDNS is valid reverse DNS format
#### Parameters
##### rdns
`string`
The reverse DNS to validate
#### Returns
`void`
#### Throws
If rdns is missing
#### Throws
If rdns is not valid format
#### Example
```typescript theme={null}
validateRdns("io.metamask"); // OK
validateRdns("metamask"); // Throws InvalidRdnsError
```
***
### validateUuid()
> **validateUuid**(`uuid`): `void`
Defined in: [src/provider/eip6963/validators.js:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/provider/eip6963/validators.js#L49)
Validate UUID is UUIDv4 format
#### Parameters
##### uuid
`string`
The UUID to validate
#### Returns
`void`
#### Throws
If uuid is missing
#### Throws
If uuid is not valid UUIDv4
#### Example
```typescript theme={null}
validateUuid("350670db-19fa-4704-a166-e52e178b59d2"); // OK
validateUuid("invalid"); // Throws InvalidUuidError
```
# utils
Source: https://voltaire.tevm.sh/generated-api/utils
Auto-generated API documentation
[**@tevm/voltaire**](index.mdx)
***
[@tevm/voltaire](index.mdx) / utils
# utils
Utilities
Generic utilities for building robust Ethereum applications.
Includes retry logic, rate limiting, polling, timeouts, and batching.
## Classes
### AsyncQueue
Defined in: [src/utils/batch.ts:277](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L277)
Async queue processor with concurrency limit
Processes items from a queue with a maximum number of concurrent operations.
Useful for rate-limiting parallel operations like RPC calls or file I/O.
#### Example
```typescript theme={null}
// Process with max 3 concurrent operations
const processor = new AsyncQueue(
async (address) => provider.eth_getBalance(address),
{ concurrency: 3 }
);
// Add items
const results = await Promise.all([
processor.add('0x123...'),
processor.add('0x456...'),
processor.add('0x789...'),
processor.add('0xabc...'),
processor.add('0xdef...'),
]);
// Only 3 execute concurrently, others wait
```
#### Type Parameters
##### T
`T`
Item type
##### R
`R`
Result type
#### Constructors
##### Constructor
> **new AsyncQueue**\<`T`, `R`>(`processFn`, `options`): [`AsyncQueue`](#asyncqueue)\<`T`, `R`>
Defined in: [src/utils/batch.ts:287](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L287)
###### Parameters
###### processFn
(`item`) => `Promise`\<`R`>
###### options
###### concurrency
`number`
###### Returns
[`AsyncQueue`](#asyncqueue)\<`T`, `R`>
#### Methods
##### activeCount()
> **activeCount**(): `number`
Defined in: [src/utils/batch.ts:345](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L345)
Get number of active operations
###### Returns
`number`
##### add()
> **add**(`item`): `Promise`\<`R`>
Defined in: [src/utils/batch.ts:301](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L301)
Add an item to the queue
###### Parameters
###### item
`T`
Item to process
###### Returns
`Promise`\<`R`>
Promise resolving to the result
##### drain()
> **drain**(): `Promise`\<`void`>
Defined in: [src/utils/batch.ts:352](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L352)
Wait for all operations to complete
###### Returns
`Promise`\<`void`>
##### size()
> **size**(): `number`
Defined in: [src/utils/batch.ts:338](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L338)
Get current queue size
###### Returns
`number`
***
### BatchQueue
Defined in: [src/utils/batch.ts:49](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L49)
Batch Queue for async operations
Automatically batches items and processes them together when:
* Batch size reaches maxBatchSize
* maxWaitTime elapses since first item added
Useful for batching RPC calls, database operations, or any async work.
#### Example
```typescript theme={null}
// Batch RPC calls
const queue = new BatchQueue({
maxBatchSize: 10,
maxWaitTime: 100,
processBatch: async (addresses) => {
// Batch call to get multiple balances
return Promise.all(
addresses.map(addr => provider.eth_getBalance(addr))
);
}
});
// Add items - automatically batched
const balance1 = queue.add('0x123...');
const balance2 = queue.add('0x456...');
const balance3 = queue.add('0x789...');
// Results returned individually
console.log(await balance1); // Balance for 0x123...
console.log(await balance2); // Balance for 0x456...
```
#### Type Parameters
##### T
`T`
Item type
##### R
`R`
Result type
#### Constructors
##### Constructor
> **new BatchQueue**\<`T`, `R`>(`options`): [`BatchQueue`](#batchqueue)\<`T`, `R`>
Defined in: [src/utils/batch.ts:63](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L63)
###### Parameters
###### options
[`BatchQueueOptions`](#batchqueueoptions)\<`T`, `R`>
###### Returns
[`BatchQueue`](#batchqueue)\<`T`, `R`>
#### Methods
##### add()
> **add**(`item`): `Promise`\<`R`>
Defined in: [src/utils/batch.ts:76](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L76)
Add an item to the queue
###### Parameters
###### item
`T`
Item to process
###### Returns
`Promise`\<`R`>
Promise resolving to the result for this item
##### clear()
> **clear**(): `void`
Defined in: [src/utils/batch.ts:172](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L172)
Clear the queue without processing
###### Returns
`void`
##### drain()
> **drain**(): `Promise`\<`void`>
Defined in: [src/utils/batch.ts:189](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L189)
Wait for all pending items to complete
###### Returns
`Promise`\<`void`>
##### flush()
> **flush**(): `Promise`\<`void`>
Defined in: [src/utils/batch.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L108)
Flush the current batch
###### Returns
`Promise`\<`void`>
##### size()
> **size**(): `number`
Defined in: [src/utils/batch.ts:165](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L165)
Get current queue size
###### Returns
`number`
***
### RateLimiter
Defined in: [src/utils/rateLimit.ts:142](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L142)
Token Bucket Rate Limiter
Implements token bucket algorithm for rate limiting. Requests consume tokens
from a bucket that refills over time. When bucket is empty, requests are queued,
rejected, or dropped based on strategy.
#### Example
```typescript theme={null}
// Limit to 10 requests per second
const limiter = new RateLimiter({
maxRequests: 10,
interval: 1000,
strategy: 'queue'
});
// Execute with rate limit
const result = await limiter.execute(() => provider.eth_blockNumber());
// Wrap function with rate limiter
const getBalance = limiter.wrap(
(address: string) => provider.eth_getBalance(address)
);
const balance = await getBalance('0x123...');
```
#### Constructors
##### Constructor
> **new RateLimiter**(`options`): [`RateLimiter`](#ratelimiter)
Defined in: [src/utils/rateLimit.ts:155](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L155)
###### Parameters
###### options
[`RateLimiterOptions`](#ratelimiteroptions)
###### Returns
[`RateLimiter`](#ratelimiter)
#### Methods
##### clearQueue()
> **clearQueue**(): `void`
Defined in: [src/utils/rateLimit.ts:295](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L295)
Clear all queued requests
###### Returns
`void`
##### execute()
> **execute**\<`T`>(`fn`): `Promise`\<`T`>
Defined in: [src/utils/rateLimit.ts:224](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L224)
Execute a function with rate limiting
###### Type Parameters
###### T
`T`
Return type
###### Parameters
###### fn
() => `Promise`\<`T`>
Async function to execute
###### Returns
`Promise`\<`T`>
Promise resolving to function result
###### Throws
Error if rate limit exceeded and strategy is 'reject'
##### getQueueLength()
> **getQueueLength**(): `number`
Defined in: [src/utils/rateLimit.ts:288](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L288)
Get queued request count
###### Returns
`number`
##### getTokens()
> **getTokens**(): `number`
Defined in: [src/utils/rateLimit.ts:280](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L280)
Get current token count
###### Returns
`number`
##### wrap()
> **wrap**\<`TArgs`, `TReturn`>(`fn`): (...`args`) => `Promise`\<`TReturn`>
Defined in: [src/utils/rateLimit.ts:271](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L271)
Wrap a function with rate limiting
###### Type Parameters
###### TArgs
`TArgs` *extends* `unknown`\[]
Function argument types
###### TReturn
`TReturn`
Function return type
###### Parameters
###### fn
(...`args`) => `Promise`\<`TReturn`>
Function to wrap
###### Returns
Rate-limited function
> (...`args`): `Promise`\<`TReturn`>
###### Parameters
###### args
...`TArgs`
###### Returns
`Promise`\<`TReturn`>
***
### TimeoutError
Defined in: [src/utils/timeout.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L16)
Timeout error class
#### Extends
* `Error`
#### Constructors
##### Constructor
> **new TimeoutError**(`message`): [`TimeoutError`](#timeouterror)
Defined in: [src/utils/timeout.ts:17](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L17)
###### Parameters
###### message
`string` = `"Operation timed out"`
###### Returns
[`TimeoutError`](#timeouterror)
###### Overrides
`Error.constructor`
## Interfaces
### BatchQueueOptions
Defined in: [src/utils/types.ts:64](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L64)
Batch queue configuration
#### Type Parameters
##### T
`T`
##### R
`R`
#### Properties
##### maxBatchSize
> **maxBatchSize**: `number`
Defined in: [src/utils/types.ts:66](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L66)
Maximum batch size
##### maxWaitTime
> **maxWaitTime**: `number`
Defined in: [src/utils/types.ts:68](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L68)
Maximum wait time before flushing batch (ms)
##### onError()?
> `optional` **onError**: (`error`, `items`) => `void`
Defined in: [src/utils/types.ts:72](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L72)
Callback on batch processing error
###### Parameters
###### error
`unknown`
###### items
`T`\[]
###### Returns
`void`
##### processBatch()
> **processBatch**: (`items`) => `Promise`\<`R`\[]>
Defined in: [src/utils/types.ts:70](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L70)
Function to process a batch of items
###### Parameters
###### items
`T`\[]
###### Returns
`Promise`\<`R`\[]>
***
### PollOptions
Defined in: [src/utils/types.ts:32](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L32)
Polling configuration options
#### Type Parameters
##### T
`T`
#### Properties
##### backoff?
> `optional` **backoff**: `boolean`
Defined in: [src/utils/types.ts:38](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L38)
Use exponential backoff for polling intervals (default: false)
##### backoffFactor?
> `optional` **backoffFactor**: `number`
Defined in: [src/utils/types.ts:40](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L40)
Backoff factor when backoff enabled (default: 1.5)
##### interval?
> `optional` **interval**: `number`
Defined in: [src/utils/types.ts:34](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L34)
Polling interval in milliseconds (default: 1000)
##### maxInterval?
> `optional` **maxInterval**: `number`
Defined in: [src/utils/types.ts:42](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L42)
Maximum interval when using backoff (default: 10000)
##### onPoll()?
> `optional` **onPoll**: (`result`, `attempt`) => `void`
Defined in: [src/utils/types.ts:46](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L46)
Callback invoked on each poll attempt
###### Parameters
###### result
`T`
###### attempt
`number`
###### Returns
`void`
##### timeout?
> `optional` **timeout**: `number`
Defined in: [src/utils/types.ts:36](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L36)
Maximum polling duration in milliseconds (default: 60000)
##### validate()?
> `optional` **validate**: (`result`) => `boolean`
Defined in: [src/utils/types.ts:44](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L44)
Predicate to determine if polling should continue
###### Parameters
###### result
`T`
###### Returns
`boolean`
***
### RateLimiterOptions
Defined in: [src/utils/types.ts:52](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L52)
Rate limiter configuration
#### Properties
##### interval
> **interval**: `number`
Defined in: [src/utils/types.ts:56](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L56)
Time interval in milliseconds
##### maxRequests
> **maxRequests**: `number`
Defined in: [src/utils/types.ts:54](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L54)
Maximum number of requests per interval
##### strategy?
> `optional` **strategy**: `"queue"` | `"reject"` | `"drop"`
Defined in: [src/utils/types.ts:58](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L58)
Queue strategy when limit exceeded (default: 'queue')
***
### RetryOptions
Defined in: [src/utils/types.ts:12](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L12)
Retry configuration options
#### Properties
##### factor?
> `optional` **factor**: `number`
Defined in: [src/utils/types.ts:18](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L18)
Exponential backoff factor (default: 2)
##### initialDelay?
> `optional` **initialDelay**: `number`
Defined in: [src/utils/types.ts:16](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L16)
Initial delay in milliseconds (default: 1000)
##### jitter?
> `optional` **jitter**: `boolean`
Defined in: [src/utils/types.ts:22](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L22)
Add random jitter to delays (default: true)
##### maxDelay?
> `optional` **maxDelay**: `number`
Defined in: [src/utils/types.ts:20](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L20)
Maximum delay cap in milliseconds (default: 30000)
##### maxRetries?
> `optional` **maxRetries**: `number`
Defined in: [src/utils/types.ts:14](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L14)
Maximum number of retry attempts (default: 3)
##### onRetry()?
> `optional` **onRetry**: (`error`, `attempt`, `nextDelay`) => `void`
Defined in: [src/utils/types.ts:26](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L26)
Callback invoked on each retry attempt
###### Parameters
###### error
`unknown`
###### attempt
`number`
###### nextDelay
`number`
###### Returns
`void`
##### shouldRetry()?
> `optional` **shouldRetry**: (`error`, `attempt`) => `boolean`
Defined in: [src/utils/types.ts:24](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L24)
Predicate to determine if error should be retried (default: always retry)
###### Parameters
###### error
`unknown`
###### attempt
`number`
###### Returns
`boolean`
***
### TimeoutOptions
Defined in: [src/utils/types.ts:78](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L78)
Timeout options
#### Properties
##### message?
> `optional` **message**: `string`
Defined in: [src/utils/types.ts:82](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L82)
Error message for timeout (default: "Operation timed out")
##### ms
> **ms**: `number`
Defined in: [src/utils/types.ts:80](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L80)
Timeout duration in milliseconds
##### signal?
> `optional` **signal**: `AbortSignal`
Defined in: [src/utils/types.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/types.ts#L84)
Optional AbortController for cancellation
## Functions
### createBatchedFunction()
> **createBatchedFunction**\<`T`, `R`>(`fn`, `maxBatchSize`, `maxWaitTime`): (`item`) => `Promise`\<`R`>
Defined in: [src/utils/batch.ts:234](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/batch.ts#L234)
Create a batched version of an async function
Returns a new function that automatically batches calls.
Useful for wrapping provider methods or other async functions.
#### Type Parameters
##### T
`T`
Argument type
##### R
`R`
Return type
#### Parameters
##### fn
(`items`) => `Promise`\<`R`\[]>
Function to batch (takes array, returns array)
##### maxBatchSize
`number`
Maximum batch size
##### maxWaitTime
`number`
Maximum wait time in milliseconds
#### Returns
Batched function (takes single item, returns single result)
> (`item`): `Promise`\<`R`>
##### Parameters
###### item
`T`
##### Returns
`Promise`\<`R`>
#### Example
```typescript theme={null}
// Batch balance lookups
const getBalance = createBatchedFunction(
async (addresses: string[]) => {
return Promise.all(
addresses.map(addr => provider.eth_getBalance(addr))
);
},
50, // Batch up to 50 addresses
100 // Wait max 100ms
);
// Use like normal function - batching happens automatically
const balance1 = getBalance('0x123...');
const balance2 = getBalance('0x456...');
const balance3 = getBalance('0x789...');
// All three requests batched into single call
console.log(await balance1);
console.log(await balance2);
console.log(await balance3);
```
***
### createDeferred()
> **createDeferred**\<`T`>(): `object`
Defined in: [src/utils/timeout.ts:226](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L226)
Create a deferred promise with manual resolve/reject control
Returns a promise along with functions to resolve or reject it manually.
Useful for complex async flows, event handling, and cancellation patterns.
#### Type Parameters
##### T
`T`
Promise result type
#### Returns
`object`
Object with promise and control functions
##### promise
> **promise**: `Promise`\<`T`>
##### reject()
> **reject**: (`error`) => `void`
###### Parameters
###### error
`unknown`
###### Returns
`void`
##### resolve()
> **resolve**: (`value`) => `void`
###### Parameters
###### value
`T`
###### Returns
`void`
#### Example
```typescript theme={null}
// Manual promise control
const { promise, resolve, reject } = createDeferred();
// Resolve from event handler
provider.on('block', (blockNumber) => {
if (blockNumber > 1000000) {
resolve(blockNumber);
}
});
const result = await promise;
// With timeout
const { promise, resolve, reject } = createDeferred();
setTimeout(() => reject(new TimeoutError()), 5000);
// Resolve from multiple sources
websocket.on('message', (data) => resolve(data));
controller.on('cancel', () => reject(new Error('Cancelled')));
```
***
### debounce()
> **debounce**\<`TArgs`, `TReturn`>(`fn`, `wait`): (...`args`) => `void` & `object`
Defined in: [src/utils/rateLimit.ts:89](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L89)
Debounce a function to execute only after calls have stopped for specified wait time
Delays execution until the function hasn't been called for the wait period.
Useful for expensive operations triggered by rapid events (search, resize, etc).
#### Type Parameters
##### TArgs
`TArgs` *extends* `unknown`\[]
Function argument types
##### TReturn
`TReturn`
Function return type
#### Parameters
##### fn
(...`args`) => `TReturn`
Function to debounce
##### wait
`number`
Wait time in milliseconds
#### Returns
(...`args`) => `void` & `object`
Debounced function with cancel method
#### Example
```typescript theme={null}
// Debounce search queries
const searchBlocks = debounce(
(query: string) => provider.eth_getBlockByNumber(query),
500 // Wait 500ms after last keystroke
);
// Rapid calls - only last executes after 500ms
searchBlocks('latest'); // Cancelled
searchBlocks('pending'); // Cancelled
searchBlocks('0x123'); // Executes after 500ms
// Cancel pending execution
searchBlocks.cancel();
```
***
### executeWithTimeout()
> **executeWithTimeout**\<`T`>(`fn`, `timeoutMs`, `maxRetries`): `Promise`\<`T`>
Defined in: [src/utils/timeout.ts:275](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L275)
Execute an async function with a timeout and optional retries
Combines timeout and retry logic for robust async operations.
Each retry attempt gets a fresh timeout.
#### Type Parameters
##### T
`T`
Return type
#### Parameters
##### fn
() => `Promise`\<`T`>
Async function to execute
##### timeoutMs
`number`
Timeout per attempt in milliseconds
##### maxRetries
`number` = `0`
Maximum number of retry attempts (default: 0)
#### Returns
`Promise`\<`T`>
Promise resolving to function result
#### Throws
TimeoutError if all attempts timeout
#### Example
```typescript theme={null}
// Execute with timeout and retries
const block = await executeWithTimeout(
() => provider.eth_getBlockByNumber('latest'),
5000, // 5s timeout per attempt
3 // Retry up to 3 times
);
// Fetch with timeout and retries
const data = await executeWithTimeout(
async () => {
const res = await fetch(url);
return res.json();
},
10000,
2
);
```
***
### poll()
> **poll**\<`T`>(`fn`, `options`): `Promise`\<`T`>
Defined in: [src/utils/poll.ts:84](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/poll.ts#L84)
Poll an async operation until it succeeds or times out
Repeatedly calls the provided function until it returns a truthy value,
the optional validate predicate passes, or the timeout is reached.
Supports exponential backoff for progressively longer intervals.
#### Type Parameters
##### T
`T`
Return type of the polling function
#### Parameters
##### fn
() => `Promise`\<`T`>
Async function to poll
##### options
[`PollOptions`](#polloptions)\<`T`> = `{}`
Polling configuration
#### Returns
`Promise`\<`T`>
Promise resolving to the successful result
#### Throws
Error if timeout is reached or validation fails
#### Example
```typescript theme={null}
// Wait for transaction confirmation
const receipt = await poll(
() => provider.eth_getTransactionReceipt(txHash),
{
interval: 1000,
timeout: 60000,
validate: (receipt) => receipt !== null
}
);
// Wait for block with backoff
const block = await poll(
() => provider.eth_getBlockByNumber('latest'),
{
interval: 500,
backoff: true,
backoffFactor: 2,
maxInterval: 5000
}
);
// Poll with progress callback
const balance = await poll(
() => provider.eth_getBalance(address),
{
interval: 2000,
onPoll: (result, attempt) => {
console.log(`Attempt ${attempt}: ${result}`);
}
}
);
```
***
### pollForReceipt()
> **pollForReceipt**\<`TReceipt`>(`txHash`, `getReceipt`, `options`): `Promise`\<`TReceipt`>
Defined in: [src/utils/poll.ts:211](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/poll.ts#L211)
Poll for a transaction receipt
Convenience function for the common pattern of waiting for transaction confirmation.
Polls eth\_getTransactionReceipt until receipt is available.
#### Type Parameters
##### TReceipt
`TReceipt`
#### Parameters
##### txHash
`string`
Transaction hash to poll for
##### getReceipt
(`hash`) => `Promise`\<`TReceipt` | `null`>
Function to fetch receipt (provider.eth\_getTransactionReceipt)
##### options
`Omit`\<[`PollOptions`](#polloptions)\<`TReceipt` | `null`>, `"validate"`> = `{}`
Polling configuration
#### Returns
`Promise`\<`TReceipt`>
Promise resolving to the transaction receipt
#### Throws
Error if timeout is reached
#### Example
```typescript theme={null}
// Wait for transaction receipt
const receipt = await pollForReceipt(
txHash,
(hash) => provider.eth_getTransactionReceipt(hash),
{ timeout: 120000 } // 2 minutes
);
if (receipt.status === '0x1') {
console.log('Transaction successful!');
}
```
***
### pollUntil()
> **pollUntil**\<`T`>(`fn`, `predicate`, `options`): `Promise`\<`T`>
Defined in: [src/utils/poll.ts:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/poll.ts#L174)
Poll until a predicate returns true
Repeatedly calls the function and checks if the predicate passes.
More expressive than poll() when you want to explicitly check a condition.
#### Type Parameters
##### T
`T`
Return type of the polling function
#### Parameters
##### fn
() => `Promise`\<`T`>
Async function to poll
##### predicate
(`result`) => `boolean`
Function to test result
##### options
`Omit`\<[`PollOptions`](#polloptions)\<`T`>, `"validate"`> = `{}`
Polling configuration (without validate)
#### Returns
`Promise`\<`T`>
Promise resolving to the successful result
#### Throws
Error if timeout is reached
#### Example
```typescript theme={null}
// Wait for specific block number
const blockNumber = await pollUntil(
() => provider.eth_blockNumber(),
(num) => num >= 1000000n,
{ interval: 500, timeout: 30000 }
);
// Wait for contract deployment
const code = await pollUntil(
() => provider.eth_getCode(contractAddress),
(code) => code.length > 2, // More than '0x'
{ interval: 1000 }
);
```
***
### pollWithBackoff()
> **pollWithBackoff**\<`T`>(`fn`, `options`): `Promise`\<`T`>
Defined in: [src/utils/poll.ts:253](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/poll.ts#L253)
Poll with exponential backoff
Convenience function that enables exponential backoff by default.
Useful when you expect operations to take progressively longer.
#### Type Parameters
##### T
`T`
Return type of the polling function
#### Parameters
##### fn
() => `Promise`\<`T`>
Async function to poll
##### options
[`PollOptions`](#polloptions)\<`T`> = `{}`
Polling configuration (backoff enabled by default)
#### Returns
`Promise`\<`T`>
Promise resolving to the successful result
#### Throws
Error if timeout is reached
#### Example
```typescript theme={null}
// Poll with automatic backoff
const data = await pollWithBackoff(
() => provider.eth_call({ to, data }),
{
interval: 100, // Start at 100ms
backoffFactor: 2, // Double each time
maxInterval: 5000, // Cap at 5s
timeout: 30000
}
);
```
***
### retryWithBackoff()
> **retryWithBackoff**\<`T`>(`fn`, `options`): `Promise`\<`T`>
Defined in: [src/utils/retryWithBackoff.ts:108](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/retryWithBackoff.ts#L108)
Retry an async operation with exponential backoff
Automatically retries failed operations using exponential backoff with jitter.
Useful for handling transient failures in network requests, RPC calls, and
other unreliable operations.
#### Type Parameters
##### T
`T`
Return type of the operation
#### Parameters
##### fn
() => `Promise`\<`T`>
Async function to retry
##### options
[`RetryOptions`](#retryoptions) = `{}`
Retry configuration
#### Returns
`Promise`\<`T`>
Promise resolving to the operation result
#### Throws
Last error encountered if all retries exhausted
#### Example
```typescript theme={null}
// Basic usage - retry RPC call
const blockNumber = await retryWithBackoff(
() => provider.eth_blockNumber(),
{ maxRetries: 5 }
);
// Custom retry condition - only retry on network errors
const data = await retryWithBackoff(
() => fetchData(),
{
maxRetries: 3,
shouldRetry: (error) => error.code === 'NETWORK_ERROR',
onRetry: (error, attempt, delay) => {
console.log(`Retry ${attempt} after ${delay}ms: ${error.message}`);
}
}
);
// Aggressive retry with custom backoff
const result = await retryWithBackoff(
() => unstableOperation(),
{
maxRetries: 10,
initialDelay: 100,
factor: 1.5,
maxDelay: 5000,
jitter: true
}
);
```
***
### sleep()
> **sleep**(`ms`, `signal?`): `Promise`\<`void`>
Defined in: [src/utils/timeout.ts:174](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L174)
Sleep for specified duration with optional cancellation
Returns a promise that resolves after the specified time.
Can be cancelled using an AbortSignal.
#### Parameters
##### ms
`number`
Milliseconds to sleep
##### signal?
`AbortSignal`
Optional AbortSignal for cancellation
#### Returns
`Promise`\<`void`>
Promise that resolves after delay
#### Throws
Error if operation is aborted
#### Example
```typescript theme={null}
// Simple delay
await sleep(1000); // Wait 1 second
// Cancellable delay
const controller = new AbortController();
const sleepPromise = sleep(5000, controller.signal);
// Cancel after 1 second
setTimeout(() => controller.abort(), 1000);
try {
await sleepPromise;
} catch (error) {
console.log('Sleep cancelled');
}
```
***
### throttle()
> **throttle**\<`TArgs`, `TReturn`>(`fn`, `wait`): (...`args`) => `TReturn` | `undefined`
Defined in: [src/utils/rateLimit.ts:39](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/rateLimit.ts#L39)
Throttle a function to execute at most once per specified wait time
The first call executes immediately, subsequent calls within the wait
period are ignored. Useful for rate-limiting user actions or events.
#### Type Parameters
##### TArgs
`TArgs` *extends* `unknown`\[]
Function argument types
##### TReturn
`TReturn`
Function return type
#### Parameters
##### fn
(...`args`) => `TReturn`
Function to throttle
##### wait
`number`
Wait time in milliseconds
#### Returns
Throttled function
> (...`args`): `TReturn` | `undefined`
##### Parameters
###### args
...`TArgs`
##### Returns
`TReturn` | `undefined`
#### Example
```typescript theme={null}
// Throttle RPC calls
const getBalance = throttle(
(address: string) => provider.eth_getBalance(address),
1000 // Max once per second
);
// Multiple rapid calls - only first executes
getBalance('0x123...'); // Executes immediately
getBalance('0x456...'); // Ignored (within 1s)
getBalance('0x789...'); // Ignored (within 1s)
```
***
### withRetry()
> **withRetry**\<`TArgs`, `TReturn`>(`fn`, `options`): (...`args`) => `Promise`\<`TReturn`>
Defined in: [src/utils/retryWithBackoff.ts:188](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/retryWithBackoff.ts#L188)
Create a retry wrapper for a function
Returns a new function that automatically retries with the given configuration.
Useful for wrapping provider methods or other frequently-called functions.
#### Type Parameters
##### TArgs
`TArgs` *extends* `unknown`\[]
Function argument types
##### TReturn
`TReturn`
Function return type
#### Parameters
##### fn
(...`args`) => `Promise`\<`TReturn`>
Function to wrap with retry logic
##### options
[`RetryOptions`](#retryoptions) = `{}`
Retry configuration
#### Returns
Wrapped function with automatic retry
> (...`args`): `Promise`\<`TReturn`>
##### Parameters
###### args
...`TArgs`
##### Returns
`Promise`\<`TReturn`>
#### Example
```typescript theme={null}
// Wrap provider method with automatic retry
const getBlockNumberWithRetry = withRetry(
(provider: Provider) => provider.eth_blockNumber(),
{ maxRetries: 5, initialDelay: 500 }
);
const blockNumber = await getBlockNumberWithRetry(provider);
// Wrap custom function
const fetchWithRetry = withRetry(
async (url: string) => {
const res = await fetch(url);
if (!res.ok) throw new Error('Request failed');
return res.json();
},
{ maxRetries: 3 }
);
const data = await fetchWithRetry('https://api.example.com/data');
```
***
### withTimeout()
> **withTimeout**\<`T`>(`promise`, `options`): `Promise`\<`T`>
Defined in: [src/utils/timeout.ts:65](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L65)
Wrap a promise with a timeout
Races the promise against a timeout. If the promise doesn't resolve
within the specified time, throws a TimeoutError. Supports AbortSignal
for cancellation.
#### Type Parameters
##### T
`T`
Promise result type
#### Parameters
##### promise
`Promise`\<`T`>
Promise to add timeout to
##### options
[`TimeoutOptions`](#timeoutoptions)
Timeout configuration
#### Returns
`Promise`\<`T`>
Promise that resolves to original result or throws TimeoutError
#### Throws
TimeoutError if timeout is reached
#### Throws
Error if AbortSignal is triggered
#### Example
```typescript theme={null}
// Basic timeout
const result = await withTimeout(
provider.eth_getBlockByNumber('latest'),
{ ms: 5000 }
);
// Custom timeout message
const balance = await withTimeout(
provider.eth_getBalance(address),
{
ms: 10000,
message: 'Balance fetch timed out after 10s'
}
);
// With AbortController
const controller = new AbortController();
const dataPromise = withTimeout(
fetchData(),
{ ms: 30000, signal: controller.signal }
);
// Cancel operation
controller.abort();
```
***
### wrapWithTimeout()
> **wrapWithTimeout**\<`TArgs`, `TReturn`>(`fn`, `ms`, `message?`): (...`args`) => `Promise`\<`TReturn`>
Defined in: [src/utils/timeout.ts:132](https://github.com/evmts/voltaire/blob/bd6ec34405c15ad8cd51d11579d495dc53813482/src/utils/timeout.ts#L132)
Create a timeout wrapper for a function
Returns a new function that automatically adds a timeout to calls.
Useful for wrapping provider methods or other async functions.
#### Type Parameters
##### TArgs
`TArgs` *extends* `unknown`\[]
Function argument types
##### TReturn
`TReturn`
Function return type
#### Parameters
##### fn
(...`args`) => `Promise`\<`TReturn`>
Function to wrap with timeout
##### ms
`number`
Timeout in milliseconds
##### message?
`string`
Optional timeout message
#### Returns
Function with automatic timeout
> (...`args`): `Promise`\<`TReturn`>
##### Parameters
###### args
...`TArgs`
##### Returns
`Promise`\<`TReturn`>
#### Example
```typescript theme={null}
// Wrap provider method with timeout
const getBalanceWithTimeout = wrapWithTimeout(
(address: string) => provider.eth_getBalance(address),
5000
);
const balance = await getBalanceWithTimeout('0x123...');
// Wrap custom function
const fetchDataWithTimeout = wrapWithTimeout(
async (url: string) => {
const res = await fetch(url);
return res.json();
},
10000,
'Data fetch timeout'
);
```
# Getting Started
Source: https://voltaire.tevm.sh/getting-started
Install Voltaire and explore the API
Looking to learn more about why to use Voltaire? Check out [What is Voltaire?](/introduction)
Try it live: open the Playground to experiment with Voltaire primitives in your browser.
## Prerequisites
* **Node.js:** 18+ (20+ recommended)
* **Package Manager:** npm, bun, pnpm, or yarn
* **Knowledge:** Basic JavaScript/TypeScript
New to Ethereum? Check out our [Skills](/skills) for example-based patterns with working code you can copy into your project.
## Installation
```bash theme={null}
npm install @tevm/voltaire
```
```bash theme={null}
bun add @tevm/voltaire
```
```bash theme={null}
pnpm add @tevm/voltaire
```
```bash theme={null}
yarn add @tevm/voltaire
```
Zig requires building native dependencies first. See [Multiplatform Installation](/getting-started/multiplatform#installation-by-language) for complete instructions.
```bash theme={null}
# Clone and build (requires Rust/Cargo)
git clone https://github.com/evmts/voltaire.git
cd voltaire && zig build
```
`zig fetch` alone will not work - native Rust crypto libraries must be built via Cargo first.
Prefer importing from `"voltaire"` instead of `"@tevm/voltaire"`? Install with an alias:
```bash theme={null}
# npm
npm install voltaire@npm:@tevm/voltaire
# bun
bun add voltaire@npm:@tevm/voltaire
# pnpm
pnpm add voltaire@npm:@tevm/voltaire
# yarn
yarn add voltaire@npm:@tevm/voltaire
```
Then import as `import { Address } from "voltaire"`.
Runtime support: Native FFI is currently supported on Bun. In Node.js, use the regular TypeScript API or the WASM modules. Browsers use WASM.
## Imports
```typescript theme={null}
import {
Abi,
AccessList,
Address,
Authorization,
Base64,
BinaryTree,
Blob,
BloomFilter,
Bytecode,
Chain,
ChainId,
Denomination,
Ens,
EventLog,
FeeMarket,
GasConstants,
Hardfork,
Hash,
Hex,
Int,
Nonce,
Opcode,
PrivateKey,
PublicKey,
Rlp,
Signature,
Siwe,
State,
Transaction,
Uint
} from "@tevm/voltaire";
```
```typescript theme={null}
import {
AesGcm,
Bip39,
Blake2,
Bls12381,
Bn254,
Ed25519,
EIP712,
HDWallet,
Keccak256,
Kzg,
P256,
Pbkdf2,
Poseidon,
Ripemd160,
Schnorr,
Secp256k1,
Secp256r1,
Sha256,
Sha3,
Sha512,
X25519
} from "@tevm/voltaire";
```
```typescript theme={null}
import {
Opcode,
Bytecode,
GasConstants
} from "@tevm/voltaire";
```
```typescript theme={null}
import {
Base64,
Hex,
Rlp
} from "@tevm/voltaire";
```
```typescript theme={null}
import { Provider } from "@tevm/voltaire";
```
## Import Paths
* Default ergonomic: `import { Address, Hex } from '@tevm/voltaire'`
* Tree-shakable subpaths: `import { Address } from '@tevm/voltaire/Address'`
* Avoid: `@tevm/voltaire/primitives/*`, `tevm/*`, `@voltaire/*`
* Aliasing: with `voltaire@npm:@tevm/voltaire`, you can `import { Address } from 'voltaire'` and still use the same subpaths for tree-shaking.
## Learn More
Copyable implementations: providers, contracts, React hooks, and more
Experiment interactively with Voltaire primitives in your browser
Learn why to use Voltaire and what makes it unique
Understand branded types and the data-first design pattern
Use AI to generate custom Skills for your contracts
## API Reference
### Primitives
#### ABI
ABI encoding and decoding. Supports functions, events, errors, and constructors per the [ABI specification](https://docs.soliditylang.org/en/latest/abi-spec.html).
[View docs →](/primitives/abi)
#### AccessList
EIP-2930 transaction access lists for optimized state access costs.
[View docs →](/primitives/accesslist)
#### Address
20-byte Ethereum addresses with EIP-55 checksumming and CREATE/CREATE2 calculation.
[View docs →](/primitives/address)
#### Authorization
EIP-7702 authorization lists for account abstraction code delegation.
[View docs →](/primitives/authorization)
#### Base64
RFC 4648 Base64 encoding and decoding.
[View docs →](/primitives/base64)
#### BinaryTree
Binary tree structures for Merkle trees and similar data structures.
[View docs →](/primitives/binarytree)
#### Blob
EIP-4844 blob transaction data (128KB blobs).
[View docs →](/primitives/blob)
#### BloomFilter
Ethereum log bloom filters for efficient log filtering.
[View docs →](/primitives/bloomfilter)
#### Bytecode
Contract bytecode manipulation, analysis, and metadata handling.
[View docs →](/primitives/bytecode)
#### Chain
Chain configuration and network parameters.
[View docs →](/primitives/chain)
#### ChainId
Network identifiers (mainnet, testnets, L2s).
[View docs →](/primitives/chainid)
#### Denomination
Ether denomination conversions (wei, gwei, ether).
[View docs →](/primitives/denomination)
#### Ens
ENS name normalization per ENSIP-15.
[View docs →](/primitives/ens)
#### EventLog
Transaction event log parsing and filtering.
[View docs →](/primitives/eventlog)
#### FeeMarket
EIP-1559 fee market calculations (base fee, priority fee).
[View docs →](/primitives/feemarket)
#### GasConstants
EVM gas costs per the Yellow Paper specification.
[View docs →](/primitives/gasconstants)
#### Hardfork
Network hardfork detection and feature flags.
[View docs →](/primitives/hardfork)
#### Hash
32-byte hash type with constant-time operations.
[View docs →](/primitives/hash)
#### Hex
Hexadecimal encoding with sized types and manipulation utilities.
[View docs →](/primitives/hex)
#### Int
Signed integer types (Int8, Int16, Int32, Int64, Int128, Int256).
[View docs →](/primitives/int)
#### Nonce
Transaction nonce management.
[View docs →](/primitives/nonce)
#### Opcode
EVM opcodes with gas costs and metadata.
[View docs →](/primitives/opcode)
#### PrivateKey
Private key operations including signing and address derivation.
[View docs →](/primitives/privatekey)
#### PublicKey
Public key operations including verification and address derivation.
[View docs →](/primitives/publickey)
#### Rlp
Recursive Length Prefix encoding and decoding.
[View docs →](/primitives/rlp)
#### Signature
ECDSA signatures (secp256k1, P-256, Ed25519) with recovery and normalization.
[View docs →](/primitives/signature)
#### Siwe
Sign-In with Ethereum (EIP-4361) authentication.
[View docs →](/primitives/siwe)
#### State
Account state management and storage slots.
[View docs →](/primitives/state)
#### Transaction
All Ethereum transaction types (Legacy, EIP-2930, EIP-1559, EIP-4844, EIP-7702).
[View docs →](/primitives/transaction)
#### Uint
Unsigned integer types (Uint8, Uint16, Uint32, Uint64, Uint128, Uint256).
[View docs →](/primitives/uint)
### Cryptography
#### AesGcm
AES-GCM authenticated encryption per NIST SP 800-38D.
[View docs →](/crypto/aesgcm)
#### Bip39
BIP-39 mnemonic phrase generation and validation.
[View docs →](/crypto/bip39)
#### Blake2
Blake2 hash function per RFC 7693.
[View docs →](/crypto/blake2)
#### Bls12381
BLS12-381 elliptic curve operations for Ethereum consensus layer.
[View docs →](/crypto/bls12381)
#### Bn254
BN254 (alt\_bn128) elliptic curve for zkSNARK verification.
[View docs →](/crypto/bn254)
#### Ed25519
Ed25519 EdDSA signatures per RFC 8032.
[View docs →](/crypto/ed25519)
#### EIP712
EIP-712 typed structured data signing.
[View docs →](/crypto/eip712)
#### HDWallet
BIP-32/BIP-44 hierarchical deterministic wallet key derivation.
[View docs →](/crypto/hdwallet)
#### Keccak256
Keccak-256 hash function (primary Ethereum hash) per FIPS 202.
[View docs →](/crypto/keccak256)
#### Kzg
KZG polynomial commitments for EIP-4844 blob verification.
[View docs →](/crypto/kzg)
#### P256
NIST P-256 (secp256r1) elliptic curve per FIPS 186-5.
[View docs →](/crypto/p256)
#### Pbkdf2
PBKDF2 key derivation function.
[View docs →](/crypto/pbkdf2)
#### Poseidon
Poseidon hash function for zero-knowledge proofs.
[View docs →](/crypto/poseidon)
#### Ripemd160
RIPEMD-160 hash function.
[View docs →](/crypto/ripemd160)
#### Schnorr
Schnorr signatures for Bitcoin compatibility.
[View docs →](/crypto/schnorr)
#### Secp256k1
Secp256k1 ECDSA for Ethereum transaction signing.
[View docs →](/crypto/secp256k1)
#### Secp256r1
Secp256r1 (P-256) ECDSA signatures.
[View docs →](/crypto/secp256r1)
#### Sha256
SHA-256 hash function per FIPS 180-4.
[View docs →](/crypto/sha256)
#### Sha3
SHA-3 hash function family per FIPS 202.
[View docs →](/crypto/sha3)
#### Sha512
SHA-512 hash function per FIPS 180-4.
[View docs →](/crypto/sha512)
#### X25519
X25519 ECDH key exchange per RFC 7748.
[View docs →](/crypto/x25519)
# Safe Ethereum
Source: https://voltaire.tevm.sh/getting-started/branded-types
Modern type safety with branded types
Voltaire provides runtime safety without third-party validation libraries. Every primitive validates at construction, giving you type-safe, runtime-verified values.
## The Problem
### Type Confusion
TypeScript's structural typing means types with the same structure are interchangeable:
```typescript theme={null}
type Address = `0x${string}`;
type Bytecode = `0x${string}`;
function simulateTransfer(to: Address, bytecode: Bytecode) { }
const address: Address = "0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e";
const bytecode: Bytecode = "0x60806040";
// Arguments swapped - compiles fine, breaks at runtime!
simulateTransfer(bytecode, address); // ✓ No error
```
### Casing Bugs
String-based addresses have casing inconsistencies:
```typescript theme={null}
const addr1 = "0x742d35cc6634c0532925a3b844bc9e7595f51e3e"; // lowercase
const addr2 = "0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e"; // checksummed
addr1 === addr2; // false - same address!
```
## The Solution
[Branded types](https://prosopo.io/blog/typescript-branding/) add compile-time tags that prevent mixing incompatible types:
```typescript theme={null}
import { Address, Bytecode } from '@tevm/voltaire'
function simulateTransfer(to: Address, bytecode: Bytecode) { }
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
const bytecode = Bytecode('0x60806040')
simulateTransfer(bytecode, address)
// Error: Type 'Bytecode' is not assignable to type 'Address'
```
For casing, Voltaire uses `Uint8Array` internally:
```typescript theme={null}
const addr1 = Address('0x742d35cc6634c0532925a3b844bc9e7595f51e3e')
const addr2 = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
Address.equals(addr1, addr2) // true
```
## Validation at Construction
Invalid inputs throw immediately:
```typescript theme={null}
Address('0xnot_valid_hex') // Error: Invalid hex character
Address('0x123') // Error: Invalid address length
Address(new Uint8Array(10)) // Error: Address must be exactly 20 bytes
// For checksum validation, use ChecksummedAddress
ChecksummedAddress('0x742d35cc6634c0532925a3b844bc9e7595f51e3E')
// Error: Invalid checksum
```
**If you see a branded type, it's validated.** Any `AddressType` value is guaranteed valid.
## Benefits
Can't mix Address with Hash or Bytecode
Brand only exists in TypeScript's type checker
Compile errors help AI assistants self-correct
Validation built into constructors
## Learn More
Complete guide to branded types
Complete Address API reference
# Agentic Coding
Source: https://voltaire.tevm.sh/getting-started/llm-optimized
Get maximum AI productivity with Voltaire using local context or MCP
## Recommended: Clone the Repo
Top AI engineers get the best results by cloning the entire Voltaire repository locally. This provides maximum context for your AI coding assistant.
**This is the recommended approach.** Having the full source code locally gives AI assistants complete context - they can read implementations, understand patterns, and provide more accurate code.
```bash theme={null}
git clone https://github.com/evmts/voltaire.git
```
Once cloned, point your AI assistant to the repo when working on Ethereum projects. The codebase includes comprehensive inline documentation, tests, and examples.
## llms.txt
Voltaire provides machine-readable documentation at standard endpoints:
* **[/llms.txt](https://voltaire.tevm.sh/llms.txt)** - Concise summary for quick context
* **[/llms-full.txt](https://voltaire.tevm.sh/llms-full.txt)** - Complete documentation in plain text
These follow the [llms.txt standard](https://llmstxt.org/) and can be fetched by AI assistants to understand Voltaire's API without needing the full repo.
## MCP Server
For AI assistants that support [Model Context Protocol](https://modelcontextprotocol.io/), Voltaire provides an MCP server with searchable documentation.
```bash theme={null}
claude mcp add --transport http voltaire https://voltaire.tevm.sh/mcp
```
Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json theme={null}
{
"mcpServers": {
"voltaire": {
"command": "npx",
"args": ["mcp-remote", "https://voltaire.tevm.sh/mcp"]
}
}
}
```
Add to `.cursor/mcp.json`:
```json theme={null}
{
"mcpServers": {
"voltaire": {
"command": "npx",
"args": ["mcp-remote", "https://voltaire.tevm.sh/mcp"]
}
}
}
```
Add to `~/.codex/config.toml`:
```toml theme={null}
[mcp_servers.voltaire]
url = "https://voltaire.tevm.sh/mcp"
```
Add to `~/.config/amp/settings.json`:
```json theme={null}
{
"mcpServers": {
"voltaire": {
"url": "https://voltaire.tevm.sh/mcp"
}
}
}
```
Add to `~/.config/opencode/opencode.json`:
```json theme={null}
{
"mcp": {
"voltaire": {
"type": "remote",
"url": "https://voltaire.tevm.sh/mcp"
}
}
}
```
Add to `~/.codeium/windsurf/mcp_config.json`:
```json theme={null}
{
"mcpServers": {
"voltaire": {
"command": "npx",
"args": ["mcp-remote", "https://voltaire.tevm.sh/mcp"]
}
}
}
```
The MCP server provides a `SearchVoltaire` tool that searches across all documentation, returning relevant code examples and API references.
## Why Local Context Works Best
The MCP server is convenient, but cloning the repo locally provides:
* **Full source code** - AI can read actual implementations, not just docs
* **Test examples** - Real-world usage patterns in test files
* **Type definitions** - Complete TypeScript types for accurate suggestions
* **Build context** - Understanding of how modules connect
Most production teams using AI-assisted development keep frequently-used libraries cloned locally for this reason.
## API Design for AI
Voltaire's API is designed to work well with AI assistants:
**Mirrors Ethereum specs** - LLMs trained on Ethereum documentation can leverage that knowledge directly. No bespoke abstractions to learn.
**Minimal abstraction** - What you pass to a function is what happens. No hidden retry policies, automatic caching, or magic behavior that confuses debugging.
**Predictable patterns** - Every primitive follows the same conventions: `Type()` constructor, `.toHex()`, `.equals()`, etc.
```typescript theme={null}
// Voltaire API maps directly to Ethereum concepts
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e');
const hash = Keccak256(new TextEncoder().encode('hello'));
const fn = Abi.Function(transferAbi);
const encoded = fn.encodeParams([to, amount]);
```
## Smart LLM Detection
When AI assistants query Voltaire documentation, we detect the request and return optimized markdown instead of HTML. This reduces token usage and improves response quality.
# Multiplatform
Source: https://voltaire.tevm.sh/getting-started/multiplatform
Works everywhere - TypeScript, Zig, and any language with C-FFI
Works everywhere. TypeScript, Zig, any language with C-FFI.
## TypeScript Entrypoints
Voltaire provides three entrypoints with identical APIs for different performance profiles:
```typescript theme={null}
import { Address, Keccak256 } from '@tevm/voltaire' // JS (default)
import { Address, Keccak256 } from '@tevm/voltaire/wasm' // WASM
import { Address, Keccak256 } from '@tevm/voltaire/native' // Native FFI (Bun only)
```
All entrypoints implement the same [`VoltaireAPI` interface](https://github.com/evmts/voltaire/blob/main/src/api-interface.ts) - switch by changing the import path.
For detailed performance comparisons and choosing the right entrypoint, see [Runtime Implementations](/getting-started/wasm).
## Installation by Language
```bash theme={null}
npm install @tevm/voltaire
# or: bun add @tevm/voltaire / pnpm add @tevm/voltaire / yarn add @tevm/voltaire
```
Then import from any entrypoint:
```typescript theme={null}
// JS (default) - works everywhere
import { Address, Keccak256 } from '@tevm/voltaire'
// WASM - for browser/edge crypto performance
import { Address, Keccak256 } from '@tevm/voltaire/wasm'
// Native - for Bun maximum performance
import { Address, Keccak256 } from '@tevm/voltaire/native'
```
**Important:** Voltaire requires native C/Rust libraries that must be built before use. `zig fetch` alone will not work because the Rust crypto wrappers (`libcrypto_wrappers.a`) are built at compile time via Cargo.
**Option 1: Git Submodule (Recommended)**
Add as a git submodule in your project:
```bash theme={null}
git submodule add https://github.com/evmts/voltaire.git lib/voltaire
cd lib/voltaire
zig build # Builds Rust/C dependencies via Cargo
```
Then in your `build.zig`:
```zig theme={null}
const voltaire = b.dependency("voltaire", .{
.target = target,
.optimize = optimize,
});
// Add modules to your executable/library
exe.root_module.addImport("primitives", voltaire.module("primitives"));
exe.root_module.addImport("crypto", voltaire.module("crypto"));
// Link required native libraries
exe.linkLibrary(voltaire.artifact("blst"));
exe.linkLibrary(voltaire.artifact("c_kzg"));
```
And in your `build.zig.zon`:
```zig theme={null}
.dependencies = .{
.voltaire = .{ .path = "lib/voltaire" },
},
```
**Option 2: Build from Source**
Clone and build once, then reference by path:
```bash theme={null}
git clone https://github.com/evmts/voltaire.git
cd voltaire
zig build # Requires Cargo/Rust installed
```
**Prerequisites for Zig builds:**
* [Zig 0.15.1+](https://ziglang.org/download/)
* [Rust/Cargo](https://rustup.rs/) - Required for native crypto wrappers
Build the C library:
```bash theme={null}
git clone https://github.com/evmts/voltaire.git
cd voltaire
zig build -Dwith-c-api=true
```
This produces:
* `zig-out/lib/libprimitives_c.a` (static library)
* `zig-out/lib/libprimitives_c.dylib` (dynamic library, macOS)
* `zig-out/include/primitives.h` (C header)
Link against the library and include the header in your project.
TypeScript, Zig, and C - fully supported with complete APIs and documentation
Swift, Go, Python, Kotlin, and any language with foreign function interface support
C-FFI bindings require manual memory management. Always call corresponding `_free` functions to prevent leaks.
## Consistent API
The Voltaire API is consistent across all languages.
```typescript theme={null}
import { Address } from '@tevm/voltaire'
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
Address.toChecksummed(address)
Address.toHex(address)
Address.isZero(address)
Address.equals(address, otherAddress)
// Also available as instance methods
address.toChecksummed()
address.toHex()
address.isZero()
address.equals(otherAddress)
```
```zig theme={null}
const Address = @import("primitives").Address;
pub fn main() !void {
const address = try Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e");
_ = address.toChecksummed();
_ = address.toHex();
_ = address.isZero();
_ = address.equals(otherAddress);
}
```
```c theme={null}
#include "primitives.h"
int main() {
Address* address = tevm_address_from_hex("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e");
char* checksummed = tevm_address_to_checksummed(address);
char* hex = tevm_address_to_hex(address);
bool is_zero = tevm_address_is_zero(address);
bool equal = tevm_address_equals(address, other_address);
// Free memory
tevm_string_free(checksummed);
tevm_string_free(hex);
tevm_address_free(address);
}
```
```swift theme={null}
import Voltaire
// Idiomatic Swift wrappers over C-FFI
let address = try Address(hex: "0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e")
print(address.checksumHex)
print(address.hex)
print(address.isZero)
let other = try Address(hex: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
print(address == other)
```
```kotlin theme={null}
import com.tevm.voltaire.Address
// JNI bindings over C-FFI
val address = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e")
println(address.checksumHex)
println(address.hex)
println(address.isZero)
val other = Address.fromHex("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
println(address == other)
```
```go theme={null}
package main
import "github.com/evmts/voltaire-go"
func main() {
address, _ := voltaire.AddressFromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e")
fmt.Println(address.ChecksumHex())
fmt.Println(address.Hex())
fmt.Println(address.IsZero())
other, _ := voltaire.AddressFromHex("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
fmt.Println(address.Equals(other))
}
```
```python theme={null}
from voltaire import Address
# ctypes/cffi bindings over C-FFI
address = Address.from_hex("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e")
print(address.checksum_hex)
print(address.hex)
print(address.is_zero)
other = Address.from_hex("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
print(address == other)
```
## Looking for Help
We're looking for contributors to help build idiomatic wrappers for:
* **Go** - Native bindings via cgo
* **Python** - Bindings via ctypes/cffi
* **Swift** - Fully implemented but lacking tests and complete documentation
* **Kotlin** - Android/JVM bindings
Interested in contributing? Check out [src/c\_api.zig](https://github.com/evmts/voltaire/blob/main/src/c_api.zig) for the C-FFI interface and [src/primitives.h](https://github.com/evmts/voltaire/blob/main/src/primitives.h) for the generated C header. Join our [Telegram](https://t.me/+ANThR9bHDLAwMjUx) or open an issue on [GitHub](https://github.com/evmts/voltaire/issues).
# Powerful Features
Source: https://voltaire.tevm.sh/getting-started/powerful-features
Bytecode analysis and EVM execution capabilities
Voltaire provides powerful bytecode analysis and EVM execution capabilities not found in other TypeScript Ethereum libraries.
## Bytecode Analysis
Parse and analyze EVM bytecode without executing it. Extract ABIs from unverified contracts, detect patterns, and debug at the opcode level.
### Extract ABI from Bytecode
Recover function selectors and events from any deployed contract—even without source code:
```typescript theme={null}
import { Bytecode } from '@tevm/voltaire'
// Fetch bytecode from any contract (verified or not)
const bytecode = Bytecode('0x608060405234801561001057600080fd5b50...')
// Extract ABI from bytecode patterns
const abi = Bytecode.toAbi(bytecode)
console.log(abi)
// [
// { type: "function", selector: "0xa9059cbb", stateMutability: "nonpayable", payable: false },
// { type: "function", selector: "0x70a08231", stateMutability: "view", payable: false },
// { type: "event", hash: "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef" }
// ]
```
### Parse Instructions
Disassemble bytecode into individual opcodes:
```typescript theme={null}
const instructions = Bytecode.parseInstructions(bytecode)
for (const inst of instructions) {
console.log(`${inst.pc}: ${inst.opcode} ${inst.pushData ?? ''}`)
}
// 0: PUSH1 0x80
// 2: PUSH1 0x40
// 4: MSTORE
// 5: CALLVALUE
// 6: DUP1
// ...
```
### Pretty Print
Human-readable bytecode disassembly:
```typescript theme={null}
console.log(Bytecode.prettyPrint(bytecode))
// 0x0000: PUSH1 0x80
// 0x0002: PUSH1 0x40
// 0x0004: MSTORE
// 0x0005: CALLVALUE
// ...
```
### Analyze Jump Destinations
Find all valid jump targets for control flow analysis:
```typescript theme={null}
const jumpDests = Bytecode.analyzeJumpDestinations(bytecode)
console.log('Valid JUMPDEST locations:', [...jumpDests])
// [16, 42, 128, 256, ...]
// Check specific location
const isValid = Bytecode.isValidJumpDest(bytecode, 0x10)
```
### Gas Analysis
Estimate gas costs per instruction:
```typescript theme={null}
const gasAnalysis = Bytecode.analyzeGas(bytecode)
console.log('Total static gas:', gasAnalysis.totalGas)
console.log('Instructions:', gasAnalysis.instructions.length)
```
### Stack Analysis
Analyze stack depth and effects:
```typescript theme={null}
const stackAnalysis = Bytecode.analyzeStack(bytecode)
console.log('Max stack depth:', stackAnalysis.maxDepth)
```
### Strip Metadata
Remove Solidity compiler metadata for cleaner analysis:
```typescript theme={null}
if (Bytecode.hasMetadata(bytecode)) {
const stripped = Bytecode.stripMetadata(bytecode)
console.log('Removed', bytecode.length - stripped.length, 'metadata bytes')
}
```
### Hash Bytecode
Compute keccak256 hash (useful for CREATE2 address prediction):
```typescript theme={null}
const codeHash = Bytecode.hash(bytecode)
console.log('Code hash:', codeHash)
```
## EVM Execution
Execute bytecode directly in TypeScript. Build execution frames, manipulate the stack, and run opcodes.
### Create Execution Frames
```typescript theme={null}
import { Frame } from '@tevm/voltaire/evm'
// Create a frame with bytecode that pushes 1 + 2
const frame = Frame({
bytecode: new Uint8Array([
0x60, 0x01, // PUSH1 1
0x60, 0x02, // PUSH1 2
0x01, // ADD
]),
gas: 100000n,
})
console.log(frame.pc) // 0
console.log(frame.gasRemaining) // 100000n
console.log(frame.stack) // []
```
### Execute Opcodes
Run individual opcodes with full gas accounting:
```typescript theme={null}
import { Frame, Arithmetic } from '@tevm/voltaire/evm'
const frame = Frame({
bytecode: new Uint8Array([0x60, 0x01, 0x60, 0x02, 0x01]),
gas: 100000n,
})
// Push values onto stack
Frame.pushStack(frame, 1n)
Frame.pushStack(frame, 2n)
// Execute ADD
const error = Arithmetic.add(frame)
console.log(frame.stack) // [3n]
console.log(error) // null (success)
```
### Stack Operations
Direct stack manipulation:
```typescript theme={null}
// Push values
Frame.pushStack(frame, 42n)
Frame.pushStack(frame, 100n)
// Pop and peek
const top = Frame.popStack(frame) // 100n
const next = Frame.peekStack(frame) // 42n (doesn't remove)
```
### Memory Operations
Read and write EVM memory:
```typescript theme={null}
// Write 32 bytes to memory offset 0
const data = new Uint8Array(32).fill(0xff)
Frame.writeMemory(frame, 0, data)
// Read 32 bytes from offset 0
const result = Frame.readMemory(frame, 0, 32)
// Calculate memory expansion cost
const cost = Frame.memoryExpansionCost(frame, 64)
```
### Gas Accounting
Track gas consumption:
```typescript theme={null}
const frame = Frame({ gas: 1000n })
// Consume gas (returns error if insufficient)
const error = Frame.consumeGas(frame, 21n)
console.log(frame.gasRemaining) // 979n
console.log(error) // null (success)
// Attempt to consume more than available
const outOfGas = Frame.consumeGas(frame, 2000n)
console.log(outOfGas) // { type: "OutOfGas" }
```
### Full Opcode Categories
All EVM opcodes are implemented:
```typescript theme={null}
import {
Arithmetic, // ADD, MUL, SUB, DIV, MOD, EXP, etc.
Bitwise, // AND, OR, XOR, NOT, SHL, SHR, SAR
Comparison, // LT, GT, SLT, SGT, EQ, ISZERO
Memory, // MLOAD, MSTORE, MSTORE8, MCOPY
Stack, // PUSH1-32, POP, DUP1-16, SWAP1-16
Control, // JUMP, JUMPI, JUMPDEST, STOP, RETURN
System, // CALL, CREATE, DELEGATECALL, SELFDESTRUCT
Log, // LOG0-LOG4
Block, // BLOCKHASH, COINBASE, TIMESTAMP, etc.
Context, // ADDRESS, CALLER, CALLVALUE, etc.
Storage, // SLOAD, SSTORE, TLOAD, TSTORE
Keccak, // SHA3
} from '@tevm/voltaire/evm'
```
Complete bytecode analysis API reference
# Runtime Implementations
Source: https://voltaire.tevm.sh/getting-started/wasm
Choose between TypeScript, WASM, and Native FFI based on your environment
Voltaire provides three entrypoints with **identical APIs**. All implement the [`VoltaireAPI` interface](https://github.com/evmts/voltaire/blob/main/src/api-interface.ts), ensuring compile-time errors if APIs diverge.
## Three Entrypoints
| Entrypoint | Import | Runtime | Use Case |
| ---------- | ----------------------- | ------------------------ | -------------------------------- |
| **JS** | `@tevm/voltaire` | Any JS runtime | Default, universal compatibility |
| **WASM** | `@tevm/voltaire/wasm` | Browser, Node, Bun, Deno | High performance, portable |
| **Native** | `@tevm/voltaire/native` | Bun | Maximum performance via FFI |
```typescript theme={null}
// All three have the SAME API
import { Address, Keccak256 } from '@tevm/voltaire' // JS (default)
import { Address, Keccak256 } from '@tevm/voltaire/wasm' // WASM
import { Address, Keccak256 } from '@tevm/voltaire/native' // Native FFI
```
All three entrypoints export identical namespaces and types. Switch implementations by changing the import path - no code changes required.
## JS (Default)
Pure TypeScript/JavaScript. Works everywhere JavaScript runs.
Shares the [ox](https://oxlib.sh) peer dependency for amortized bundle costs.
```typescript theme={null}
import { Keccak256, Address, Hex } from '@tevm/voltaire'
const hash = Keccak256.hash(Hex.toBytes(Hex.fromString('hello')))
const addr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
```
A useful default - easy to debug and performant enough for most use cases.
## WASM
WebAssembly bindings to Zig implementations. Portable high-performance.
The WASM entrypoint exports the **same API** as JS. Switch by changing the import path.
```typescript theme={null}
import { Keccak256, Secp256k1, Hex, Address } from '@tevm/voltaire/wasm'
// Same API as JS entrypoint
const hash = Keccak256.hash(data)
const recovered = Secp256k1.recoverAddress(hash, signature)
const addr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
// All namespaces work identically
Secp256k1.sign(message, privateKey)
```
We recommend WASM for crypto operations - usually faster and smaller bundle size than JS equivalents. Best for applications needing maximum performance.
Design trade-off: Voltaire’s published WASM builds target a balance of strong performance and small bundle size. If you need maximum raw speed for specific workloads, build from source using the performance-optimized target (ReleaseFast). See `/dev/build-system#typescript-targets` and `/dev/wasm#build-modes`.
## Native FFI (Bun)
Direct bindings to Zig via Bun FFI. Maximum performance.
The Native entrypoint exports the **same API** as JS. Switch by changing the import path.
```typescript theme={null}
import { Keccak256, Address, Secp256k1 } from '@tevm/voltaire/native'
// Same API as JS entrypoint
const hash = Keccak256.hash(data)
const addr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e')
const signature = Secp256k1.sign(message, privateKey)
```
Runtime support: Native FFI is Bun-only. In Node.js, use the JS or WASM entrypoint. Ensure the compiled `.dylib`/`.so`/`.dll` is available (run `zig build build-ts-native`).
## Per-Module Imports
For fine-grained control, import specific implementations:
```typescript theme={null}
// Keccak256 variants
import { Keccak256 } from '@tevm/voltaire/Keccak256' // JS (default)
import { Keccak256 } from '@tevm/voltaire/Keccak256/wasm' // WASM
import { Keccak256 } from '@tevm/voltaire/Keccak256/native' // Native FFI
```
## Performance Considerations
Performance is nuanced. WASM/Native aren't always faster than TypeScript.
**Bridging overhead**: Crossing the JS↔WASM or JS↔FFI boundary has constant overhead (\~1-10μs). For cheap operations (simple math, short string manipulation), this overhead can exceed the operation itself.
**When WASM/Native wins**:
* Cryptographic operations (keccak256, secp256k1, BLS) - 5-15x faster
* Large data encoding/decoding (RLP, ABI with big payloads)
* Batch operations that amortize bridging cost
**When JS wins**:
* Simple operations (hex encoding small values, address validation)
* String/hex formatting helpers that map to JS built-ins (for example, `toHex()`)
* Very small, trivial conversions where JS↔WASM overhead dominates
* Single-item operations with low computational cost
* When avoiding async overhead matters
**Bundle size**: For cryptography specifically, WASM is often *smaller* than equivalent pure-JS implementations. A full JS secp256k1 library can be 50-100KB, while WASM crypto modules are typically 20-40KB.
| Operation | JS | WASM | Native | Default |
| ----------------- | -- | ------ | ------ | ------- |
| keccak256 | 1x | \~5x | \~10x | JS |
| secp256k1 sign | 1x | \~8x | \~15x | JS |
| secp256k1 recover | 1x | \~8x | \~15x | JS |
| RLP encode | 1x | \~1.2x | \~1.5x | JS |
| Hex encode | 1x | \~1.1x | \~1.2x | JS |
Benchmark your actual workload. Default implementations are chosen for common use cases, but your specific access patterns may differ.
## WASM Limitations
| Module | WASM Status | Reason | Alternative |
| ---------------------- | --------------- | ---------------------------------- | --------------------------- |
| **BIP-39 / HD Wallet** | ❌ Not available | Requires libwally-core (C library) | Use native or JS entrypoint |
All other modules including BLS12-381, KZG, and BN254 work in WASM.
# Astro
Source: https://voltaire.tevm.sh/integrations/astro
Using Tevm with Astro for static and server-rendered Ethereum apps
Tevm works with Astro for static site generation and server-side rendering of Ethereum data.
## Installation
```bash theme={null}
bun add @tevm/voltaire
```
## Static Data Fetching
Fetch data at build time:
```astro theme={null}
---
// pages/address/[address].astro
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
const { address } = Astro.params
if (!address) {
return Astro.redirect('/404')
}
const addr = Address.from(address)
const [balance, nonce, code] = await Promise.all([
provider.eth.getBalance({ address: addr }),
provider.eth.getTransactionCount({ address: addr }),
provider.eth.getCode({ address: addr }),
])
const data = {
address,
balance: Wei.toEther(balance),
nonce: Number(nonce),
isContract: code.length > 2,
}
---
Address: {data.address}
Balance: {data.balance} ETH
Nonce: {data.nonce}
Type: {data.isContract ? 'Contract' : 'EOA'}
```
## Server Endpoints
Create API routes for dynamic data:
```ts theme={null}
// pages/api/balance/[address].ts
import type { APIRoute } from 'astro'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export const GET: APIRoute = async ({ params }) => {
const { address } = params
if (!address) {
return new Response(JSON.stringify({ error: 'Address required' }), {
status: 400,
headers: { 'Content-Type': 'application/json' },
})
}
try {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return new Response(JSON.stringify({
address,
balance: Wei.toEther(balance),
}), {
headers: { 'Content-Type': 'application/json' },
})
} catch (e) {
return new Response(JSON.stringify({ error: (e as Error).message }), {
status: 500,
headers: { 'Content-Type': 'application/json' },
})
}
}
```
## Static Paths for Known Addresses
Pre-generate pages for known addresses:
```astro theme={null}
---
// pages/address/[address].astro
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
export async function getStaticPaths() {
// Pre-defined addresses to generate at build time
const addresses = [
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045', // vitalik.eth
'0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
]
return addresses.map(address => ({
params: { address },
}))
}
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
const { address } = Astro.params
const addr = Address.from(address!)
const balance = await provider.eth.getBalance({ address: addr })
---
Balance: {Wei.toEther(balance)} ETH
```
## Hybrid Rendering
Use SSR for dynamic pages:
```ts theme={null}
// astro.config.mjs
export default defineConfig({
output: 'hybrid', // or 'server' for full SSR
})
```
```astro theme={null}
---
// pages/live/[address].astro
export const prerender = false // Force SSR for this page
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
const { address } = Astro.params
const addr = Address.from(address!)
const balance = await provider.eth.getBalance({ address: addr })
---
Live Balance: {Wei.toEther(balance)} ETH
Fetched at: {new Date().toISOString()}
```
## React/Vue/Solid Islands
Use framework components for interactivity:
```astro theme={null}
---
// pages/dashboard.astro
import BalanceChecker from '../components/BalanceChecker.tsx'
---
Ethereum Dashboard
(null)
const [loading, setLoading] = useState(false)
async function checkBalance() {
if (!address) return
setLoading(true)
try {
const addr = Address.from(address)
const result = await provider.eth.getBalance({ address: addr })
setBalance(Wei.toEther(result))
} finally {
setLoading(false)
}
}
return (
setAddress(e.target.value)}
placeholder="Enter address"
/>
{balance && Balance: {balance} ETH
}
)
}
```
## Content Collections
Generate pages from a collection of addresses:
```ts theme={null}
// content/config.ts
import { defineCollection, z } from 'astro:content'
const addresses = defineCollection({
type: 'data',
schema: z.object({
address: z.string(),
name: z.string(),
description: z.string().optional(),
}),
})
export const collections = { addresses }
```
```json theme={null}
// content/addresses/vitalik.json
{
"address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
"name": "Vitalik Buterin",
"description": "Ethereum co-founder"
}
```
```astro theme={null}
---
// pages/addresses/[slug].astro
import { getCollection, getEntry } from 'astro:content'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
export async function getStaticPaths() {
const entries = await getCollection('addresses')
return entries.map(entry => ({
params: { slug: entry.id },
props: { entry },
}))
}
const { entry } = Astro.props
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
const addr = Address.from(entry.data.address)
const balance = await provider.eth.getBalance({ address: addr })
---
{entry.data.name}
{entry.data.description}
Address: {entry.data.address}
Balance: {Wei.toEther(balance)} ETH
```
## Middleware for Caching
Add caching headers:
```ts theme={null}
// middleware.ts
import { defineMiddleware } from 'astro:middleware'
export const onRequest = defineMiddleware(async (context, next) => {
const response = await next()
// Cache API responses
if (context.url.pathname.startsWith('/api/')) {
response.headers.set('Cache-Control', 'public, max-age=10')
}
return response
})
```
## Environment Variables
Configure RPC URL:
```ts theme={null}
// env.d.ts
interface ImportMetaEnv {
readonly PUBLIC_RPC_URL: string
}
interface ImportMeta {
readonly env: ImportMetaEnv
}
```
```ts theme={null}
// lib/provider.ts
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
export const provider = createJsonRpcProvider(
import.meta.env.PUBLIC_RPC_URL || 'https://eth.llamarpc.com'
)
```
## Build-time Data
Fetch data during build:
```ts theme={null}
// lib/buildData.ts
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
// This runs at build time
export async function getTopContracts() {
const contracts = [
'0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
'0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
'0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
]
return Promise.all(
contracts.map(async (address) => {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return { address, balance: Wei.toEther(balance) }
})
)
}
```
```astro theme={null}
---
import { getTopContracts } from '../lib/buildData'
const contracts = await getTopContracts()
---
{contracts.map(c => (
- {c.address}: {c.balance} ETH
))}
```
## Next Steps
* [JSONRPCProvider](/jsonrpc-provider) - Full provider documentation
* [Address](/primitives/address) - Address primitive reference
# Solid
Source: https://voltaire.tevm.sh/integrations/solid
Using Tevm with SolidJS and SolidStart
Tevm integrates with SolidJS using signals and resources for reactive data fetching.
## Installation
```bash theme={null}
bun add @tevm/voltaire
```
## Basic Resource Pattern
Use `createResource` for async data:
```tsx theme={null}
// components/Balance.tsx
import { createResource, Show } from 'solid-js'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
async function fetchBalance(address: string) {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return Wei.toEther(balance)
}
function Balance(props: { address: string }) {
const [balance, { refetch }] = createResource(() => props.address, fetchBalance)
return (
Loading...}>
Error: {balance.error.message}}>
Balance: {balance()} ETH
)
}
```
## SolidStart Server Functions
Fetch data server-side:
```tsx theme={null}
// routes/address/[address].tsx
import { createAsync, type RouteDefinition } from '@solidjs/router'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
async function getAddressData(address: string) {
'use server'
const addr = Address.from(address)
const [balance, nonce, code] = await Promise.all([
provider.eth.getBalance({ address: addr }),
provider.eth.getTransactionCount({ address: addr }),
provider.eth.getCode({ address: addr }),
])
return {
address,
balance: Wei.toEther(balance),
nonce: Number(nonce),
isContract: code.length > 2,
}
}
export const route: RouteDefinition = {
load: ({ params }) => getAddressData(params.address),
}
export default function AddressPage(props: { params: { address: string } }) {
const data = createAsync(() => getAddressData(props.params.address))
return (
{(d) => (
{d().address}
Balance: {d().balance} ETH
Nonce: {d().nonce}
Type: {d().isContract ? 'Contract' : 'EOA'}
)}
)
}
```
## Signals for Reactive State
Create reactive Ethereum state:
```tsx theme={null}
import { createSignal, createEffect } from 'solid-js'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function AddressInput() {
const [address, setAddress] = createSignal('')
const [balance, setBalance] = createSignal(null)
const [loading, setLoading] = createSignal(false)
createEffect(async () => {
const addr = address()
if (addr.length !== 42) return
setLoading(true)
try {
const parsedAddr = Address.from(addr)
const result = await provider.eth.getBalance({ address: parsedAddr })
setBalance(Wei.toEther(result))
} finally {
setLoading(false)
}
})
return (
setAddress(e.currentTarget.value)}
placeholder="Enter address"
/>
Loading...
Balance: {balance()} ETH
)
}
```
## Polling with createEffect
Poll for block updates:
```tsx theme={null}
import { createSignal, onCleanup } from 'solid-js'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useLatestBlock() {
const [blockNumber, setBlockNumber] = createSignal(null)
const fetchBlock = async () => {
setBlockNumber(await provider.eth.getBlockNumber())
}
fetchBlock()
const interval = setInterval(fetchBlock, 12000)
onCleanup(() => clearInterval(interval))
return blockNumber
}
function BlockDisplay() {
const blockNumber = useLatestBlock()
return Latest Block: {blockNumber()?.toString() ?? 'Loading...'}
}
```
## Multiple Resources
Fetch multiple addresses:
```tsx theme={null}
import { createResource, For, Show } from 'solid-js'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
async function fetchBalances(addresses: string[]) {
return Promise.all(
addresses.map(async (addr) => {
const parsedAddr = Address.from(addr)
const balance = await provider.eth.getBalance({ address: parsedAddr })
return { address: addr, balance: Wei.toEther(balance) }
})
)
}
function MultiBalance(props: { addresses: string[] }) {
const [balances] = createResource(() => props.addresses, fetchBalances)
return (
Loading...}>
{(item) => (
{item.address}: {item.balance} ETH
)}
)
}
```
## Context for Provider
Share provider across components:
```tsx theme={null}
// context/ethereum.tsx
import { createContext, useContext, type ParentComponent } from 'solid-js'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
type Provider = ReturnType
const EthereumContext = createContext()
export const EthereumProvider: ParentComponent<{ url: string }> = (props) => {
const provider = createJsonRpcProvider(props.url)
return (
{props.children}
)
}
export function useProvider() {
const provider = useContext(EthereumContext)
if (!provider) throw new Error('useProvider must be used within EthereumProvider')
return provider
}
```
```tsx theme={null}
// App.tsx
import { EthereumProvider } from './context/ethereum'
function App() {
return (
)
}
```
## Store Pattern
Use Solid stores for complex state:
```tsx theme={null}
import { createStore } from 'solid-js/store'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function createEthereumStore() {
const [state, setState] = createStore({
balances: {} as Record,
blockNumber: null as bigint | null,
loading: false,
})
const actions = {
async fetchBalance(address: string) {
setState('loading', true)
try {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
setState('balances', address, Wei.toEther(balance))
} finally {
setState('loading', false)
}
},
async fetchBlockNumber() {
setState('blockNumber', await provider.eth.getBlockNumber())
},
}
return { state, ...actions }
}
// Usage
const store = createEthereumStore()
store.fetchBalance('0x...')
```
## Suspense Integration
Use with Solid's Suspense:
```tsx theme={null}
import { Suspense, createResource } from 'solid-js'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function Balance(props: { address: string }) {
const [balance] = createResource(async () => {
const addr = Address.from(props.address)
const result = await provider.eth.getBalance({ address: addr })
return Wei.toEther(result)
})
return Balance: {balance()} ETH
}
function App() {
return (
Loading...}>
)
}
```
## Error Boundaries
Handle errors gracefully:
```tsx theme={null}
import { ErrorBoundary, createResource, Show } from 'solid-js'
function BalanceWithError(props: { address: string }) {
const [balance] = createResource(async () => {
// Fetch logic that may throw
})
return (
Error: {err.message}
}>
Balance: {balance()} ETH
)
}
```
## Next Steps
* [JSONRPCProvider](/jsonrpc-provider) - Full provider documentation
* [Address](/primitives/address) - Address primitive reference
# Svelte
Source: https://voltaire.tevm.sh/integrations/svelte
Using Tevm with Svelte and SvelteKit
Tevm integrates with Svelte using stores and SvelteKit's load functions for server-side data fetching.
## Installation
```bash theme={null}
bun add @tevm/voltaire
```
## Basic Store Pattern
Create reactive stores for Ethereum data:
```ts theme={null}
// lib/ethereum.ts
import { writable, derived } from 'svelte/store'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export function createBalanceStore(address: string) {
const { subscribe, set } = writable(null)
const loading = writable(true)
const error = writable(null)
async function fetch() {
loading.set(true)
error.set(null)
try {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
set(Wei.toEther(balance))
} catch (e) {
error.set(e as Error)
} finally {
loading.set(false)
}
}
fetch()
return {
subscribe,
loading,
error,
refresh: fetch,
}
}
```
```svelte theme={null}
{#if $balance.loading}
Loading...
{:else if $balance.error}
Error: {$balance.error.message}
{:else}
Balance: {$balance} ETH
{/if}
```
## SvelteKit Load Functions
Fetch data server-side with SvelteKit:
```ts theme={null}
// routes/address/[address]/+page.server.ts
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
import type { PageServerLoad } from './$types'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export const load: PageServerLoad = async ({ params }) => {
const addr = Address.from(params.address)
const [balance, nonce, code] = await Promise.all([
provider.eth.getBalance({ address: addr }),
provider.eth.getTransactionCount({ address: addr }),
provider.eth.getCode({ address: addr }),
])
return {
address: params.address,
balance: Wei.toEther(balance),
nonce: Number(nonce),
isContract: code.length > 2,
}
}
```
```svelte theme={null}
Address: {data.address}
Balance: {data.balance} ETH
Nonce: {data.nonce}
Type: {data.isContract ? 'Contract' : 'EOA'}
```
## Reactive Polling
Poll for block updates:
```ts theme={null}
// lib/blocks.ts
import { readable } from 'svelte/store'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export const latestBlock = readable(null, (set) => {
const fetchBlock = async () => {
const blockNumber = await provider.eth.getBlockNumber()
set(blockNumber)
}
fetchBlock()
const interval = setInterval(fetchBlock, 12000)
return () => clearInterval(interval)
})
```
```svelte theme={null}
Latest Block: {$latestBlock?.toString() ?? 'Loading...'}
```
## Derived Stores
Compute values from multiple stores:
```ts theme={null}
// lib/account.ts
import { derived, writable } from 'svelte/store'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export const currentAddress = writable(null)
export const accountData = derived(
currentAddress,
($address, set) => {
if (!$address) {
set(null)
return
}
const fetchData = async () => {
const addr = Address.from($address)
const [balance, nonce] = await Promise.all([
provider.eth.getBalance({ address: addr }),
provider.eth.getTransactionCount({ address: addr }),
])
set({
address: $address,
balance: Wei.toEther(balance),
nonce: Number(nonce),
})
}
fetchData()
},
null as { address: string; balance: string; nonce: number } | null
)
```
## Custom Async Store
Reusable async store factory:
```ts theme={null}
// lib/asyncStore.ts
import { writable, type Readable } from 'svelte/store'
interface AsyncStore extends Readable {
loading: Readable
error: Readable
refresh: () => Promise
}
export function asyncStore(fetcher: () => Promise): AsyncStore {
const data = writable(null)
const loading = writable(true)
const error = writable(null)
async function refresh() {
loading.set(true)
error.set(null)
try {
const result = await fetcher()
data.set(result)
} catch (e) {
error.set(e as Error)
} finally {
loading.set(false)
}
}
refresh()
return {
subscribe: data.subscribe,
loading: { subscribe: loading.subscribe },
error: { subscribe: error.subscribe },
refresh,
}
}
```
```ts theme={null}
// Usage
import { asyncStore } from '$lib/asyncStore'
import { Address } from '@tevm/voltaire/Address'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
const balance = asyncStore(() =>
provider.eth.getBalance({
address: Address.from('0x...')
})
)
```
## Actions for Transactions
Use Svelte actions for form submissions:
```svelte theme={null}
{status}
```
## Context API
Share provider across components:
```ts theme={null}
// lib/context.ts
import { getContext, setContext } from 'svelte'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const PROVIDER_KEY = Symbol('provider')
export function setProvider(url: string) {
const provider = createJsonRpcProvider(url)
setContext(PROVIDER_KEY, provider)
return provider
}
export function getProvider() {
return getContext(PROVIDER_KEY)
}
```
```svelte theme={null}
Loading...
{:else if balance}
Balance: {balance} ETH
{/if}
```
## Next Steps
* [JSONRPCProvider](/jsonrpc-provider) - Full provider documentation
* [Address](/primitives/address) - Address primitive reference
# TanStack Query
Source: https://voltaire.tevm.sh/integrations/tanstack-query
Using Tevm with TanStack Query for React data fetching
TanStack Query (React Query) integrates seamlessly with Tevm for fetching and caching Ethereum data in React applications.
## Installation
```bash theme={null}
bun add @tanstack/react-query @tevm/voltaire
```
## Setup
Wrap your app with `QueryClientProvider`:
```tsx theme={null}
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
const queryClient = new QueryClient()
function App() {
return (
)
}
```
## Basic Usage
### Fetching Address Balance
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useBalance(address: string) {
return useQuery({
queryKey: ['balance', address],
queryFn: async () => {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return Wei.toEther(balance)
},
staleTime: 10_000, // 10 seconds
})
}
function BalanceDisplay({ address }: { address: string }) {
const { data: balance, isLoading, error } = useBalance(address)
if (isLoading) return Loading...
if (error) return Error: {error.message}
return Balance: {balance} ETH
}
```
### Fetching Block Data
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useBlock(blockNumber?: bigint | 'latest') {
return useQuery({
queryKey: ['block', blockNumber?.toString() ?? 'latest'],
queryFn: () => provider.eth.getBlockByNumber({
blockNumber: blockNumber ?? 'latest',
includeTransactions: false,
}),
staleTime: blockNumber === 'latest' ? 12_000 : Infinity,
})
}
```
### Transaction History
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useTransactionCount(address: string) {
return useQuery({
queryKey: ['txCount', address],
queryFn: async () => {
const addr = Address.from(address)
return provider.eth.getTransactionCount({ address: addr })
},
})
}
```
## Advanced Patterns
### Parallel Queries
Fetch multiple addresses simultaneously:
```tsx theme={null}
import { useQueries } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useMultipleBalances(addresses: string[]) {
return useQueries({
queries: addresses.map(address => ({
queryKey: ['balance', address],
queryFn: async () => {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return { address, balance: Wei.toEther(balance) }
},
})),
})
}
```
### Dependent Queries
Chain queries when one depends on another:
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useContractCode(address: string) {
const { data: code } = useQuery({
queryKey: ['code', address],
queryFn: async () => {
const addr = Address.from(address)
return provider.eth.getCode({ address: addr })
},
})
return useQuery({
queryKey: ['isContract', address],
queryFn: () => code && code.length > 2,
enabled: !!code,
})
}
```
### Polling for Updates
Poll for block updates:
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
function useLatestBlock() {
return useQuery({
queryKey: ['latestBlock'],
queryFn: () => provider.eth.getBlockNumber(),
refetchInterval: 12_000, // Poll every 12 seconds (block time)
})
}
```
### Optimistic Updates
Update cache optimistically when sending transactions:
```tsx theme={null}
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
function useSendTransaction() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: async (tx: { to: string; value: bigint }) => {
// Your transaction sending logic
},
onMutate: async ({ to, value }) => {
await queryClient.cancelQueries({ queryKey: ['balance', to] })
const previousBalance = queryClient.getQueryData(['balance', to])
queryClient.setQueryData(['balance', to], (old?: string) => {
const oldEther = old ? BigInt(old) : 0n
const oldWei = Wei.fromEther(oldEther)
const newWei = oldWei + value
return Wei.toEther(newWei)
})
return { previousBalance }
},
onError: (err, variables, context) => {
queryClient.setQueryData(['balance', variables.to], context?.previousBalance)
},
onSettled: (data, error, variables) => {
queryClient.invalidateQueries({ queryKey: ['balance', variables.to] })
},
})
}
```
## Query Key Patterns
Structure query keys for efficient cache management:
```tsx theme={null}
const queryKeys = {
// Address-specific
balance: (address: string) => ['balance', address] as const,
nonce: (address: string) => ['nonce', address] as const,
code: (address: string) => ['code', address] as const,
// Block-specific
block: (number: bigint | 'latest') => ['block', number.toString()] as const,
blockByHash: (hash: string) => ['block', 'hash', hash] as const,
// Transaction-specific
tx: (hash: string) => ['tx', hash] as const,
txReceipt: (hash: string) => ['txReceipt', hash] as const,
// Contract state
storage: (address: string, slot: string) => ['storage', address, slot] as const,
}
```
## Custom Hooks Library
Create a reusable hooks library:
```tsx theme={null}
// hooks/useEthereum.ts
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider(process.env.NEXT_PUBLIC_RPC_URL!)
export function useBalance(address: string | undefined) {
return useQuery({
queryKey: ['balance', address],
queryFn: async () => {
if (!address) throw new Error('No address')
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
return Wei.toEther(balance)
},
enabled: !!address,
staleTime: 10_000,
})
}
export function useBlockNumber() {
return useQuery({
queryKey: ['blockNumber'],
queryFn: () => provider.eth.getBlockNumber(),
refetchInterval: 12_000,
})
}
export function useGasPrice() {
return useQuery({
queryKey: ['gasPrice'],
queryFn: () => provider.eth.getGasPrice(),
staleTime: 5_000,
})
}
```
## Error Handling
Handle RPC errors gracefully:
```tsx theme={null}
import { useQuery } from '@tanstack/react-query'
function useBalanceWithRetry(address: string) {
return useQuery({
queryKey: ['balance', address],
queryFn: async () => {
// Your fetch logic
},
retry: (failureCount, error) => {
// Retry on network errors, not on validation errors
if (error.message.includes('invalid address')) return false
return failureCount < 3
},
retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
})
}
```
## React Suspense Integration
Use with React Suspense:
```tsx theme={null}
import { useSuspenseQuery } from '@tanstack/react-query'
import { Suspense } from 'react'
function Balance({ address }: { address: string }) {
const { data } = useSuspenseQuery({
queryKey: ['balance', address],
queryFn: async () => {
// Your fetch logic
},
})
return {data} ETH
}
function App() {
return (
Loading...}>
)
}
```
## DevTools
Enable React Query DevTools for debugging:
```tsx theme={null}
import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
function App() {
return (
)
}
```
## Best Practices
**Cache Configuration**
* Use `staleTime: Infinity` for immutable data (confirmed transactions, historical blocks)
* Use short `staleTime` (5-15s) for frequently changing data (balances, pending state)
* Use `refetchInterval` for data that changes on a known schedule (block numbers)
**Rate Limiting**
Public RPC endpoints have rate limits. Consider:
* Batching requests where possible
* Using `staleTime` to reduce refetches
* Implementing request deduplication with query keys
## Next Steps
* [JSONRPCProvider](/jsonrpc-provider) - Full provider documentation
* [Address](/primitives/address) - Address primitive reference
* [Uint](/primitives/uint) - Number handling utilities
# Vue
Source: https://voltaire.tevm.sh/integrations/vue
Using Tevm with Vue 3 and Nuxt
Tevm integrates with Vue using the Composition API and Nuxt for server-side rendering.
## Installation
```bash theme={null}
bun add @tevm/voltaire
```
## Basic Composable
Create reusable composables for Ethereum data:
```ts theme={null}
// composables/useBalance.ts
import { ref, watch, type Ref } from 'vue'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export function useBalance(address: Ref | string) {
const balance = ref(null)
const loading = ref(true)
const error = ref(null)
async function fetch() {
const addr = typeof address === 'string' ? address : address.value
if (!addr) return
loading.value = true
error.value = null
try {
const parsedAddr = Address.from(addr)
const result = await provider.eth.getBalance({ address: parsedAddr })
balance.value = Wei.toEther(result)
} catch (e) {
error.value = e as Error
} finally {
loading.value = false
}
}
if (typeof address !== 'string') {
watch(address, fetch, { immediate: true })
} else {
fetch()
}
return { balance, loading, error, refresh: fetch }
}
```
```vue theme={null}
Loading...
Error: {{ error.message }}
Balance: {{ balance }} ETH
```
## Nuxt Server Routes
Fetch data server-side with Nuxt:
```ts theme={null}
// server/api/address/[address].ts
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export default defineEventHandler(async (event) => {
const address = getRouterParam(event, 'address')
if (!address) throw createError({ statusCode: 400, message: 'Address required' })
const addr = Address.from(address)
const [balance, nonce, code] = await Promise.all([
provider.eth.getBalance({ address: addr }),
provider.eth.getTransactionCount({ address: addr }),
provider.eth.getCode({ address: addr }),
])
return {
address,
balance: Wei.toEther(balance),
nonce: Number(nonce),
isContract: code.length > 2,
}
})
```
```vue theme={null}
Loading...
Error loading address
{{ data.address }}
Balance: {{ data.balance }} ETH
Nonce: {{ data.nonce }}
Type: {{ data.isContract ? 'Contract' : 'EOA' }}
```
## Polling with useIntervalFn
Poll for block updates using VueUse:
```ts theme={null}
// composables/useLatestBlock.ts
import { ref } from 'vue'
import { useIntervalFn } from '@vueuse/core'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export function useLatestBlock() {
const blockNumber = ref(null)
const loading = ref(true)
async function fetch() {
try {
blockNumber.value = await provider.eth.getBlockNumber()
} finally {
loading.value = false
}
}
fetch()
useIntervalFn(fetch, 12000)
return { blockNumber, loading }
}
```
## Provide/Inject Pattern
Share provider across components:
```ts theme={null}
// plugins/ethereum.ts
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
import type { InjectionKey } from 'vue'
export const providerKey: InjectionKey> = Symbol('provider')
export default defineNuxtPlugin((nuxtApp) => {
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
nuxtApp.vueApp.provide(providerKey, provider)
})
```
```ts theme={null}
// composables/useProvider.ts
import { inject } from 'vue'
import { providerKey } from '@/plugins/ethereum'
export function useProvider() {
const provider = inject(providerKey)
if (!provider) throw new Error('Provider not found')
return provider
}
```
## Multiple Addresses
Fetch multiple addresses in parallel:
```ts theme={null}
// composables/useMultipleBalances.ts
import { ref, computed, type Ref } from 'vue'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export function useMultipleBalances(addresses: Ref) {
const balances = ref>(new Map())
const loading = ref(true)
async function fetchAll() {
loading.value = true
const results = await Promise.all(
addresses.value.map(async (addr) => {
const parsedAddr = Address.from(addr)
const balance = await provider.eth.getBalance({ address: parsedAddr })
return [addr, Wei.toEther(balance)] as const
})
)
balances.value = new Map(results)
loading.value = false
}
watch(addresses, fetchAll, { immediate: true, deep: true })
return { balances, loading, refresh: fetchAll }
}
```
## Async Component Pattern
Load data on component mount:
```vue theme={null}
📄 Contract
👤 EOA
```
## Pinia Store
Use Pinia for global state:
```ts theme={null}
// stores/ethereum.ts
import { defineStore } from 'pinia'
import { Address } from '@tevm/voltaire/Address'
import { Wei } from '@tevm/voltaire/Denomination'
import { createJsonRpcProvider } from '@tevm/voltaire/jsonrpc'
const provider = createJsonRpcProvider('https://eth.llamarpc.com')
export const useEthereumStore = defineStore('ethereum', {
state: () => ({
balances: {} as Record,
blockNumber: null as bigint | null,
loading: false,
}),
actions: {
async fetchBalance(address: string) {
this.loading = true
try {
const addr = Address.from(address)
const balance = await provider.eth.getBalance({ address: addr })
this.balances[address] = Wei.toEther(balance)
} finally {
this.loading = false
}
},
async fetchBlockNumber() {
this.blockNumber = await provider.eth.getBlockNumber()
},
},
getters: {
getBalance: (state) => (address: string) => state.balances[address],
},
})
```
```vue theme={null}
Loading...
{{ store.getBalance(address) }} ETH
```
## Error Handling
Handle errors gracefully:
```ts theme={null}
// composables/useEthereumQuery.ts
import { ref, type Ref } from 'vue'
interface QueryOptions {
onError?: (error: Error) => void
retry?: number
}
export function useEthereumQuery(
fetcher: () => Promise,
options: QueryOptions = {}
) {
const data = ref(null) as Ref
const loading = ref(true)
const error = ref(null)
async function execute(retries = options.retry ?? 0) {
loading.value = true
error.value = null
try {
data.value = await fetcher()
} catch (e) {
if (retries > 0) {
await new Promise(r => setTimeout(r, 1000))
return execute(retries - 1)
}
error.value = e as Error
options.onError?.(e as Error)
} finally {
loading.value = false
}
}
execute()
return { data, loading, error, refresh: () => execute(options.retry) }
}
```
## Next Steps
* [JSONRPCProvider](/jsonrpc-provider) - Full provider documentation
* [Address](/primitives/address) - Address primitive reference
# What is Voltaire?
Source: https://voltaire.tevm.sh/introduction
Modern general-purpose Ethereum library for TypeScript, Zig, C, and Swift
Voltaire is a modern general-purpose Ethereum library for TypeScript, Zig, C, and Swift. Type-safe primitives, WASM-accelerated performance, and designed for AI-assisted development.
Want to explore Voltaire in your browser? Open the [Playground](https://playground.tevm.sh).
## Simple, Intuitive API
Voltaire's API mirrors Ethereum specifications:
```typescript theme={null}
import { Address, Wei, Gwei, Ether } from '@tevm/voltaire';
import { Hex } from '@tevm/voltaire/Hex';
import { Bytes32 } from '@tevm/voltaire/Bytes32';
import { Rlp } from '@tevm/voltaire/Rlp';
import { Abi } from '@tevm/voltaire/Abi';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Addresses - branded Uint8Array with type safety
const addr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e');
console.log(addr.toHex()); // "0x742d35cc..."
console.log(addr.toChecksummed()); // "0x742d35Cc..."
// Denominations - type-safe ETH value handling
const value = Wei(1000000000000000000n);
console.log(Wei.toEther(value)); // "1"
console.log(Wei.toGwei(value)); // "1000000000"
// Type safety prevents denomination confusion
// ❌ This won't compile - Wei and Gwei are incompatible types
// const confusion: WeiType = someGweiValue; // Type Error!
// Fixed-size bytes
const hash = Bytes32('0x' + '12'.repeat(32));
console.log(hash.toHex());
// Keccak256 hashing
const messageHash = Keccak256('hello');
const selector = Keccak256.selector('transfer(address,uint256)');
// Uint8Array(4) [0xa9, 0x05, 0x9c, 0xbb]
// RLP encoding
const encoded = Rlp.encode([addr, Hex.fromNumber(42n)]);
const decoded = Rlp.decode(encoded);
// ABI encoding
const transferAbi = {
type: 'function',
name: 'transfer',
inputs: [
{ type: 'address', name: 'to' },
{ type: 'uint256', name: 'amount' }
],
outputs: [{ type: 'bool' }],
stateMutability: 'nonpayable'
} as const;
const calldata = Abi.Function.encodeParams(transferAbi, [
'0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
1000000000000000000n
]);
```
## What's Included
Native FFI is currently supported on Bun. In Node.js, use the regular TypeScript API or WASM.
* **[Skills](/concepts/skills)** - Higher-level abstractions as copyable implementations, not rigid library exports. Like shadcn/ui for Ethereum—copy a provider, contract wrapper, or React integration into your codebase and customize it for your needs.
# Comparison
Source: https://voltaire.tevm.sh/jsonrpc-provider/comparison
Voltaire request builders vs raw JSON-RPC and other libraries
# Comparison
How Voltaire's request builders compare to other Ethereum libraries.
## vs Raw EIP-1193
| Feature | Raw EIP-1193 | Voltaire Request Builders |
| -------------- | ----------------------------- | ----------------------------- |
| Method calls | `request({ method, params })` | Request builder + `request()` |
| Parameters | Plain strings/objects | Branded primitive types |
| Type safety | None (manual typing) | Full compile-time checking |
| Errors | Throws exceptions | Throws exceptions |
| Autocompletion | No | Yes |
### Example Comparison
```typescript theme={null}
// Raw EIP-1193 - no type safety
const balance = await provider.request({
method: 'eth_getBalance',
params: ['0x...', 'latest'] // Typos not caught!
});
// Voltaire - fully typed
import * as Rpc from '@tevm/voltaire/jsonrpc';
import * as Address from '@tevm/voltaire/Address';
const balance = await provider.request(
Rpc.Eth.GetBalanceRequest(Address('0x...'), 'latest')
);
```
## vs ethers.js
| Feature | ethers.js | Voltaire |
| ------------ | ------------------------- | ---------------------------------- |
| Method style | Abstracted (`getBalance`) | Direct JSON-RPC (`eth_getBalance`) |
| Types | Runtime classes | Branded primitives (zero overhead) |
| Type safety | Good | Excellent (branded types) |
| Tree-shaking | Limited | Full |
Voltaire provides lower-level JSON-RPC access with maximum type safety and tree-shaking.
## vs viem
| Feature | viem | Voltaire |
| -------------- | ------------ | --------------------- |
| API style | Actions | Request builders |
| Type system | Narrow types | Branded primitives |
| Tree-shaking | ✅ Yes | ✅ Yes |
| WASM | ❌ No | ✅ Yes (optional) |
| Multi-language | ❌ No | ✅ Yes (TS/Zig/Rust/C) |
Both provide excellent type safety. Voltaire adds multi-language support and optional WASM acceleration.
## When to Use Voltaire
* **Type safety** - Branded primitives catch errors at compile time
* **Tree-shaking** - Import only what you need
* **Multi-language** - Building for TypeScript + Zig/Rust/C
* **WASM acceleration** - Performance-critical crypto operations
* **Direct JSON-RPC** - Work directly with JSON-RPC spec
## Related
* [Getting Started](/jsonrpc-provider/getting-started) - Installation and setup
* [Method API](/jsonrpc-provider/method-api) - Request builders
# debug Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/debug-methods
Debugging and development methods (5 methods)
**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.
# debug Methods
The `debug` namespace provides 5 debugging and development methods for transaction tracing and block analysis.
Debug methods are not part of the standard JSON-RPC spec and may not be available on all nodes. They are typically only enabled on development and testing nodes.
## Overview
Access debug methods directly on the provider:
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const txHash = Keccak256.from('0x...');
// Trace transaction execution
const trace = await provider.debug_traceTransaction(txHash, {
tracer: 'callTracer'
});
```
## Transaction Tracing
### debug\_traceTransaction
Trace the execution of a transaction, returning detailed information about each step.
```typescript theme={null}
const trace = await provider.debug_traceTransaction(txHash, {
tracer: 'callTracer',
timeout: '10s'
});
// Response
```
**Parameters:**
* `transactionHash: Hash` - Transaction to trace
* `options?: TraceOptions` - Tracing configuration
**Common Tracers:**
* `callTracer` - Call tree with gas and value transfers
* `prestateTracer` - State before transaction execution
* `4byteTracer` - Count of 4-byte function selectors
* `opcodeTracer` - Full opcode-level trace
**Example:**
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const txHash = Hash('0xabc123...');
// Call tracer - see internal calls
const callTrace = await provider.debug_traceTransaction(txHash, {
tracer: 'callTracer'
});
if (!callTrace.error) {
console.log('Calls:', callTrace.result.calls);
console.log('Gas used:', callTrace.result.gasUsed);
}
// Opcode tracer - detailed execution
const opcodeTrace = await provider.debug_traceTransaction(txHash, {
tracer: 'opcodeTracer',
enableMemory: true,
enableReturnData: true
});
```
### debug\_traceBlockByNumber
Trace all transactions in a block by block number.
```typescript theme={null}
const traces = await provider.debug_traceBlockByNumber('latest', {
tracer: 'callTracer'
});
// Response
```
**Parameters:**
* `blockTag: BlockTag` - Block to trace
* `options?: TraceOptions` - Tracing configuration
**Example:**
```typescript theme={null}
// Trace all transactions in latest block
const traces = await provider.debug_traceBlockByNumber('latest', {
tracer: 'callTracer'
});
if (!traces.error) {
traces.result.forEach((trace, i) => {
console.log(`Transaction ${i}:`, trace.result);
});
}
```
### debug\_traceBlockByHash
Trace all transactions in a block by block hash.
```typescript theme={null}
const traces = await provider.debug_traceBlockByHash(blockHash, {
tracer: 'prestateTracer'
});
// Response
```
**Parameters:**
* `blockHash: Hash` - Block hash to trace
* `options?: TraceOptions` - Tracing configuration
**Example:**
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const blockHash = Hash('0xdef456...');
const traces = await provider.debug_traceBlockByHash(blockHash, {
tracer: 'prestateTracer'
});
if (!traces.error) {
console.log('Pre-state:', traces.result[0].result);
}
```
### debug\_traceCall
Trace a call without creating a transaction (like eth\_call with tracing).
```typescript theme={null}
const trace = await provider.debug_traceCall({
from: Address('0x...'),
to: Address('0x...'),
data: Hex('0x...')
}, 'latest', {
tracer: 'callTracer'
});
// Response
```
**Parameters:**
* `callParams: CallParams` - Transaction parameters
* `blockTag: BlockTag` - Block to execute against
* `options?: TraceOptions` - Tracing configuration
**Example:**
```typescript theme={null}
import * as Address from '@tevm/voltaire/Address';
import * as Hex from '@tevm/voltaire/Hex';
// Trace a call before submitting
const trace = await provider.debug_traceCall({
from: Address('0x742d35...'),
to: Address('0xcontract...'),
data: Hex('0xa9059cbb...') // transfer(address,uint256)
}, 'latest', {
tracer: 'callTracer'
});
if (!trace.error) {
// Inspect internal calls before submitting transaction
console.log('Will make calls:', trace.result.calls);
}
```
## Block Inspection
### debug\_getRawBlock
Get the RLP-encoded raw block data.
```typescript theme={null}
const rawBlock = await provider.debug_getRawBlock('latest');
// Response
```
**Parameters:**
* `blockTag: BlockTag` - Block to retrieve
**Example:**
```typescript theme={null}
// Get raw block bytes
const rawBlock = await provider.debug_getRawBlock('latest');
if (!rawBlock.error) {
console.log('RLP-encoded block:', rawBlock.result);
// Can decode with RLP module
}
```
## Trace Options
Common options for tracing methods:
```typescript theme={null}
interface TraceOptions {
// Built-in tracer name
tracer?: 'callTracer' | 'prestateTracer' | '4byteTracer' | 'opcodeTracer';
// Custom JavaScript tracer code
tracerConfig?: {
onlyTopCall?: boolean;
withLog?: boolean;
};
// Timeout for tracing operation
timeout?: string; // e.g., '10s', '1m'
// Include memory in trace
enableMemory?: boolean;
// Include return data
enableReturnData?: boolean;
// Disable storage
disableStorage?: boolean;
// Disable stack
disableStack?: boolean;
}
```
## Usage Patterns
### Debug Failed Transaction
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
async function debugFailedTx(txHash: Keccak256.Keccak256Hash) {
// Get transaction receipt
const receipt = await provider.eth_getTransactionReceipt(txHash);
if (!receipt.error && receipt.result.status === '0x0') {
// Transaction reverted, trace it
const trace = await provider.debug_traceTransaction(txHash, {
tracer: 'callTracer'
});
if (!trace.error) {
console.log('Revert reason:', trace.result.error);
console.log('Failed at:', trace.result.calls);
}
}
}
```
### Analyze Gas Usage
```typescript theme={null}
async function analyzeGas(txHash: Keccak256.Keccak256Hash) {
const trace = await provider.debug_traceTransaction(txHash, {
tracer: 'callTracer'
});
if (!trace.error) {
const result = trace.result;
console.log('Total gas:', result.gasUsed);
// Show gas for each call
result.calls?.forEach(call => {
console.log(`${call.type} to ${call.to}: ${call.gasUsed} gas`);
});
}
}
```
### Test Before Sending
```typescript theme={null}
async function testTransaction(params: CallParams) {
// Trace the call first
const trace = await provider.debug_traceCall(params, 'latest', {
tracer: 'callTracer'
});
if (!trace.error) {
if (trace.result.error) {
console.error('Transaction would fail:', trace.result.error);
return false;
}
console.log('Transaction would succeed');
console.log('Gas estimate:', trace.result.gasUsed);
return true;
}
return false;
}
```
### Compare State Changes
```typescript theme={null}
async function compareStateChanges(txHash: Keccak256.Keccak256Hash) {
// Get pre-state
const preTrace = await provider.debug_traceTransaction(txHash, {
tracer: 'prestateTracer'
});
if (!preTrace.error) {
const preState = preTrace.result;
// Get transaction receipt for post-state
const receipt = await provider.eth_getTransactionReceipt(txHash);
console.log('Accounts modified:', Object.keys(preState));
}
}
```
## Node Requirements
Debug methods require specific node configuration:
**Geth:**
```bash theme={null}
geth --http --http.api="eth,debug,net,web3"
```
**Erigon:**
```bash theme={null}
erigon --http --http.api="eth,debug,trace,net,web3"
```
**Hardhat:**
```javascript theme={null}
// Enabled by default in Hardhat Network
```
**Anvil:**
```bash theme={null}
anvil --host 0.0.0.0
# Debug methods enabled by default
```
## Performance Considerations
* **Tracing is expensive** - Can take several seconds for complex transactions
* **Use timeouts** - Prevent hanging on long traces
* **Disable unused features** - `disableMemory`, `disableStack` for faster traces
* **Production nodes** - Usually disable debug methods for security
## Type Reference
All parameter and return types are defined in the [JSON-RPC types](/jsonrpc/debug) module.
## Next Steps
* [Method API](/provider/methods) - Learn about the method-based API
* [eth Methods](/provider/eth-methods) - Standard Ethereum methods
* [engine Methods](/provider/engine-methods) - Consensus layer methods
* [Events](/provider/events) - Subscribe to blockchain events
# EIP-6963: Multi Injected Provider Discovery
Source: https://voltaire.tevm.sh/jsonrpc-provider/eip6963
Discover multiple wallet providers and allow wallets to announce themselves
EIP-6963 enables dapps to discover multiple wallet providers and wallets to announce themselves without conflicts.
## Overview
Traditional wallet injection (`window.ethereum`) creates conflicts when multiple wallets are installed. EIP-6963 solves this by:
* **Dapps**: Subscribe to wallet announcements, discover all available wallets
* **Wallets**: Announce themselves with metadata (name, icon, identifier)
## Dapp Usage
### Subscribe to Announcements
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const unsubscribe = EIP6963.subscribe((providers) => {
console.log(`Found ${providers.length} wallets`);
for (const { info, provider } of providers) {
console.log(`- ${info.name} (${info.rdns})`);
}
});
// Cleanup when done
unsubscribe();
```
The listener is called immediately with current providers, then again whenever new providers announce.
### Find Specific Provider
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// Start discovery
const unsubscribe = EIP6963.subscribe(() => {});
// Find MetaMask by reverse DNS
const metamask = EIP6963.findProvider({ rdns: 'io.metamask' });
if (metamask) {
const accounts = await metamask.provider.request({
method: 'eth_requestAccounts'
});
console.log('Connected:', accounts[0]);
}
unsubscribe();
```
### Get Current Providers
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
// Start discovery
const unsubscribe = EIP6963.subscribe(() => {});
// Get snapshot of all providers
const providers = EIP6963.getProviders();
console.log(providers.map(p => p.info.name));
unsubscribe();
```
## Wallet Usage
For wallet developers: announce your provider to dapps.
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const unsubscribe = EIP6963.announce({
info: {
uuid: crypto.randomUUID(),
name: "My Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.mywallet"
},
provider: myEIP1193Provider
});
// On extension unload
unsubscribe();
```
The wallet automatically re-announces when dapps request providers.
## Types
### ProviderInfo
Wallet metadata:
```typescript theme={null}
type ProviderInfo = Readonly<{
uuid: string; // UUIDv4 unique to session
name: string; // Human-readable name
icon: string; // Data URI (>=96x96px)
rdns: string; // Reverse DNS (e.g., "io.metamask")
}>;
```
### ProviderDetail
Complete announcement:
```typescript theme={null}
type ProviderDetail = Readonly<{
info: ProviderInfo;
provider: EIP1193Provider;
}>;
```
## Constructors
Create validated, frozen objects:
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const info = EIP6963.ProviderInfo({
uuid: "350670db-19fa-4704-a166-e52e178b59d2",
name: "Example Wallet",
icon: "data:image/svg+xml;base64,PHN2Zy...",
rdns: "com.example.wallet"
});
console.log(Object.isFrozen(info)); // true
```
## Environment Detection
EIP-6963 only works in browsers. Use `getPlatform()` to check:
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
const platform = EIP6963.getPlatform();
// 'browser' | 'node' | 'bun' | 'worker' | 'unknown'
if (platform === 'browser') {
// Safe to use EIP-6963
}
```
## Error Handling
All errors extend `EIP6963Error`:
```typescript theme={null}
import * as EIP6963 from '@voltaire/provider/eip6963';
try {
EIP6963.subscribe(() => {});
} catch (error) {
if (error instanceof EIP6963.UnsupportedEnvironmentError) {
console.log(`Not supported: ${error.platform}`);
}
}
```
### Error Types
| Error | Code | When |
| ----------------------------- | ------------------------- | ---------------------- |
| `UnsupportedEnvironmentError` | `UNSUPPORTED_ENVIRONMENT` | Not in browser |
| `InvalidUuidError` | `INVALID_UUID` | UUID not v4 format |
| `InvalidRdnsError` | `INVALID_RDNS` | RDNS not valid format |
| `InvalidIconError` | `INVALID_ICON` | Icon not data URI |
| `InvalidProviderError` | `INVALID_PROVIDER` | No request() method |
| `MissingFieldError` | `MISSING_FIELD` | Required field missing |
| `InvalidArgumentError` | `INVALID_ARGUMENT` | Bad function argument |
## Security
**Icon XSS Prevention**: Always render wallet icons via `
` elements.
Never inject icon content directly into the DOM, as malicious SVG icons could contain scripts.
## Common RDNS Values
| Wallet | RDNS |
| --------------- | --------------------- |
| MetaMask | `io.metamask` |
| Coinbase Wallet | `com.coinbase.wallet` |
| Rainbow | `me.rainbow` |
| Trust Wallet | `com.trustwallet.app` |
| Rabby | `io.rabby` |
## API Reference
### Dapp Functions
| Function | Description |
| ------------------------ | ----------------------------------------------- |
| `subscribe(listener)` | Subscribe to announcements, returns unsubscribe |
| `getProviders()` | Get current providers snapshot |
| `findProvider({ rdns })` | Find provider by RDNS |
### Wallet Functions
| Function | Description |
| ------------------------------ | -------------------------------------- |
| `announce({ info, provider })` | Announce provider, returns unsubscribe |
### Utilities
| Function | Description |
| ----------------------- | ------------------------------- |
| `getPlatform()` | Detect runtime environment |
| `ProviderInfo(input)` | Create validated ProviderInfo |
| `ProviderDetail(input)` | Create validated ProviderDetail |
## See Also
* [EIP-6963 Specification](https://eips.ethereum.org/EIPS/eip-6963)
* [EIP-1193 Provider](/jsonrpc-provider/index)
# engine Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/engine-methods
Consensus layer integration methods (20 methods)
**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.
# engine Methods
The `engine` namespace provides 20 methods for consensus layer integration via the Engine API.
The Engine API is used for communication between execution layer (EL) and consensus layer (CL) clients in post-merge Ethereum. Most application developers won't interact with these methods directly.
## Overview
Access engine methods directly on the provider:
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Validate payload (consensus layer → execution layer)
const response = await provider.engine_newPayloadV3(payload);
// Get payload for block production (execution layer → consensus layer)
const payload = await provider.engine_getPayloadV3(payloadId);
```
## Engine API Context
The Engine API implements the communication protocol between:
* **Consensus Layer (CL)** - Beacon chain, validators, attestations
* **Execution Layer (EL)** - Transaction execution, state, EVM
**Key Concepts:**
* **Payload** - Block execution data (transactions, state root, receipts root)
* **Forkchoice** - Head, safe, and finalized block hashes
* **Payload ID** - Identifier for a pending payload being built
## Payload Methods
### engine\_newPayloadV1
Verify and execute a payload (pre-Shapella).
```typescript theme={null}
const result = await provider.engine_newPayloadV1(payload);
// Response
```
### engine\_newPayloadV2
Verify and execute a payload (Shapella/Shanghai).
```typescript theme={null}
const result = await provider.engine_newPayloadV2(payload);
// Response
```
### engine\_newPayloadV3
Verify and execute a payload (Cancun - includes blobs).
```typescript theme={null}
const result = await provider.engine_newPayloadV3(
payload,
expectedBlobVersionedHashes,
parentBeaconBlockRoot
);
// Response
```
**Parameters:**
* `payload: ExecutionPayload` - Block execution data
* `expectedBlobVersionedHashes: Hash[]` - Blob KZG commitments (Cancun)
* `parentBeaconBlockRoot: Hash` - Parent beacon block root (Cancun)
**Payload Status:**
* `VALID` - Payload executed successfully
* `INVALID` - Payload execution failed
* `SYNCING` - Node is syncing, cannot validate yet
* `ACCEPTED` - Optimistically accepted (pre-finality)
**Example:**
```typescript theme={null}
const result = await provider.engine_newPayloadV3(payload, blobHashes, beaconRoot);
if (!result.error) {
switch (result.result.status) {
case 'VALID':
console.log('Payload valid, hash:', result.result.latestValidHash);
break;
case 'INVALID':
console.error('Invalid payload:', result.result.validationError);
break;
case 'SYNCING':
console.log('Node syncing, try again later');
break;
}
}
```
## Forkchoice Methods
### engine\_forkchoiceUpdatedV1
Update forkchoice state and optionally start building a new payload (pre-Shapella).
```typescript theme={null}
const result = await provider.engine_forkchoiceUpdatedV1(
forkchoiceState,
payloadAttributes
);
// Response
```
### engine\_forkchoiceUpdatedV2
Update forkchoice state (Shapella/Shanghai).
```typescript theme={null}
const result = await provider.engine_forkchoiceUpdatedV2(
forkchoiceState,
payloadAttributes
);
// Response
```
### engine\_forkchoiceUpdatedV3
Update forkchoice state (Cancun).
```typescript theme={null}
const result = await provider.engine_forkchoiceUpdatedV3(
forkchoiceState,
payloadAttributes
);
// Response
```
**Parameters:**
* `forkchoiceState: ForkchoiceState` - Head, safe, and finalized hashes
* `payloadAttributes?: PayloadAttributes` - Optional payload building parameters
**Forkchoice State:**
```typescript theme={null}
interface ForkchoiceState {
headBlockHash: Hash; // Current head
safeBlockHash: Hash; // Safe (justified) block
finalizedBlockHash: Hash; // Finalized block
}
```
**Example:**
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const forkchoiceState = {
headBlockHash: Hash('0xabc...'),
safeBlockHash: Hash('0xdef...'),
finalizedBlockHash: Hash('0x123...')
};
// Update forkchoice
const result = await provider.engine_forkchoiceUpdatedV3(forkchoiceState);
if (!result.error && result.result.payloadStatus.status === 'VALID') {
console.log('Forkchoice updated successfully');
}
// Update forkchoice and start building payload
const buildResult = await provider.engine_forkchoiceUpdatedV3(
forkchoiceState,
{
timestamp: Quantity(Date.now() / 1000),
prevRandao: Hash('0x...'),
suggestedFeeRecipient: Address('0x...')
}
);
if (!buildResult.error && buildResult.result.payloadId) {
console.log('Started building payload:', buildResult.result.payloadId);
}
```
## Payload Building Methods
### engine\_getPayloadV1
Retrieve a built payload by ID (pre-Shapella).
```typescript theme={null}
const payload = await provider.engine_getPayloadV1(payloadId);
// Response
```
### engine\_getPayloadV2
Retrieve a built payload by ID (Shapella/Shanghai).
```typescript theme={null}
const payload = await provider.engine_getPayloadV2(payloadId);
// Response
```
### engine\_getPayloadV3
Retrieve a built payload by ID (Cancun - includes blobs).
```typescript theme={null}
const payload = await provider.engine_getPayloadV3(payloadId);
// Response
```
**Parameters:**
* `payloadId: Hex` - Payload identifier from forkchoiceUpdated
**Example:**
```typescript theme={null}
// Start building payload
const forkchoiceResult = await provider.engine_forkchoiceUpdatedV3(
forkchoiceState,
payloadAttributes
);
if (!forkchoiceResult.error && forkchoiceResult.result.payloadId) {
const payloadId = forkchoiceResult.result.payloadId;
// Wait for payload to build (typically 0-12 seconds)
await new Promise(resolve => setTimeout(resolve, 1000));
// Retrieve built payload
const payloadResult = await provider.engine_getPayloadV3(payloadId);
if (!payloadResult.error) {
console.log('Payload:', payloadResult.result.executionPayload);
console.log('Block value:', payloadResult.result.blockValue);
console.log('Blobs:', payloadResult.result.blobsBundle);
}
}
```
## Blob Methods
### engine\_getBlobsV1
Retrieve blob sidecars for a list of blob versioned hashes.
```typescript theme={null}
const blobs = await provider.engine_getBlobsV1(blobVersionedHashes);
// Response
```
**Parameters:**
* `blobVersionedHashes: Hash[]` - KZG commitment hashes
**Example:**
```typescript theme={null}
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Get blobs for specific commitments
const blobHashes = [
Hash('0x01abc...'), // Blob versioned hash (sha256(kzg_commitment)[0] = 0x01)
Hash('0x01def...')
];
const blobsResult = await provider.engine_getBlobsV1(blobHashes);
if (!blobsResult.error) {
blobsResult.result.forEach((blobData, i) => {
console.log(`Blob ${i}:`);
console.log(' Data:', blobData.blob);
console.log(' Commitment:', blobData.commitment);
console.log(' Proof:', blobData.proof);
});
}
```
## Exchange Capabilities
### engine\_exchangeCapabilities
Exchange supported Engine API capabilities between CL and EL.
```typescript theme={null}
const capabilities = await provider.engine_exchangeCapabilities([
'engine_newPayloadV3',
'engine_forkchoiceUpdatedV3',
'engine_getPayloadV3'
]);
// Response
```
**Example:**
```typescript theme={null}
// Declare CL capabilities
const clCapabilities = [
'engine_newPayloadV3',
'engine_forkchoiceUpdatedV3',
'engine_getPayloadV3',
'engine_getBlobsV1'
];
const result = await provider.engine_exchangeCapabilities(clCapabilities);
if (!result.error) {
console.log('EL supports:', result.result);
// Check for specific capability
const supportsCancun = result.result.includes('engine_newPayloadV3');
console.log('Cancun support:', supportsCancun);
}
```
## Transition Methods
### engine\_exchangeTransitionConfigurationV1
Exchange transition configuration (for merge preparation).
```typescript theme={null}
const config = await provider.engine_exchangeTransitionConfigurationV1({
terminalTotalDifficulty: Quantity(58750000000000000000000n),
terminalBlockHash: Hash('0x0000000000000000000000000000000000000000000000000000000000000000'),
terminalBlockNumber: Quantity(0)
});
// Response
```
**Note:** This method was used during the merge transition and is rarely needed in post-merge operations.
## Block Validation Methods
### engine\_getPayloadBodiesByHashV1
Get block bodies (transactions only) by block hashes.
```typescript theme={null}
const bodies = await provider.engine_getPayloadBodiesByHashV1([
Hash('0xabc...'),
Hash('0xdef...')
]);
// Response
```
### engine\_getPayloadBodiesByRangeV1
Get block bodies for a range of block numbers.
```typescript theme={null}
const bodies = await provider.engine_getPayloadBodiesByRangeV1(
Quantity(1000000), // Start block
Quantity(100) // Count
);
// Response
```
**Example:**
```typescript theme={null}
// Get last 10 block bodies
const latestBlock = await provider.eth_blockNumber();
if (!latestBlock.error) {
const start = latestBlock.result - 10n;
const bodies = await provider.engine_getPayloadBodiesByRangeV1(
Quantity(start),
Quantity(10)
);
if (!bodies.error) {
bodies.result.forEach((body, i) => {
console.log(`Block ${start + BigInt(i)}:`, body.transactions.length, 'txs');
});
}
}
```
## Usage Patterns
### Block Production Flow
```typescript theme={null}
// 1. CL notifies EL of new forkchoice and requests payload
const forkchoiceResult = await provider.engine_forkchoiceUpdatedV3(
{
headBlockHash: newHead,
safeBlockHash: safeBlock,
finalizedBlockHash: finalizedBlock
},
{
timestamp: Quantity(nextSlotTime),
prevRandao: randomness,
suggestedFeeRecipient: validatorFeeRecipient,
withdrawals: withdrawalsList
}
);
// 2. EL returns payload ID
const payloadId = forkchoiceResult.result.payloadId;
// 3. CL waits for payload to build
await sleep(4000); // 4 second block time
// 4. CL retrieves built payload
const payloadResult = await provider.engine_getPayloadV3(payloadId);
const payload = payloadResult.result.executionPayload;
// 5. CL proposes block to beacon chain
// ... beacon chain operations ...
// 6. When block is attested, CL notifies EL to import
const validationResult = await provider.engine_newPayloadV3(
payload,
blobVersionedHashes,
parentBeaconBlockRoot
);
// 7. CL updates forkchoice to make new block head
await provider.engine_forkchoiceUpdatedV3({
headBlockHash: payload.blockHash,
safeBlockHash: safeBlock,
finalizedBlockHash: finalizedBlock
});
```
## Version Compatibility
| Method Version | Fork | Key Features |
| -------------- | ------------------- | ---------------------------- |
| V1 | Bellatrix (Merge) | Basic Engine API |
| V2 | Shapella (Shanghai) | Withdrawals support |
| V3 | Cancun (Dencun) | Blob transactions (EIP-4844) |
Always use the latest version compatible with your target fork.
## Error Handling
Engine API methods return detailed error information:
```typescript theme={null}
const result = await provider.engine_newPayloadV3(payload, blobHashes, beaconRoot);
if (result.error) {
console.error('RPC error:', result.error.code, result.error.message);
} else if (result.result.status === 'INVALID') {
console.error('Validation error:', result.result.validationError);
console.error('Latest valid hash:', result.result.latestValidHash);
}
```
## Type Reference
All parameter and return types are defined in the [JSON-RPC types](/jsonrpc/engine) module.
## Next Steps
* [Method API](/provider/methods) - Learn about the method-based API
* [eth Methods](/provider/eth-methods) - Standard Ethereum methods
* [debug Methods](/provider/debug-methods) - Debugging methods
* [Events](/provider/events) - Subscribe to blockchain events
## Resources
* [Engine API Specification](https://github.com/ethereum/execution-apis/tree/main/src/engine)
* [Merge Documentation](https://ethereum.org/en/roadmap/merge/)
* [EIP-4844 (Cancun/Dencun)](https://eips.ethereum.org/EIPS/eip-4844)
# Error Handling
Source: https://voltaire.tevm.sh/jsonrpc-provider/error-handling
JSON-RPC error codes, response structure, and retry strategies
Provider requests throw errors following the [JSON-RPC 2.0](https://www.jsonrpc.org/specification#error_object) and [EIP-1474](https://eips.ethereum.org/EIPS/eip-1474) specifications.
## Error Structure
```typescript theme={null}
interface JsonRpcErrorType {
code: number;
message: string;
data?: unknown;
}
```
## Standard JSON-RPC 2.0 Error Codes
Defined by [JSON-RPC 2.0 specification](https://www.jsonrpc.org/specification#error_object):
| Code | Constant | Description |
| -------- | ------------------ | ----------------------------------------- |
| `-32700` | `PARSE_ERROR` | Invalid JSON received by server |
| `-32600` | `INVALID_REQUEST` | JSON is not a valid request object |
| `-32601` | `METHOD_NOT_FOUND` | Method does not exist or is not available |
| `-32602` | `INVALID_PARAMS` | Invalid method parameter(s) |
| `-32603` | `INTERNAL_ERROR` | Internal JSON-RPC error |
## Ethereum-Specific Error Codes (EIP-1474)
Defined by [EIP-1474](https://eips.ethereum.org/EIPS/eip-1474) in the `-32000` to `-32099` range:
| Code | Constant | Description |
| -------- | -------------------------------- | --------------------------------------------------------------- |
| `-32000` | `INVALID_INPUT` | Missing or invalid parameters (commonly "execution reverted") |
| `-32001` | `RESOURCE_NOT_FOUND` | Requested resource not found (block, transaction, etc.) |
| `-32002` | `RESOURCE_UNAVAILABLE` | Requested resource not available (node syncing, data not ready) |
| `-32003` | `TRANSACTION_REJECTED` | Transaction creation failed |
| `-32004` | `METHOD_NOT_SUPPORTED` | Method exists but is not implemented |
| `-32005` | `LIMIT_EXCEEDED` | Request exceeds defined limit |
| `-32006` | `JSON_RPC_VERSION_NOT_SUPPORTED` | JSON-RPC protocol version not supported |
## Using Error Codes
```typescript theme={null}
import {
JsonRpcError,
INVALID_INPUT,
RESOURCE_NOT_FOUND,
TRANSACTION_REJECTED,
} from '@tevm/voltaire/JsonRpcError';
// Create error with code and message
const error = JsonRpcError.from(INVALID_INPUT, 'execution reverted');
// Create error with additional data (e.g., revert reason)
const revertError = JsonRpcError.from(
INVALID_INPUT,
'execution reverted',
'0x08c379a0...' // ABI-encoded revert reason
);
// Check error code
if (response.error?.code === INVALID_INPUT) {
console.log('Contract execution failed');
}
```
## Execution Reverted Errors
The `-32000` (`INVALID_INPUT`) error code is most commonly used for contract execution failures:
````typescript theme={null}
import * as Rpc from '@tevm/voltaire/jsonrpc';
import { INVALID_INPUT } from '@tevm/voltaire/JsonRpcError';
try {
const result = await provider.request(
Rpc.Eth.CallRequest({
to: contractAddress,
data: encodedCall
})
);
} catch (error) {
if (error.code === INVALID_INPUT) {
// Contract reverted - data may contain revert reason
console.error('Execution reverted:', error.data);
}
}
## Error Handling Patterns
### Checking for Specific Errors
```typescript
import * as Rpc from '@tevm/voltaire/jsonrpc';
import {
INVALID_INPUT,
METHOD_NOT_FOUND,
RESOURCE_NOT_FOUND,
} from '@tevm/voltaire/JsonRpcError';
try {
const block = await provider.request(
Rpc.Eth.GetBlockByHashRequest(blockHash, false)
);
} catch (error) {
switch (error.code) {
case INVALID_INPUT:
console.error('Invalid block hash format');
break;
case RESOURCE_NOT_FOUND:
console.error('Block not found');
break;
case METHOD_NOT_FOUND:
console.error('Method not supported by this provider');
break;
default:
console.error('Unexpected error:', error.message);
}
}
````
## Retry Strategies
### Smart Retry with Error Code Filtering
Only retry on transient errors (not permanent failures):
```typescript theme={null}
import {
METHOD_NOT_FOUND,
INVALID_PARAMS,
} from '@tevm/voltaire/JsonRpcError';
async function fetchWithRetry(
fn: () => Promise,
maxRetries: number = 3
): Promise {
const NON_RETRYABLE_ERRORS = new Set([
METHOD_NOT_FOUND, // Method will never exist
INVALID_PARAMS, // Parameters are wrong
]);
for (let i = 0; i < maxRetries; i++) {
try {
return await fn();
} catch (error) {
// Don't retry if error is non-retryable or last attempt
if (NON_RETRYABLE_ERRORS.has(error.code) || i === maxRetries - 1) {
throw error;
}
// Exponential backoff: 1s, 2s, 4s
await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
}
}
throw new Error('Max retries exceeded');
}
```
### Rate Limit Handling
```typescript theme={null}
import { LIMIT_EXCEEDED } from '@tevm/voltaire/JsonRpcError';
async function callWithRateLimit(
fn: () => Promise
): Promise {
while (true) {
try {
return await fn();
} catch (error) {
// If rate limited, wait and retry
if (error.code === LIMIT_EXCEEDED) {
await new Promise(resolve => setTimeout(resolve, 1000));
continue;
}
throw error;
}
}
}
```
## Complete Error Reference
See `@tevm/voltaire/JsonRpcError` for:
* All error code constants
* `JsonRpcError.from()` constructor
* `ERROR_MESSAGES` lookup table
## Related
* [Method API](/jsonrpc-provider/method-api) - Method calls and responses
* [Performance](/jsonrpc-provider/performance) - Optimization strategies
# Block Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/blocks
Query blocks, receipts, and transaction counts (8 methods)
**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.
# Block Methods
8 methods for querying block data, receipts, and transaction counts.
## Overview
Block methods provide access to block headers, full blocks, transaction receipts, and metadata. Use these methods to query blockchain state at specific block heights or hashes.
## Methods
Get the most recent block number.
**Returns:** `Quantity`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const blockNumber = await provider.request(Rpc.Eth.BlockNumberRequest());
console.log('Current block:', blockNumber);
```
Get block by number with full transactions or hashes.
**Parameters:**
| Parameter | Type | Description |
| ------------------ | ---------- | ----------------------------------------------------------------------- |
| `blockTag` | `BlockTag` | Block to query (`'latest'`, `'earliest'`, `'pending'`, or block number) |
| `fullTransactions` | `boolean` | `true` for full tx objects, `false` for hashes only |
**Returns:** `Block`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
// Get latest block with full transaction objects
const block = await provider.request(Rpc.Eth.GetBlockByNumberRequest('latest', true));
console.log('Block number:', block.number);
console.log('Transaction count:', block.transactions.length);
```
Get block by hash with full transactions or hashes.
**Parameters:**
| Parameter | Type | Description |
| ------------------ | --------- | --------------------------------------------------- |
| `blockHash` | `Hash` | Block hash to query |
| `fullTransactions` | `boolean` | `true` for full tx objects, `false` for hashes only |
**Returns:** `Block`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const blockHash = Keccak256.from('0x...');
const block = await provider.request(Rpc.Eth.GetBlockByHashRequest(blockHash, false));
console.log('Block:', block);
```
Get all transaction receipts for a block.
**Parameters:**
| Parameter | Type | Description |
| ---------- | ---------- | -------------- |
| `blockTag` | `BlockTag` | Block to query |
**Returns:** `TransactionReceipt[]`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const receipts = await provider.request(Rpc.Eth.GetBlockReceiptsRequest('latest'));
console.log('Receipts:', receipts.length);
receipts.forEach((receipt, i) => {
console.log(`TX ${i} status:`, receipt.status);
});
```
Get transaction count in a block by hash.
**Parameters:**
| Parameter | Type | Description |
| ----------- | ------ | ------------------- |
| `blockHash` | `Hash` | Block hash to query |
**Returns:** `Quantity`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const blockHash = Keccak256.from('0x...');
const count = await provider.request(Rpc.Eth.GetBlockTransactionCountByHashRequest(blockHash));
console.log('Transaction count:', count);
```
Get transaction count in a block by number.
**Parameters:**
| Parameter | Type | Description |
| ---------- | ---------- | -------------- |
| `blockTag` | `BlockTag` | Block to query |
**Returns:** `Quantity`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const count = await provider.request(Rpc.Eth.GetBlockTransactionCountByNumberRequest('latest'));
console.log('Transaction count:', count);
```
Get uncle count for a block by hash.
**Parameters:**
| Parameter | Type | Description |
| ----------- | ------ | ------------------- |
| `blockHash` | `Hash` | Block hash to query |
**Returns:** `Quantity`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const blockHash = Keccak256.from('0x...');
const count = await provider.request(Rpc.Eth.GetUncleCountByBlockHashRequest(blockHash));
console.log('Uncle count:', count);
```
Uncle blocks were removed in Ethereum's transition to Proof of Stake (The Merge). This method returns 0 for post-merge blocks.
Get uncle count for a block by number.
**Parameters:**
| Parameter | Type | Description |
| ---------- | ---------- | -------------- |
| `blockTag` | `BlockTag` | Block to query |
**Returns:** `Quantity`
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const count = await provider.request(Rpc.Eth.GetUncleCountByBlockNumberRequest('latest'));
console.log('Uncle count:', count);
```
Uncle blocks were removed in Ethereum's transition to Proof of Stake (The Merge). This method returns 0 for post-merge blocks.
## Usage Patterns
### Get Latest Block with Transactions
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
const block = await provider.request(Rpc.Eth.GetBlockByNumberRequest('latest', true));
console.log('Block:', block.number);
console.log('Gas used:', block.gasUsed);
console.log('Transactions:', block.transactions.length);
// Get receipts for all transactions
const receipts = await provider.request(Rpc.Eth.GetBlockReceiptsRequest('latest'));
const gasUsedTotal = receipts.reduce(
(sum, r) => sum + BigInt(r.gasUsed),
0n
);
console.log('Total gas used:', gasUsedTotal);
```
### Query Historical Block
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
import * as Quantity from '@tevm/voltaire/primitives/Quantity';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
// Query specific block number
const blockNumber = Quantity(18000000n);
const block = await provider.request(Rpc.Eth.GetBlockByNumberRequest(blockNumber, false));
console.log('Timestamp:', block.timestamp);
console.log('Miner:', block.miner);
// Get transaction count
const txCount = await provider.request(Rpc.Eth.GetBlockTransactionCountByNumberRequest(blockNumber));
console.log('Transactions:', txCount);
```
### Check Block Finality
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const provider = new Provider({ url: 'https://mainnet.infura.io' });
// Get latest and finalized blocks
const [latest, finalized] = await Promise.all([
provider.request(Rpc.Eth.GetBlockByNumberRequest('latest', false)),
provider.request(Rpc.Eth.GetBlockByNumberRequest('finalized', false))
]);
const latestNum = BigInt(latest.number);
const finalizedNum = BigInt(finalized.number);
const confirmations = latestNum - finalizedNum;
console.log('Latest block:', latestNum);
console.log('Finalized block:', finalizedNum);
console.log('Blocks until finalized:', confirmations);
```
## Related
* [eth Methods](/jsonrpc-provider/eth-methods/index) - All eth namespace methods
* [Transaction Methods](/jsonrpc-provider/eth-methods/transactions) - Transaction queries and submission
* [State Methods](/jsonrpc-provider/eth-methods/state) - Account and storage queries
* [Block JSON-RPC Types](/jsonrpc/eth/types/block) - Block type definitions
# Contract Call Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/calls
Execute contract calls, estimate gas, and simulate transactions
**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.
# Contract Call Methods
Methods for executing contract calls and transaction simulations.
## eth\_call
Execute a read-only contract call without creating a transaction.
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
const result = await provider.eth_call({
from: Address('0x742d35Cc6634C0532925a3b844Bc454e4438f44e'),
to: Address('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
data: Hex('0x70a08231000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e') // balanceOf(address)
}, 'latest');
if (!result.error) {
console.log('Balance:', result.result);
}
// Response
```
**Parameters:**
* `callParams: CallParams` - Transaction call parameters
* `from?: Address` - Sender address (optional)
* `to: Address` - Contract address
* `data: Hex` - Encoded function call
* `gas?: Quantity` - Gas limit (optional)
* `gasPrice?: Quantity` - Gas price (optional)
* `value?: Quantity` - ETH value (optional)
* `blockTag: BlockTag` - Block to execute against (`'latest'`, `'earliest'`, `'pending'`, or block number/hash)
**Returns:** `Response` - Encoded return data
**Common use cases:**
* Call contract view functions
* Query contract state
* Validate transaction execution before sending
* Simulate complex contract interactions
## eth\_estimateGas
Estimate gas required for a transaction.
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
import { Hex } from '@tevm/voltaire/Hex';
const gas = await provider.eth_estimateGas({
from: Address('0x742d35Cc6634C0532925a3b844Bc454e4438f44e'),
to: Address('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
value: Quantity(1000000000000000000n), // 1 ETH
data: Hex('0xa9059cbb...')
});
if (!gas.error) {
const estimate = BigInt(gas.result);
const withBuffer = estimate * 120n / 100n; // Add 20% buffer
console.log('Estimated gas:', estimate);
console.log('With buffer:', withBuffer);
}
// Response
```
**Parameters:**
* `callParams: CallParams` - Transaction parameters (same as `eth_call`)
**Returns:** `Response` - Estimated gas amount
**Best practices:**
* Always add a buffer (10-20%) to estimates
* Handle estimation failures gracefully
* Consider network congestion in final gas limits
* Test with realistic transaction data
### Estimating with Buffer Pattern
```typescript theme={null}
async function estimateGasWithBuffer(
provider: Provider,
params: {
from: Address.AddressType;
to: Address.AddressType;
data: Hex.HexType;
}
): Promise {
const response = await provider.eth_estimateGas(params);
if (response.error) {
return null;
}
const estimate = BigInt(response.result);
return estimate * 120n / 100n; // Add 20% buffer
}
```
## eth\_createAccessList
Generate an access list for a transaction to optimize gas costs (EIP-2930).
```typescript theme={null}
import * as Address from '@tevm/voltaire/Address';
import * as Hex from '@tevm/voltaire/Hex';
const accessList = await provider.eth_createAccessList({
from: Address('0x742d35Cc6634C0532925a3b844Bc454e4438f44e'),
to: Address('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
data: Hex('0xa9059cbb...')
}, 'latest');
if (!accessList.error) {
console.log('Access list:', accessList.result.accessList);
console.log('Gas used:', accessList.result.gasUsed);
}
// Response
```
**Parameters:**
* `callParams: CallParams` - Transaction parameters
* `blockTag: BlockTag` - Block to execute against
**Returns:** `Response`
* `accessList: AccessList` - Generated access list
* `gasUsed: Quantity` - Gas that would be used
* `error?: string` - Optional error message
**Benefits:**
* Reduces gas costs for complex transactions
* Makes gas costs more predictable
* Required for some contract interactions post-EIP-2930
**When to use:**
* Multi-contract interactions
* Transactions touching many storage slots
* Gas optimization for frequent operations
## eth\_simulateV1
Simulate multiple transactions in sequence (EIP-not-yet-finalized).
```typescript theme={null}
const simulation = await provider.eth_simulateV1({
blockStateCalls: [
{
blockOverrides: {
number: '0x1234567',
timestamp: '0x5678'
},
calls: [
{
from: Address('0x...'),
to: Address('0x...'),
data: Hex('0x...')
}
]
}
],
validation: true
});
// Response
```
**Parameters:**
* `params: SimulationParams` - Simulation configuration
* `blockStateCalls: BlockStateCall[]` - Transactions to simulate
* `validation: boolean` - Enable validation
* `returnFullTransactionObjects?: boolean` - Include full tx objects
**Returns:** `Response` - Simulation results for each transaction
**Use cases:**
* Test transaction sequences
* Validate multi-step operations
* Debug complex contract interactions
* Estimate total gas for batched transactions
`eth_simulateV1` is from an EIP that's not yet finalized. The API may change and not all providers support it.
## Related
* [State Query Methods](/jsonrpc-provider/eth-methods/state) - Query account and storage
* [Transaction Methods](/jsonrpc-provider/eth-methods/transactions) - Send and query transactions
* [Usage Patterns](/jsonrpc-provider/usage-patterns) - Common recipes including gas estimation
* [Error Handling](/jsonrpc-provider/error-handling) - Handle RPC errors
# Fee Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/fees
Gas price and fee estimation methods (4 methods)
**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.
# Fee Methods
The `eth` namespace provides 4 methods for querying gas prices and fee history to estimate transaction costs.
## Overview
Access fee methods directly on the provider:
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
// Get current gas price
const gasPrice = await provider.eth_gasPrice();
// Get EIP-1559 priority fee
const priorityFee = await provider.eth_maxPriorityFeePerGas();
// Get historical fee data
const history = await provider.eth_feeHistory(
Quantity(10), // Block count
'latest', // Newest block
[25, 50, 75] // Percentiles
);
```
## Usage Patterns
### Estimate Transaction Costs
Calculate gas costs for legacy transactions:
```typescript theme={null}
const gasPrice = await provider.eth_gasPrice();
const gasLimit = Quantity(21000);
// Total cost in wei
const cost = BigInt(gasPrice.data) * BigInt(gasLimit);
```
### Calculate EIP-1559 Fees
Build EIP-1559 transaction fees with historical data:
```typescript theme={null}
// Get base fee from latest block
const block = await provider.eth_getBlockByNumber('latest', false);
const baseFee = block.data.baseFeePerGas;
// Get suggested priority fee
const priorityFee = await provider.eth_maxPriorityFeePerGas();
// Set max fees
const maxPriorityFeePerGas = priorityFee.data;
const maxFeePerGas = Quantity(
BigInt(baseFee) * 2n + BigInt(maxPriorityFeePerGas)
);
```
### Monitor Gas Prices
Track fee trends over time:
```typescript theme={null}
const history = await provider.eth_feeHistory(
Quantity(100), // Last 100 blocks
'latest',
[10, 50, 90] // Low, medium, high
);
// Analyze fee trends
const recentFees = history.data.baseFeePerGas.slice(-10);
const avgBaseFee = recentFees.reduce(
(sum, fee) => sum + BigInt(fee),
0n
) / BigInt(recentFees.length);
```
## Methods
### eth\_gasPrice
Get current gas price in wei.
```typescript theme={null}
const gasPrice = await provider.eth_gasPrice();
// Response
```
**Returns:** Current gas price in wei as a `Quantity`.
**Use Case:** Legacy (non-EIP-1559) transaction fee estimation.
***
### eth\_maxPriorityFeePerGas
Get current max priority fee per gas (EIP-1559).
```typescript theme={null}
const priorityFee = await provider.eth_maxPriorityFeePerGas();
// Response
```
**Returns:** Suggested max priority fee per gas in wei as a `Quantity`.
**Use Case:** EIP-1559 transaction fee calculation. This is the "tip" paid to validators.
For EIP-1559 transactions, set `maxFeePerGas` to at least `baseFee + maxPriorityFeePerGas` to ensure inclusion.
***
### eth\_feeHistory
Get historical gas fee data for a range of blocks.
```typescript theme={null}
const history = await provider.eth_feeHistory(
Quantity(10), // Block count
'latest', // Newest block
[25, 50, 75] // Percentiles
);
// Response
```
**Parameters:**
* `blockCount: Quantity` - Number of blocks to query (max varies by node)
* `newestBlock: BlockTag | Quantity` - Highest block to query
* `rewardPercentiles?: number[]` - Priority fee percentiles (0-100)
**Returns:** `FeeHistory` object containing:
* `oldestBlock: Quantity` - First block in range
* `baseFeePerGas: Quantity[]` - Base fee per block
* `gasUsedRatio: number[]` - Fraction of gas limit used
* `reward?: Quantity[][]` - Priority fees at requested percentiles
**Use Case:** Analyze fee trends, predict optimal gas prices, calculate EIP-1559 fees with historical context.
The `rewardPercentiles` parameter is only applicable for EIP-1559 blocks. For pre-EIP-1559 blocks, the `reward` field will be empty.
***
### eth\_blobBaseFee
Get current blob base fee for EIP-4844 transactions.
```typescript theme={null}
const blobFee = await provider.eth_blobBaseFee();
// Response
```
**Returns:** Current blob base fee in wei as a `Quantity`.
**Use Case:** Calculate costs for EIP-4844 blob transactions. Blob fees are separate from execution gas fees.
This method is only available on networks that have activated EIP-4844 (Cancun upgrade). It will error on pre-Cancun networks.
## Related Methods
* [eth\_getBlockByNumber](/jsonrpc-provider/eth-methods/index#eth_getblockbynumber) - Get block with base fee
* [eth\_estimateGas](/jsonrpc-provider/eth-methods/index#eth_estimategas) - Estimate gas limit
* [eth\_sendTransaction](/jsonrpc-provider/eth-methods/index#eth_sendtransaction) - Send transaction with fees
# eth Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/index
Standard Ethereum JSON-RPC methods (40 methods)
**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.
# eth Methods
The `eth` namespace provides 40 standard Ethereum JSON-RPC methods for blocks, transactions, state queries, and more.
## Overview
Access eth methods via the EIP-1193 `request` API:
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Address from '@tevm/voltaire/Address';
import * as Rpc from '@tevm/voltaire/jsonrpc';
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
// Call eth methods
const blockNumber = await provider.request(Rpc.Eth.BlockNumberRequest());
const balance = await provider.request(Rpc.Eth.GetBalanceRequest(address, 'latest'));
const tx = await provider.request(Rpc.Eth.GetTransactionByHashRequest(txHash));
```
## Block Methods
### eth\_blockNumber
Get the most recent block number.
```typescript theme={null}
const blockNumber = await provider.request(Rpc.Eth.BlockNumberRequest());
// Quantity
```
### eth\_getBlockByNumber
Get block by number with full transactions or hashes.
```typescript theme={null}
const block = await provider.request(Rpc.Eth.GetBlockByNumberRequest('latest', true));
// Block
```
**Parameters:**
* `blockTag: BlockTag` - Block to query
* `fullTransactions: boolean` - true for full tx objects, false for hashes
### eth\_getBlockByHash
Get block by hash.
```typescript theme={null}
const block = await provider.request(Rpc.Eth.GetBlockByHashRequest(blockHash, false));
// Block
```
**Parameters:**
* `blockHash: Hash` - Block hash
* `fullTransactions: boolean` - true for full tx objects, false for hashes
### eth\_getBlockReceipts
Get all transaction receipts for a block.
```typescript theme={null}
const receipts = await provider.request(Rpc.Eth.GetBlockReceiptsRequest('latest'));
// TransactionReceipt[]
```
### eth\_getBlockTransactionCountByHash
Get transaction count in a block by hash.
```typescript theme={null}
const count = await provider.request(Rpc.Eth.GetBlockTransactionCountByHashRequest(blockHash));
// Quantity
```
### eth\_getBlockTransactionCountByNumber
Get transaction count in a block by number.
```typescript theme={null}
const count = await provider.request(Rpc.Eth.GetBlockTransactionCountByNumberRequest('latest'));
// Quantity
```
### eth\_getUncleCountByBlockHash
Get uncle count for a block by hash.
```typescript theme={null}
const count = await provider.request(Rpc.Eth.GetUncleCountByBlockHashRequest(blockHash));
// Quantity
```
### eth\_getUncleCountByBlockNumber
Get uncle count for a block by number.
```typescript theme={null}
const count = await provider.request(Rpc.Eth.GetUncleCountByBlockNumberRequest('latest'));
// Quantity
```
## Transaction Methods
### eth\_sendRawTransaction
Submit a signed transaction to the network.
```typescript theme={null}
const txHash = await provider.request(Rpc.Eth.SendRawTransactionRequest(signedTx));
// Hash
```
**Parameters:**
* `signedTransaction: Hex` - Signed transaction bytes
### eth\_sendTransaction
Sign and send a transaction (requires unlocked account).
```typescript theme={null}
const txHash = await provider.request(Rpc.Eth.SendTransactionRequest({
from: Address('0x...'),
to: Address('0x...'),
value: Quantity(1000000000000000000n),
data: Hex('0x...')
}));
// Hash
```
### eth\_getTransactionByHash
Get transaction by hash.
```typescript theme={null}
const tx = await provider.request(Rpc.Eth.GetTransactionByHashRequest(txHash));
// Transaction
```
### eth\_getTransactionByBlockHashAndIndex
Get transaction by block hash and index.
```typescript theme={null}
const tx = await provider.request(Rpc.Eth.GetTransactionByBlockHashAndIndexRequest(
blockHash,
Quantity(0)
));
// Transaction
```
### eth\_getTransactionByBlockNumberAndIndex
Get transaction by block number and index.
```typescript theme={null}
const tx = await provider.request(Rpc.Eth.GetTransactionByBlockNumberAndIndexRequest(
'latest',
Quantity(0)
));
// Transaction
```
### eth\_getTransactionReceipt
Get transaction receipt (includes logs and status).
```typescript theme={null}
const receipt = await provider.request(Rpc.Eth.GetTransactionReceiptRequest(txHash));
// TransactionReceipt
```
### eth\_getTransactionCount
Get transaction count (nonce) for an address.
```typescript theme={null}
const nonce = await provider.request(Rpc.Eth.GetTransactionCountRequest(address, 'latest'));
// Quantity
```
## State Methods
### eth\_getBalance
Get ether balance of an address.
```typescript theme={null}
const balance = await provider.request(Rpc.Eth.GetBalanceRequest(address, 'latest'));
// Quantity
```
**Parameters:**
* `address: Address` - Account address
* `blockTag: BlockTag` - Block to query
### eth\_getCode
Get contract bytecode at an address.
```typescript theme={null}
const code = await provider.request(Rpc.Eth.GetCodeRequest(address, 'latest'));
// Hex
```
**Parameters:**
* `address: Address` - Contract address
* `blockTag: BlockTag` - Block to query
### eth\_getStorageAt
Get value from a contract storage slot.
```typescript theme={null}
const value = await provider.request(Rpc.Eth.GetStorageAtRequest(
address,
Quantity(0),
'latest'
));
// Hex
```
**Parameters:**
* `address: Address` - Contract address
* `position: Quantity` - Storage slot
* `blockTag: BlockTag` - Block to query
### eth\_getProof
Get Merkle proof for account and storage values.
```typescript theme={null}
const proof = await provider.request(Rpc.Eth.GetProofRequest(
address,
[Quantity(0), Quantity(1)],
'latest'
));
// Proof
```
**Parameters:**
* `address: Address` - Account address
* `storageKeys: Quantity[]` - Storage slots to prove
* `blockTag: BlockTag` - Block to query
## Call Methods
### eth\_call
Execute a read-only contract call without creating a transaction.
```typescript theme={null}
const result = await provider.request(Rpc.Eth.CallRequest({
from: Address('0x...'),
to: Address('0x...'),
data: Hex('0x70a08231...') // balanceOf(address)
}, 'latest'));
// Hex
```
**Parameters:**
* `callParams: CallParams` - Transaction parameters
* `blockTag: BlockTag` - Block to execute against
### eth\_estimateGas
Estimate gas required for a transaction.
```typescript theme={null}
const gas = await provider.request(Rpc.Eth.EstimateGasRequest({
from: Address('0x...'),
to: Address('0x...'),
value: Quantity(1000000000000000000n),
data: Hex('0x...')
}));
// Quantity
```
### eth\_createAccessList
Generate an access list for a transaction.
```typescript theme={null}
const accessList = await provider.request(Rpc.Eth.CreateAccessListRequest({
from: Address('0x...'),
to: Address('0x...'),
data: Hex('0x...')
}, 'latest'));
// AccessList
```
### eth\_simulateV1
Simulate multiple transactions (EIP-not-yet-finalized).
```typescript theme={null}
const simulation = await provider.request(Rpc.Eth.SimulateV1Request(params));
// SimulationResult
```
## Log & Filter Methods
### eth\_getLogs
Query event logs matching a filter.
```typescript theme={null}
const logs = await provider.request(Rpc.Eth.GetLogsRequest({
fromBlock: 'earliest',
toBlock: 'latest',
address: Address('0x...'),
topics: [Hash('0x...')] // Event signature
}));
// Log[]
```
### eth\_newFilter
Create a new log filter.
```typescript theme={null}
const filterId = await provider.request(Rpc.Eth.NewFilterRequest({
fromBlock: 'latest',
toBlock: 'latest',
address: Address('0x...'),
topics: []
}));
// Quantity
```
### eth\_newBlockFilter
Create a filter for new blocks.
```typescript theme={null}
const filterId = await provider.request(Rpc.Eth.NewBlockFilterRequest());
// Quantity
```
### eth\_newPendingTransactionFilter
Create a filter for pending transactions.
```typescript theme={null}
const filterId = await provider.request(Rpc.Eth.NewPendingTransactionFilterRequest());
// Quantity
```
### eth\_getFilterChanges
Get new entries for a filter since last poll.
```typescript theme={null}
const changes = await provider.request(Rpc.Eth.GetFilterChangesRequest(filterId));
// Log[] | Hash[]
```
### eth\_getFilterLogs
Get all logs matching a filter.
```typescript theme={null}
const logs = await provider.request(Rpc.Eth.GetFilterLogsRequest(filterId));
// Log[]
```
### eth\_uninstallFilter
Remove a filter.
```typescript theme={null}
const success = await provider.request(Rpc.Eth.UninstallFilterRequest(filterId));
// boolean
```
## Fee Methods
### eth\_gasPrice
Get current gas price.
```typescript theme={null}
const gasPrice = await provider.request(Rpc.Eth.GasPriceRequest());
// Quantity
```
### eth\_maxPriorityFeePerGas
Get current max priority fee per gas (EIP-1559).
```typescript theme={null}
const priorityFee = await provider.request(Rpc.Eth.MaxPriorityFeePerGasRequest());
// Quantity
```
### eth\_feeHistory
Get historical gas fee data.
```typescript theme={null}
const history = await provider.request(Rpc.Eth.FeeHistoryRequest(
Quantity(10), // Block count
'latest', // Newest block
[25, 50, 75] // Percentiles
));
// FeeHistory
```
### eth\_blobBaseFee
Get current blob base fee (EIP-4844).
```typescript theme={null}
const blobFee = await provider.request(Rpc.Eth.BlobBaseFeeRequest());
// Quantity
```
## Network Methods
### eth\_chainId
Get the chain ID.
```typescript theme={null}
const chainId = await provider.request(Rpc.Eth.ChainIdRequest());
// Quantity
```
### eth\_syncing
Get sync status (false if not syncing).
```typescript theme={null}
const syncStatus = await provider.request(Rpc.Eth.SyncingRequest());
// SyncStatus | false
```
### eth\_coinbase
Get the coinbase address (miner/validator).
```typescript theme={null}
const coinbase = await provider.request(Rpc.Eth.CoinbaseRequest());
// Address
```
## Account Methods
### eth\_accounts
List available accounts (if wallet is connected).
```typescript theme={null}
const accounts = await provider.request(Rpc.Eth.AccountsRequest());
// Address[]
```
### eth\_sign
Sign data with an account (requires unlocked account).
```typescript theme={null}
const signature = await provider.request(Rpc.Eth.SignRequest(
Address('0x...'),
Hex('0x...')
));
// Hex
```
`eth_sign` is dangerous and deprecated. Use typed signing methods like EIP-712 instead.
### eth\_signTransaction
Sign a transaction (requires unlocked account).
```typescript theme={null}
const signedTx = await provider.request(Rpc.Eth.SignTransactionRequest({
from: Address('0x...'),
to: Address('0x...'),
value: Quantity(1000000000000000000n)
}));
// Hex
```
## Usage Patterns
### Check Balance and Nonce
```typescript theme={null}
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
try {
const [balance, nonce] = await Promise.all([
provider.request(Rpc.Eth.GetBalanceRequest(address, 'latest')),
provider.request(Rpc.Eth.GetTransactionCountRequest(address, 'latest'))
]);
console.log('Balance:', balance);
console.log('Nonce:', nonce);
} catch (error) {
console.error('Failed to fetch account data:', error);
}
```
### Query Contract State
```typescript theme={null}
try {
// Get contract code
const code = await provider.request(Rpc.Eth.GetCodeRequest(contractAddress, 'latest'));
if (code !== '0x') {
// Contract exists, call a method
const result = await provider.request(Rpc.Eth.CallRequest({
to: contractAddress,
data: Hex('0x18160ddd') // totalSupply()
}, 'latest'));
console.log('Total supply:', result);
}
} catch (error) {
console.error('Failed to query contract:', error);
}
```
### Monitor Transaction
```typescript theme={null}
try {
// Submit transaction
const txHash = await provider.request(Rpc.Eth.SendRawTransactionRequest(signedTx));
// Poll for receipt
let receipt = null;
while (!receipt) {
try {
receipt = await provider.request(Rpc.Eth.GetTransactionReceiptRequest(txHash));
if (receipt) {
console.log('Transaction mined in block:', receipt.blockNumber);
}
} catch (error) {
// Receipt not yet available, continue polling
}
await new Promise(resolve => setTimeout(resolve, 1000));
}
} catch (error) {
console.error('Failed to submit transaction:', error);
}
```
## Type Reference
All parameter and return types are defined in the [JSON-RPC types](/jsonrpc/eth) module.
## Next Steps
* [Method API](/provider/methods) - Learn about the method-based API
* [debug Methods](/provider/debug-methods) - Debugging methods
* [engine Methods](/provider/engine-methods) - Consensus layer methods
* [Events](/provider/events) - Subscribe to blockchain events
# Logs & Filters
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/logs-filters
Query event logs and create filters for monitoring
**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.
Query historical event logs and create filters to monitor new blocks, transactions, and events.
## Log Query
### eth\_getLogs
Query event logs matching filter criteria.
```typescript theme={null}
import { Address } from '@tevm/voltaire/Address';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const logs = await provider.eth_getLogs({
fromBlock: 'earliest',
toBlock: 'latest',
address: Address('0x...'),
topics: [Hash('0x...')] // Event signature
});
// Response
```
**Parameters:**
* `fromBlock: BlockTag` - Starting block (default: 'latest')
* `toBlock: BlockTag` - Ending block (default: 'latest')
* `address?: Address | Address[]` - Contract address(es) to filter
* `topics?: Array` - Event topic filters
**Usage patterns:**
* Query historical events from contracts
* Filter by event signature (topic\[0])
* Filter by indexed parameters (topic\[1-3])
* Search across multiple contracts
## Filter Creation
### eth\_newFilter
Create a log filter for event monitoring.
```typescript theme={null}
const filterId = await provider.eth_newFilter({
fromBlock: 'latest',
toBlock: 'latest',
address: Address('0x...'),
topics: []
});
// Response
```
**Parameters:** Same as `eth_getLogs`
**Returns:** Filter ID for polling
### eth\_newBlockFilter
Create a filter for new block hashes.
```typescript theme={null}
const filterId = await provider.eth_newBlockFilter();
// Response
```
Monitor new blocks by polling for changes.
### eth\_newPendingTransactionFilter
Create a filter for pending transaction hashes.
```typescript theme={null}
const filterId = await provider.eth_newPendingTransactionFilter();
// Response
```
Monitor mempool activity by polling for new transactions.
## Filter Polling
### eth\_getFilterChanges
Get new entries for a filter since last poll.
```typescript theme={null}
const changes = await provider.eth_getFilterChanges(filterId);
// Response
```
**Returns:**
* `Log[]` - For log filters
* `Hash[]` - For block/transaction filters
**Note:** Resets the filter's internal state - subsequent calls only return new changes.
### eth\_getFilterLogs
Get all logs matching a filter (does not reset state).
```typescript theme={null}
const logs = await provider.eth_getFilterLogs(filterId);
// Response
```
**Note:** Only works with log filters, not block/transaction filters.
## Filter Cleanup
### eth\_uninstallFilter
Remove a filter and free resources.
```typescript theme={null}
const success = await provider.eth_uninstallFilter(filterId);
// Response
```
Always uninstall filters when done to prevent resource leaks.
## Usage Example
```typescript theme={null}
import * as Address from '@tevm/voltaire/Address';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
// Create filter for Transfer events
const filterId = await provider.eth_newFilter({
fromBlock: 'latest',
address: Address('0x...'),
topics: [
Hash('0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef') // Transfer(address,address,uint256)
]
});
// Poll for changes
setInterval(async () => {
const logs = await provider.eth_getFilterChanges(filterId);
if (logs.length > 0) {
console.log('New transfers:', logs);
}
}, 5000);
// Cleanup on exit
process.on('exit', async () => {
await provider.eth_uninstallFilter(filterId);
});
```
## Filter Lifecycle
1. **Create** - Use `eth_newFilter`, `eth_newBlockFilter`, or `eth_newPendingTransactionFilter`
2. **Poll** - Call `eth_getFilterChanges` periodically to get new entries
3. **Query** - Optionally use `eth_getFilterLogs` to re-query all matches
4. **Cleanup** - Call `eth_uninstallFilter` when done
Filters expire after 5 minutes of inactivity on most nodes. Poll regularly to keep them alive.
## Related
* [State Methods](/jsonrpc-provider/eth-methods/state) - Query account and storage state
* [Transaction Methods](/jsonrpc-provider/eth-methods/transactions) - Send and query transactions
* [Block Methods](/jsonrpc-provider/eth-methods/blocks) - Query block data
# Network Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/network
Ethereum network info methods - chain ID, sync status, coinbase, accounts
**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.
# Network Methods
Network information methods for detecting chain ID, checking sync status, and querying node/account state.
## Overview
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
const provider = new Provider({ url: 'https://mainnet.infura.io/v3/...' });
// Network detection
const chainId = await provider.eth_chainId();
const syncStatus = await provider.eth_syncing();
// Node info
const coinbase = await provider.eth_coinbase();
const accounts = await provider.eth_accounts();
```
## Methods
### eth\_chainId
Get the chain ID.
```typescript theme={null}
const chainId = await provider.eth_chainId();
// Response
```
**Returns:** Chain ID as hex quantity (e.g., `0x1` for Ethereum mainnet)
**Usage:**
```typescript theme={null}
const response = await provider.eth_chainId();
const chainId = parseInt(response.data, 16);
if (chainId === 1) {
console.log('Connected to Ethereum mainnet');
} else if (chainId === 11155111) {
console.log('Connected to Sepolia testnet');
}
```
### eth\_syncing
Get sync status (false if not syncing).
```typescript theme={null}
const syncStatus = await provider.eth_syncing();
// Response
```
**Returns:**
* `false` if node is fully synced
* `SyncStatus` object if syncing:
* `startingBlock: Quantity` - Block where sync started
* `currentBlock: Quantity` - Current synced block
* `highestBlock: Quantity` - Highest known block
**Usage:**
```typescript theme={null}
const response = await provider.eth_syncing();
if (response.data === false) {
console.log('Node is fully synced');
} else {
const { currentBlock, highestBlock } = response.data;
const progress = (parseInt(currentBlock, 16) / parseInt(highestBlock, 16)) * 100;
console.log(`Syncing: ${progress.toFixed(2)}% complete`);
}
```
### eth\_coinbase
Get the coinbase address (miner/validator).
```typescript theme={null}
const coinbase = await provider.eth_coinbase();
// Response
```
**Returns:** Address that receives mining/validation rewards
**Usage:**
```typescript theme={null}
const response = await provider.eth_coinbase();
console.log(`Coinbase address: ${response.data}`);
```
Returns null or zero address if not mining/validating
### eth\_accounts
List available accounts (if wallet is connected).
```typescript theme={null}
const accounts = await provider.eth_accounts();
// Response
```
**Returns:** Array of available account addresses
**Usage:**
```typescript theme={null}
const response = await provider.eth_accounts();
if (response.data.length === 0) {
console.log('No accounts available');
} else {
console.log(`Found ${response.data.length} account(s):`);
response.data.forEach((address, i) => {
console.log(` ${i + 1}. ${address}`);
});
}
```
Most public RPC nodes return empty array. Only works with personal/wallet connections.
## Common Patterns
### Network Detection
```typescript theme={null}
async function detectNetwork(provider: Provider) {
const response = await provider.eth_chainId();
const chainId = parseInt(response.data, 16);
const networks: Record = {
1: 'Ethereum Mainnet',
11155111: 'Sepolia',
17000: 'Holesky',
137: 'Polygon',
10: 'Optimism',
42161: 'Arbitrum One',
};
return networks[chainId] || `Unknown (${chainId})`;
}
```
### Check Node Readiness
```typescript theme={null}
async function isNodeReady(provider: Provider): Promise {
const syncResponse = await provider.eth_syncing();
// Node is ready if not syncing
if (syncResponse.data === false) {
return true;
}
// Check if syncing is near completion
const { currentBlock, highestBlock } = syncResponse.data;
const current = parseInt(currentBlock, 16);
const highest = parseInt(highestBlock, 16);
// Consider ready if within 10 blocks
return (highest - current) < 10;
}
```
### Verify Connection
```typescript theme={null}
async function verifyConnection(provider: Provider) {
try {
// Quick check - chainId is fast and always available
const response = await provider.eth_chainId();
return {
connected: true,
chainId: parseInt(response.data, 16),
};
} catch (error) {
return {
connected: false,
error: error.message,
};
}
}
```
## Related Methods
* [Block Methods](/jsonrpc-provider/eth-methods/index#block-methods) - Query block data
* [State Methods](/jsonrpc-provider/eth-methods/index#state-methods) - Query account state
* [Transaction Methods](/jsonrpc-provider/eth-methods/index#transaction-methods) - Send and query transactions
## See Also
* [Response Type](/jsonrpc-provider/types#response) - JSON-RPC response wrapper
* [Error Handling](/jsonrpc-provider/errors) - Handle RPC errors
* [EIP-695](https://eips.ethereum.org/EIPS/eip-695) - eth\_chainId specification
# State Query Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/state
Query Ethereum state with eth_getBalance, eth_getCode, eth_getStorageAt, eth_getProof
**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.
State methods query account balances, contract bytecode, storage, and Merkle proofs at specific block heights.
## eth\_getBalance
Get ether balance of an address.
```typescript theme={null}
const balance = await provider.eth_getBalance(address, 'latest');
// Response
```
**Parameters:**
* `address: Address` - Account address
* `blockTag: BlockTag` - Block to query
**Usage:**
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Address from '@tevm/voltaire/Address';
const provider = Provider({ url: 'https://eth.llamarpc.com' });
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
const balance = await provider.eth_getBalance(address, 'latest');
if (balance.isOk()) {
console.log(`Balance: ${balance.value} wei`);
}
```
## eth\_getCode
Get contract bytecode at an address.
```typescript theme={null}
const code = await provider.eth_getCode(address, 'latest');
// Response
```
**Parameters:**
* `address: Address` - Contract address
* `blockTag: BlockTag` - Block to query
**Usage:**
```typescript theme={null}
// Check if address is a contract
const code = await provider.eth_getCode(address, 'latest');
if (code.isOk() && code.value !== '0x') {
console.log('Address is a contract');
console.log('Bytecode:', code.value);
} else {
console.log('Address is an EOA');
}
```
## eth\_getStorageAt
Get value from a contract storage slot.
```typescript theme={null}
const value = await provider.eth_getStorageAt(
address,
Quantity(0),
'latest'
);
// Response
```
**Parameters:**
* `address: Address` - Contract address
* `position: Quantity` - Storage slot
* `blockTag: BlockTag` - Block to query
**Usage:**
```typescript theme={null}
import * as Quantity from '@tevm/voltaire/primitives/Quantity';
// Read storage slot 0
const value = await provider.eth_getStorageAt(
contractAddress,
Quantity(0),
'latest'
);
if (value.isOk()) {
console.log('Storage slot 0:', value.value);
}
// Read multiple slots
const slots = [0, 1, 2];
const values = await Promise.all(
slots.map(slot =>
provider.eth_getStorageAt(contractAddress, Quantity(slot), 'latest')
)
);
```
## eth\_getProof
Get Merkle proof for account and storage values.
```typescript theme={null}
const proof = await provider.eth_getProof(
address,
[Quantity(0), Quantity(1)],
'latest'
);
// Response
```
**Parameters:**
* `address: Address` - Account address
* `storageKeys: Quantity[]` - Storage slots to prove
* `blockTag: BlockTag` - Block to query
**Usage:**
```typescript theme={null}
// Get proof for account and storage
const proof = await provider.eth_getProof(
address,
[Quantity(0), Quantity(1)],
'latest'
);
if (proof.isOk()) {
console.log('Account proof:', proof.value.accountProof);
console.log('Storage proofs:', proof.value.storageProof);
console.log('Balance:', proof.value.balance);
console.log('Nonce:', proof.value.nonce);
console.log('Code hash:', proof.value.codeHash);
console.log('Storage hash:', proof.value.storageHash);
}
```
**Proof structure:**
```typescript theme={null}
interface Proof {
address: Address;
accountProof: Hex[];
balance: Quantity;
codeHash: Hash;
nonce: Quantity;
storageHash: Hash;
storageProof: {
key: Quantity;
value: Quantity;
proof: Hex[];
}[];
}
```
## Common Patterns
### Check account type
```typescript theme={null}
// Determine if address is contract or EOA
const [balance, code] = await Promise.all([
provider.eth_getBalance(address, 'latest'),
provider.eth_getCode(address, 'latest')
]);
if (balance.isOk() && code.isOk()) {
const isContract = code.value !== '0x';
const hasBalance = balance.value > 0n;
console.log('Account type:', isContract ? 'Contract' : 'EOA');
console.log('Has balance:', hasBalance);
}
```
### Verify state proof
```typescript theme={null}
// Get proof for account state
const proof = await provider.eth_getProof(
address,
[Quantity(0)],
'latest'
);
if (proof.isOk()) {
// Verify account proof against state root
const stateRoot = await provider.eth_getBlockByNumber('latest', false);
if (stateRoot.isOk()) {
// Verify Merkle proof
// (verification logic depends on your needs)
console.log('State root:', stateRoot.value.stateRoot);
console.log('Account proof valid');
}
}
```
### Read contract state
```typescript theme={null}
// Read multiple storage slots efficiently
async function readContractState(
provider: Provider,
address: Address,
slots: number[]
): Promise> {
const results = await Promise.all(
slots.map(slot =>
provider.eth_getStorageAt(address, Quantity(slot), 'latest')
)
);
const state = new Map();
for (let i = 0; i < slots.length; i++) {
if (results[i].isOk()) {
state.set(slots[i], results[i].value);
}
}
return state;
}
// Usage
const state = await readContractState(
provider,
contractAddress,
[0, 1, 2, 3, 4]
);
```
# Transaction Methods
Source: https://voltaire.tevm.sh/jsonrpc-provider/eth-methods/transactions
Submit, query, and track Ethereum transactions via JSON-RPC
**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.
# Transaction Methods
9 methods for submitting signed transactions, querying transaction data, and managing account nonces.
## Overview
Transaction methods handle the full lifecycle: submission, retrieval, receipt tracking, and nonce management.
```typescript theme={null}
import { Provider } from '@tevm/voltaire/provider';
import * as Rpc from '@tevm/voltaire/jsonrpc';
import * as Address from '@tevm/voltaire/Address';
import * as Hex from '@tevm/voltaire/Hex';
import { Keccak256 } from '@tevm/voltaire/Keccak256';
const provider = new Provider({ url: 'https://eth.llamarpc.com' });
const address = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0');
// Submit transaction
const txHash = await provider.request(Rpc.Eth.SendRawTransactionRequest(signedTx));
// Track transaction
const tx = await provider.request(Rpc.Eth.GetTransactionByHashRequest(txHash));
const receipt = await provider.request(Rpc.Eth.GetTransactionReceiptRequest(txHash));
// Get nonce
const nonce = await provider.request(Rpc.Eth.GetTransactionCountRequest(address, 'latest'));
```
## Methods
Submit a signed transaction to the network for execution.
**Parameters:**
* `signedTransaction: Hex` - Signed transaction bytes
**Returns:** `Hash` - Transaction hash
```typescript theme={null}
const txHash = await provider.request(Rpc.Eth.SendRawTransactionRequest(
Hex('0xf86c808504a817c800825208...')
));
// Hash
```
**Use cases:**
* Submit pre-signed transactions
* Broadcast transactions from offline signing
* Send transactions without wallet interaction
Sign and send a transaction (requires unlocked account). Most nodes disable this for security.
**Parameters:**
* `transaction: TransactionRequest` - Transaction parameters
* `from: Address` - Sender address (must be unlocked)
* `to?: Address` - Recipient address (omit for contract creation)
* `value?: Quantity` - ETH amount in wei
* `data?: Hex` - Transaction data
* `gas?: Quantity` - Gas limit
* `gasPrice?: Quantity` - Gas price (legacy)
* `maxFeePerGas?: Quantity` - Max fee (EIP-1559)
* `maxPriorityFeePerGas?: Quantity` - Max priority fee (EIP-1559)
* `nonce?: Quantity` - Transaction nonce
**Returns:** `Response` - Transaction hash
```typescript theme={null}
const txHash = await provider.eth_sendTransaction({
from: Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'),
to: Address('0x5FbDB2315678afecb367f032d93F642f64180aa3'),
value: Quantity(1000000000000000000n), // 1 ETH
data: Hex('0x')
});
// Response