entropa-core 0.1.1

Entropa core — post-quantum (ML-DSA / NIST FIPS-204) blockchain primitives: probes, transactions, blocks, and a verifiable chain seeded by a public randomness beacon.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Blocks and transactions.
//!
//! A [`Block`] is one point in Entropa's growing constellation. It bundles a set of
//! [`Transaction`]s, the cosmic-entropy `beacon` that seeded this round, the proposing
//! Probe's public identity, a blake3 `hash` over the canonical preimage, and a
//! post-quantum `signature` by the proposer over that hash.

use serde::{Deserialize, Serialize};

/// A single transaction — a signal the network records.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Transaction {
    /// Originating actor (a Probe id, or an external identifier).
    pub from: String,
    /// What kind of signal, e.g. `"transfer"`, `"register"`, `"attest"`.
    pub kind: String,
    /// Canonical payload or content-hash.
    pub payload: String,
}

impl Transaction {
    pub fn new(
        from: impl Into<String>,
        kind: impl Into<String>,
        payload: impl Into<String>,
    ) -> Self {
        Self {
            from: from.into(),
            kind: kind.into(),
            payload: payload.into(),
        }
    }
}

/// One block in the chain.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub prev_hash: String,
    /// Cosmic entropy beacon value that seeded this round.
    pub beacon: String,
    pub transactions: Vec<Transaction>,
    /// Proposing Probe's fingerprint, e.g. `PROBE-1A2B3C4D`.
    pub proposer_id: String,
    /// Proposing Probe's hex ML-DSA verifying key (used to verify `signature`).
    pub proposer_pubkey: String,
    /// blake3 digest (hex) over the canonical preimage.
    pub hash: String,
    /// Proposer's post-quantum ML-DSA signature (hex) over the raw digest bytes.
    pub signature: String,
}

/// Compute the canonical blake3 digest that a block's `hash` commits to and that the
/// proposer signs. Deterministic and order-sensitive — any change to any field
/// changes the digest.
pub fn block_digest(
    index: u64,
    timestamp: u64,
    prev_hash: &str,
    beacon: &str,
    transactions: &[Transaction],
    proposer_id: &str,
) -> [u8; 32] {
    let mut hasher = blake3::Hasher::new();
    hasher.update(&index.to_be_bytes());
    hasher.update(&timestamp.to_be_bytes());
    hasher.update(prev_hash.as_bytes());
    hasher.update(beacon.as_bytes());
    hasher.update(proposer_id.as_bytes());
    // Canonical serialization of the transaction set.
    let tx_bytes = serde_json::to_vec(transactions).expect("transactions serialize");
    hasher.update(&tx_bytes);
    *hasher.finalize().as_bytes()
}