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)
Accepts arbitrary-length byte array. No restrictions on input size.
Offset | Length | Description
-------|--------|-------------
0 | 32 | SHA-256 hash of input
Usage Example
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
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:
// Bitcoin block hash = SHA256(SHA256(header))
const firstHash = executeSHA256(blockHeader);
const blockHash = executeSHA256(firstHash.output);
- Per-byte cost: ~0.375 gas/byte
- Prefer hashing larger inputs over multiple small ones
References
Specifications
