Struct Chain 

pub struct Chain {
    pub blocks: Vec<Block>,
}

An append-only chain of post-quantum-signed blocks.

Fields

blocks: Vec<Block>

Implementations

impl Chain

pub fn genesis( founder: &Probe, timestamp: u64, beacon: impl Into<String>, ) -> Self

Create a new chain, proposing the genesis (“Big Bang”) block with founder.

pub fn draft( &self, proposer: &Probe, timestamp: u64, beacon: impl Into<String>, transactions: Vec<Transaction>, ) -> Block

Build and post-quantum-sign the next block without appending it.

Lets a proposer broadcast the exact block it will append. The block links to the current head (or BIG_BANG if the chain is empty).

pub fn try_append(&mut self, block: Block) -> Result<(), ChainError>

Validate a block against the current head (index, link, hash, proposer fingerprint, PQC signature) and append it. Does not enforce consensus rules (who may propose) — that is the node layer’s job.

pub fn propose( &mut self, proposer: &Probe, timestamp: u64, beacon: impl Into<String>, transactions: Vec<Transaction>, ) -> u64

Propose (draft + append) the next block with proposer. Returns its index.

pub fn verify(&self) -> Result<(), ChainError>

Verify the entire chain: links, hashes, and every post-quantum signature.

Examples found in repository

examples/verify_backup.rs (line 9)

fn main() {
    let path = std::env::args().nth(1).expect("path to blocks JSON");
    let data = std::fs::read_to_string(&path).expect("read file");
    let blocks: Vec<Block> = serde_json::from_str(&data).expect("parse blocks");
    println!("loaded {} blocks", blocks.len());
    let chain = Chain { blocks };
    match chain.verify() {
        Ok(()) => println!("VERIFY OK"),
        Err(e) => println!("VERIFY FAILED: {e:?}"),
    }
}

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn head(&self) -> Option<&Block>

Trait Implementations

impl Clone for Chain

fn clone(&self) -> Chain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Chain

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

Formats the value using the given formatter.

impl Default for Chain

fn default() -> Chain

Returns the “default value” for a type.