Struct ChainId 

pub struct ChainId([u8; 32]);

Unique identifier for a Mina blockchain network.

ChainId is a 32-byte cryptographic hash that uniquely identifies a specific Mina blockchain network. It ensures network isolation by preventing nodes from different chains (mainnet, devnet, custom testnets) from connecting to each other.

Security Properties

The chain ID provides several security guarantees:

• Deterministic: Always produces the same ID for identical protocol parameters
• Collision Resistant: Uses Blake2b hashing to prevent ID conflicts
• Tamper Evident: Any change to protocol parameters changes the chain ID
• Network Isolation: Incompatible networks cannot connect accidentally

Computation Method

Chain IDs are computed using ChainId::compute() from these inputs:

1. Constraint System Digests: MD5 hashes of SNARK constraint systems
2. Genesis State Hash: Hash of the initial blockchain state
3. Genesis Constants: Protocol timing and consensus parameters
4. Protocol Versions: Transaction and network protocol versions
5. Transaction Pool Size: Maximum mempool configuration

The computation uses Blake2b-256 to hash these components in a specific order, ensuring reproducible results across different implementations.

Network Usage

Chain IDs are used throughout the networking stack:

• Peer Discovery: Nodes broadcast their chain ID during discovery
• Connection Handshakes: WebRTC offers include chain ID for validation
• Private Networks: preshared_key() generates libp2p private network keys
• Protocol Compatibility: Ensures all peers use compatible protocol versions

Serialization Formats

Chain IDs support multiple serialization formats:

• Hex String: Human-readable format for configuration files
• Binary: 32-byte array for network transmission
• JSON: String representation for APIs and debugging

Example Usage

use openmina_core::{ChainId, MAINNET_CHAIN_ID};

// Use predefined mainnet ID
let mainnet = MAINNET_CHAIN_ID;
println!("Mainnet: {}", mainnet.to_hex());

// Parse from configuration
let custom_id = ChainId::from_hex("29936104443aaf264a7f0192ac64b1c7173198c1ed404c1bcff5e562e05eb7f6")?;

// Generate private network key
let psk = mainnet.preshared_key();

Tuple Fields

0: [u8; 32]

Implementations

impl ChainId

pub fn compute( constraint_system_digests: &[[u8; 16]], genesis_state_hash: &StateHash, genesis_constants: &MinaBaseProtocolConstantsCheckedValueStableV1, protocol_transaction_version: u8, protocol_network_version: u8, tx_max_pool_size: &UnsignedExtendedUInt32StableV1, ) -> ChainId

Computes a chain ID from protocol parameters and network configuration.

This method creates a deterministic 32-byte chain identifier by hashing all the fundamental parameters that define a Mina blockchain network. Any change to these parameters will result in a different chain ID, ensuring network isolation and protocol compatibility.

Parameters

• constraint_system_digests - MD5 hashes of the SNARK constraint systems used for transaction and block verification
• genesis_state_hash - Hash of the initial blockchain state
• genesis_constants - Protocol constants including timing parameters, consensus settings, and economic parameters
• protocol_transaction_version - Version number of the transaction protocol
• protocol_network_version - Version number of the network protocol
• tx_max_pool_size - Maximum number of transactions in the mempool

Returns

A new ChainId representing the unique identifier for this network configuration.

Algorithm

The computation process:

1. Hash all constraint system digests into a combined string
2. Hash the genesis constants with transaction pool size
3. Create Blake2b-256 hash of:
   • Genesis state hash (as string)
   • Combined constraint system hash
   • Genesis constants hash (as hex)
   • Protocol transaction version (as MD5 hash)
   • Protocol network version (as MD5 hash)

Example

use openmina_core::ChainId;
use mina_p2p_messages::v2::UnsignedExtendedUInt32StableV1;

let chain_id = ChainId::compute(
    &constraint_digests,
    &genesis_hash,
    &protocol_constants,
    1,  // transaction version
    1,  // network version
    &UnsignedExtendedUInt32StableV1::from(3000),
);

pub fn preshared_key(&self) -> [u8; 32]

Generates a preshared key for libp2p private networking.

This method creates a cryptographic key used by libp2p’s private network (Pnet) protocol to ensure only nodes with the same chain ID can connect. The preshared key provides an additional layer of network isolation beyond basic chain ID validation.

Algorithm

The preshared key is computed as:

Blake2b-256("/coda/0.0.1/" + chain_id_hex)

The “/coda/0.0.1/” prefix is a protocol identifier that ensures the preshared key is unique to the Mina protocol and not accidentally compatible with other systems.

Returns

A 32-byte array containing the preshared key for this chain ID.

Usage

This key is used to configure libp2p’s private network transport, which encrypts all network traffic and prevents unauthorized nodes from joining the network even if they know peer addresses.

Example

use openmina_core::MAINNET_CHAIN_ID;

let psk = MAINNET_CHAIN_ID.preshared_key();
// Use psk to configure libp2p Pnet transport

pub fn to_hex(&self) -> String

Converts the chain ID to a hexadecimal string representation.

This method creates a lowercase hex string of the 32-byte chain ID, suitable for display, logging, configuration files, and JSON serialization.

Returns

A 64-character hexadecimal string representing the chain ID.

Example

use openmina_core::MAINNET_CHAIN_ID;

let hex_id = MAINNET_CHAIN_ID.to_hex();
assert_eq!(hex_id.len(), 64);
println!("Mainnet ID: {}", hex_id);

pub fn from_hex(s: &str) -> Result<ChainId, FromHexError>

Parses a chain ID from a hexadecimal string.

This method converts a hex string back into a ChainId instance. The input string must represent exactly 32 bytes (64 hex characters). Case-insensitive parsing is supported.

Parameters

• s - A hexadecimal string representing the chain ID

Returns

• Ok(ChainId) if the string is valid 64-character hex
• Err(hex::FromHexError) if the string is invalid or wrong length

Errors

This method returns an error if:

• The string contains non-hexadecimal characters
• The string length is not exactly 64 characters
• The string represents fewer than 32 bytes

Example

use openmina_core::ChainId;

let chain_id = ChainId::from_hex(
    "a7351abc7ddf2ea92d1b38cc8e636c271c1dfd2c081c637f62ebc2af34eb7cc1"
)?;

pub fn from_bytes(bytes: &[u8]) -> ChainId

Creates a chain ID from raw bytes.

This method constructs a ChainId from a byte slice, taking the first 32 bytes as the chain identifier. If the input has fewer than 32 bytes, the remaining bytes are zero-padded.

Parameters

• bytes - A byte slice containing at least 32 bytes

Returns

A new ChainId instance created from the input bytes.

Panics

This method will panic if the input slice has fewer than 32 bytes.

Example

use openmina_core::ChainId;

let bytes = [0u8; 32]; // All zeros for testing
let chain_id = ChainId::from_bytes(&bytes);

Trait Implementations

impl AsRef<[u8]> for ChainId

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl BinProtRead for ChainId

fn binprot_read<R: Read + ?Sized>(r: &mut R) -> Result<Self, Error>

where Self: Sized,

impl BinProtWrite for ChainId

fn binprot_write<W: Write>(&self, w: &mut W) -> Result<()>

impl Clone for ChainId

fn clone(&self) -> ChainId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChainId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChainId

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for ChainId

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

Formats the value using the given formatter.

impl PartialEq for ChainId

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ChainId

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for ChainId

impl StructuralPartialEq for ChainId