Network Types and Traits

Network trait, implementations, and consensus parameters

The network module defines the Network trait and its implementations (MainnetV0, TestnetV0, CanaryV0). Networks specify consensus parameters, cryptographic functions, and blockchain configuration.

Network Trait

The core trait that defines a network’s parameters and capabilities.

Declaration

pub trait Network:
    'static
    + Environment
    + Copy
    + Clone
    + Debug
    + Eq
    + PartialEq
    + core::hash::Hash
    + Serialize
    + DeserializeOwned
    + for<'a> Deserialize<'a>
    + Send
    + Sync
{
    // Constants and methods
}

Identity Constants

ID · u16

The network ID (unique identifier)

NAME · &'static str

The long network name (e.g., “Mainnet”)

SHORT_NAME · &'static str

The short network name (e.g., “mainnet”)

Genesis Parameters

GENESIS_TIMESTAMP · i64

The fixed timestamp of the genesis block

GENESIS_COINBASE_TARGET · u64

The genesis block coinbase target

GENESIS_PROOF_TARGET · u64

The genesis block proof target

Supply and Economics

STARTING_SUPPLY · u64

Starting supply of Aleo credits (1.5B)

MAX_SUPPLY · u64

Maximum supply of Aleo credits (5B)

MAX_SUPPLY_LIMIT_HEIGHT · u32

Block height that upper bounds total supply to 5B

DEPLOYMENT_FEE_MULTIPLIER · u64

Cost in microcredits per byte for deployment (1,000)

CONSTRUCTOR_FEE_MULTIPLIER · u64

Multiplier in microcredits for each constructor command (100)

SYNTHESIS_FEE_MULTIPLIER · u64

Cost in microcredits per constraint (25)

MAX_FEE · u64

Maximum microcredits that can be spent as a fee (1T)

TRANSACTION_SPEND_LIMIT · [(ConsensusVersion, u64); 2]

Transaction spend limits by consensus version

Timing Parameters

BLOCK_TIME · u16

Expected time per block in seconds (10)

ANCHOR_TIME · u16

Anchor time in seconds (25)

ANCHOR_HEIGHT · u32

Expected blocks to reach coinbase target (ANCHOR_TIME / BLOCK_TIME)

NUM_BLOCKS_PER_EPOCH · u32

Number of blocks per epoch (360 blocks ≈ 1 hour)

Data Limits

MAX_DATA_ENTRIES · usize

Maximum number of entries in data (32)

MAX_DATA_DEPTH · usize

Maximum recursive depth of an entry (32)

MAX_DATA_SIZE_IN_FIELDS · u32

Maximum number of fields in data (must not exceed u16::MAX)

MIN_STRUCT_ENTRIES · usize

Minimum number of entries in a struct (1)

MAX_STRUCT_ENTRIES · usize

Maximum number of entries in a struct (32)

MIN_ARRAY_ELEMENTS · usize

Minimum number of elements in an array (1)

MAX_ARRAY_ELEMENTS · [(ConsensusVersion, usize); 3]

Maximum array elements by consensus version (32 → 512 → 2048)

MIN_RECORD_ENTRIES · usize

Minimum number of entries in a record (1, for owner)

MAX_RECORD_ENTRIES · usize

Maximum number of entries in a record (33)

Program Limits

MAX_PROGRAM_SIZE · [(ConsensusVersion, usize); 2]

Maximum program size in characters (100 kB → 512 kB)

MAX_MAPPINGS · usize

Maximum number of mappings in a program (31)

MAX_FUNCTIONS · usize

Maximum number of functions in a program (31)

MAX_STRUCTS · usize

Maximum number of structs in a program (310)

MAX_RECORDS · usize

Maximum number of records in a program (310)

MAX_CLOSURES · usize

Maximum number of closures in a program (62)

MAX_INSTRUCTIONS · usize

Maximum number of instructions in a closure/function (65,535)

MAX_COMMANDS · usize

Maximum number of commands in finalize (65,535)

MAX_WRITES · [(ConsensusVersion, u16); 2]

Maximum write commands in finalize (16 → 32)

MAX_INPUTS · usize

Maximum number of inputs per transition (16)

MAX_OUTPUTS · usize

Maximum number of outputs per transition (16)

MAX_IMPORTS · usize

Maximum number of imports (64)

MAX_TRANSACTION_SIZE · [(ConsensusVersion, usize); 2]

Maximum transaction size in bytes (128 kB → 768 kB)

Associated Types

StateRoot · type StateRoot: Bech32ID<Field<Self>>

The state root type

BlockHash · type BlockHash: Bech32ID<Field<Self>>

The block hash type

RatificationID · type RatificationID: Bech32ID<Field<Self>>

The ratification ID type

TransactionID · type TransactionID: Bech32ID<Field<Self>>

The transaction ID type

TransitionID · type TransitionID: Bech32ID<Field<Self>>

The transition ID type

Consensus Methods

CONSENSUS_VERSION · fn CONSENSUS_VERSION(height: u32) -> Result<ConsensusVersion>

Returns the consensus version active at the given height

CONSENSUS_HEIGHT · fn CONSENSUS_HEIGHT(version: ConsensusVersion) -> Result<u32>

Returns the height at which a consensus version becomes active

INCLUSION_UPGRADE_HEIGHT · fn INCLUSION_UPGRADE_HEIGHT() -> Result<u32>

Returns the block height where the inclusion proof will be updated

Cryptographic Functions

Commitment Functions

commit_bhp256 · fn commit_bhp256(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

BHP commitment with 256-bit input hasher

commit_bhp512 · fn commit_bhp512(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

BHP commitment with 512-bit input hasher

commit_bhp768 · fn commit_bhp768(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

BHP commitment with 768-bit input hasher

commit_bhp1024 · fn commit_bhp1024(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

BHP commitment with 1024-bit input hasher

commit_ped64 · fn commit_ped64(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

Pedersen commitment for up to 64-bit input

commit_ped128 · fn commit_ped128(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>

Pedersen commitment for up to 128-bit input

Hash Functions

hash_bhp256 · fn hash_bhp256(input: &[bool]) -> Result<Field<Self>>

BHP hash with 256-bit input hasher

hash_bhp512 · fn hash_bhp512(input: &[bool]) -> Result<Field<Self>>

BHP hash with 512-bit input hasher

hash_bhp768 · fn hash_bhp768(input: &[bool]) -> Result<Field<Self>>

BHP hash with 768-bit input hasher

hash_bhp1024 · fn hash_bhp1024(input: &[bool]) -> Result<Field<Self>>

BHP hash with 1024-bit input hasher

hash_psd2 · fn hash_psd2(input: &[Field<Self>]) -> Result<Field<Self>>

Poseidon hash with input rate of 2

hash_psd4 · fn hash_psd4(input: &[Field<Self>]) -> Result<Field<Self>>

Poseidon hash with input rate of 4

hash_psd8 · fn hash_psd8(input: &[Field<Self>]) -> Result<Field<Self>>

Poseidon hash with input rate of 8

hash_keccak256 · fn hash_keccak256(input: &[bool]) -> Result<Vec<bool>>

Keccak hash with 256-bit output

hash_sha3_256 · fn hash_sha3_256(input: &[bool]) -> Result<Vec<bool>>

SHA-3 hash with 256-bit output

Hash to Group/Scalar

hash_to_group_psd2 · fn hash_to_group_psd2(input: &[Field<Self>]) -> Result<Group<Self>>

Poseidon hash to group with input rate of 2

hash_to_group_psd4 · fn hash_to_group_psd4(input: &[Field<Self>]) -> Result<Group<Self>>

Poseidon hash to group with input rate of 4

hash_to_group_psd8 · fn hash_to_group_psd8(input: &[Field<Self>]) -> Result<Group<Self>>

Poseidon hash to group with input rate of 8

hash_to_scalar_psd2 · fn hash_to_scalar_psd2(input: &[Field<Self>]) -> Result<Scalar<Self>>

Poseidon hash to scalar with input rate of 2

hash_to_scalar_psd4 · fn hash_to_scalar_psd4(input: &[Field<Self>]) -> Result<Scalar<Self>>

Poseidon hash to scalar with input rate of 4

hash_to_scalar_psd8 · fn hash_to_scalar_psd8(input: &[Field<Self>]) -> Result<Scalar<Self>>

Poseidon hash to scalar with input rate of 8

Merkle Trees

merkle_tree_bhp · fn merkle_tree_bhp<const DEPTH: u8>(leaves: &[Vec<bool>]) -> Result<BHPMerkleTree<Self, DEPTH>>

Merkle tree with BHP leaf hasher (1024-bit) and path hasher (512-bit)

merkle_tree_psd · fn merkle_tree_psd<const DEPTH: u8>(leaves: &[Vec<Field<Self>>]) -> Result<PoseidonMerkleTree<Self, DEPTH>>

Merkle tree with Poseidon leaf hasher (rate 4) and path hasher (rate 2)

verify_merkle_path_bhp · fn verify_merkle_path_bhp<const DEPTH: u8>(path: &MerklePath<Self, DEPTH>, root: &Field<Self>, leaf: &Vec<bool>) -> bool

Verifies a BHP Merkle path

verify_merkle_path_psd · fn verify_merkle_path_psd<const DEPTH: u8>(path: &MerklePath<Self, DEPTH>, root: &Field<Self>, leaf: &Vec<Field<Self>>) -> bool

Verifies a Poseidon Merkle path

Domain Separators

commitment_domain · fn commitment_domain() -> Field<Self>

Returns the commitment domain constant

encryption_domain · fn encryption_domain() -> Field<Self>

Returns the encryption domain constant

graph_key_domain · fn graph_key_domain() -> Field<Self>

Returns the graph key domain constant

serial_number_domain · fn serial_number_domain() -> Field<Self>

Returns the serial number domain constant

MainnetV0

The production Aleo network.

Example

use snarkvm_console::network::{MainnetV0, Network};

type CurrentNetwork = MainnetV0;

println!("Network ID: {}", CurrentNetwork::ID);
println!("Network Name: {}", CurrentNetwork::NAME);
println!("Block Time: {}s", CurrentNetwork::BLOCK_TIME);
println!("Max Supply: {} credits", CurrentNetwork::MAX_SUPPLY);

Configuration

// Network identity
ID: 0
NAME: "Mainnet"
SHORT_NAME: "mainnet"

// Genesis parameters
GENESIS_TIMESTAMP: specific timestamp
GENESIS_COINBASE_TARGET: specific target
GENESIS_PROOF_TARGET: specific target

TestnetV0

The test network for development and testing.

Example

use snarkvm_console::network::{TestnetV0, Network};

type CurrentNetwork = TestnetV0;

// Use TestnetV0 for development
let private_key = PrivateKey::<CurrentNetwork>::new(&mut rng)?;

Configuration

// Network identity
ID: 1
NAME: "Testnet"
SHORT_NAME: "testnet"

// Same limits as mainnet but different genesis parameters

CanaryV0

The canary network for testing upgrades.

Example

use snarkvm_console::network::{CanaryV0, Network};

type CurrentNetwork = CanaryV0;

Configuration

// Network identity
ID: 2
NAME: "Canary"
SHORT_NAME: "canary"

Helper Types

BHPMerkleTree

pub type BHPMerkleTree<N, const DEPTH: u8> = 
    MerkleTree<N, BHP1024<N>, BHP512<N>, DEPTH>;

Merkle tree using BHP hash functions.

PoseidonMerkleTree

pub type PoseidonMerkleTree<N, const DEPTH: u8> = 
    MerkleTree<N, Poseidon4<N>, Poseidon2<N>, DEPTH>;

Merkle tree using Poseidon hash functions.

Consensus Versions

Networks support multiple consensus versions:

pub enum ConsensusVersion {
    V1,
    V10,
    V11,
    V14,
    // etc.
}

Querying Consensus

use snarkvm_console::network::{MainnetV0, Network, ConsensusVersion};

type CurrentNetwork = MainnetV0;

// Get consensus version at a specific height
let version = CurrentNetwork::CONSENSUS_VERSION(1000)?;

// Get height when a version activates
let height = CurrentNetwork::CONSENSUS_HEIGHT(ConsensusVersion::V14)?;

// Get latest max array elements
let max_array = CurrentNetwork::LATEST_MAX_ARRAY_ELEMENTS();

Using Network Parameters

Example: Fee Calculation

use snarkvm_console::network::{MainnetV0, Network};

type CurrentNetwork = MainnetV0;

// Calculate deployment fee
let program_size = 50_000; // 50 kB
let deployment_fee = program_size as u64 * CurrentNetwork::DEPLOYMENT_FEE_MULTIPLIER;
println!("Deployment fee: {} microcredits", deployment_fee);

// Check transaction size limit
let tx_size = 100_000;
assert!(tx_size <= CurrentNetwork::LATEST_MAX_TRANSACTION_SIZE());

Example: Using Cryptographic Functions

use snarkvm_console::network::{MainnetV0, Network};
use snarkvm_console::types::{Field, Scalar};

type CurrentNetwork = MainnetV0;

// Hash data
let data = vec![true, false, true, true];
let hash = CurrentNetwork::hash_bhp256(&data)?;

// Commit with randomizer
let randomizer = Scalar::<CurrentNetwork>::rand(&mut rng);
let commitment = CurrentNetwork::commit_bhp512(&data, &randomizer)?;

// Poseidon hash
let fields = vec![Field::from_u64(1), Field::from_u64(2)];
let hash = CurrentNetwork::hash_psd2(&fields)?;

Example: Merkle Trees

use snarkvm_console::network::{MainnetV0, Network};

type CurrentNetwork = MainnetV0;

// Create BHP Merkle tree
let leaves = vec![
    vec![true, false, true],
    vec![false, true, false],
];
let tree = CurrentNetwork::merkle_tree_bhp::<3>(&leaves)?;

// Get root and proof
let root = tree.root();
let proof = tree.prove(0, &leaves[0])?;

// Verify proof
assert!(CurrentNetwork::verify_merkle_path_bhp(&proof, &root, &leaves[0]));

See Also

• Console Overview - Console module architecture
• Console Types - Primitive types used with networks
• Algorithms - Cryptographic algorithm implementations