> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/a16z/jolt/llms.txt
> Use this file to discover all available pages before exploring further.

# BLAKE2 Inline

> High-performance BLAKE2b hash function for Jolt zkVM

## Overview

The BLAKE2 inline provides an optimized implementation of the BLAKE2b hash function with 512-bit output. BLAKE2 is faster than MD5, SHA-1, SHA-2, and SHA-3, while being at least as secure as SHA-3.

## API Reference

### Constants

```rust theme={null}
pub const IV: [u64; 8];  // BLAKE2b initialization vector
pub const SIGMA: [[usize; 16]; 12];  // Message permutation table

pub const STATE_VECTOR_LEN: usize = 8;
pub const STATE_SIZE_IN_BYTES: usize = 64;
pub const MSG_BLOCK_LEN: usize = 16;
pub const BLOCK_INPUT_SIZE_IN_BYTES: usize = 128;
pub const OUTPUT_SIZE_IN_BYTES: usize = 64;
```

### Initialization Vector

```rust theme={null}
pub const IV: [u64; 8] = [
    0x6a09e667f3bcc908,
    0xbb67ae8584caa73b,
    0x3c6ef372fe94f82b,
    0xa54ff53a5f1d36f1,
    0x510e527fade682d1,
    0x9b05688c2b3e6c1f,
    0x1f83d9abfb41bd6b,
    0x5be0cd19137e2179,
];
```

## Usage Examples

### Basic Hashing

```rust theme={null}
use blake2_inline::blake2b;

#[jolt::provable]
fn hash_data(data: &[u8]) -> [u8; 64] {
    blake2b(data)
}
```

### Keyed Hashing (MAC)

```rust theme={null}
use blake2_inline::blake2b_keyed;

#[jolt::provable]
fn create_mac(key: &[u8], message: &[u8]) -> [u8; 64] {
    blake2b_keyed(key, message)
}
```

### File Integrity Verification

```rust theme={null}
use blake2_inline::blake2b;

#[jolt::provable]
fn verify_file_hash(contents: &[u8], expected: [u8; 64]) -> bool {
    let hash = blake2b(contents);
    hash == expected
}
```

## Implementation Details

### Compression Function

BLAKE2b uses a compression function similar to ChaCha20:

* **State**: 8 × 64-bit words (512 bits)
* **Message block**: 16 × 64-bit words (1024 bits)
* **Rounds**: 12 rounds using the SIGMA permutation table

### SIGMA Permutation Table

The message schedule uses a 12-round permutation pattern:

```rust theme={null}
pub const SIGMA: [[usize; 16]; 12] = [
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
    [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
    // ... (10 more rounds)
];
```

### Custom Instruction

* **`BLAKE2_COMPRESS`** (funct3=0x00, funct7=0x02): Performs BLAKE2b compression

### Memory Layout

* **Input block**: 128 bytes (16 × 64-bit words)
* **State**: 64 bytes (8 × 64-bit words)
* **Output**: 64 bytes

## Performance Characteristics

* **Block size**: 128 bytes per compression
* **Output size**: 64 bytes (512 bits)
* **Speed**: Faster than SHA-2 and SHA-3 on modern hardware
* **Security**: 512-bit security level

## BLAKE2 Variants

The inline implements BLAKE2b (64-bit optimized). Other variants:

* **BLAKE2b**: Optimized for 64-bit platforms (this implementation)
* **BLAKE2s**: Optimized for 8-32 bit platforms (not included)
* **BLAKE2bp**: Parallel variant (not included)
* **BLAKE2sp**: Parallel variant for smaller platforms (not included)

## Feature Flags

* **`host`**: Enables reference implementation for host-side execution
  * Guest code: Compile WITHOUT this feature
  * Prover code: Compile WITH this feature

## Constants Reference

```rust theme={null}
pub const INLINE_OPCODE: u32 = 0x0B;
pub const BLAKE2_FUNCT3: u32 = 0x00;
pub const BLAKE2_FUNCT7: u32 = 0x02;
pub const BLAKE2_NAME: &str = "BLAKE2_INLINE";
```

## Comparison with Standard Implementation

* **Cycle count**: \~10-50x reduction compared to pure Rust implementation
* **Proving time**: Proportionally faster proof generation
* **Compatibility**: Standard BLAKE2b output format

## Security Properties

* **Collision resistance**: 512 bits
* **Pre-image resistance**: 512 bits
* **MAC security**: Full key size (up to 64 bytes)

## Source Code Location

```
jolt-inlines/blake2/
├── src/
│   ├── lib.rs          # Module definitions and constants
│   ├── sdk.rs          # Public API
│   ├── exec.rs         # Host-side reference implementation
│   └── sequence_builder.rs  # Instruction sequence generation
└── Cargo.toml
```

## See Also

* [BLAKE3](/api/inlines/blake3) - Next-generation BLAKE hash function
* [SHA-256](/api/inlines/sha2) - SHA-2 hash function
* [Keccak-256](/api/inlines/keccak256) - SHA-3 hash function
* [Inlines Overview](/api/inlines/overview) - General information about cryptographic inlines