From 6aeac94810b3a740ed2ef7fae8dd82c4c6fa6204 Mon Sep 17 00:00:00 2001 From: augustin Date: Fri, 23 Oct 2026 10:44:44 +0200 Subject: [PATCH 1/3] Add source-bound Alpenglow footer facts and readers --- .github/workflows/ci.yml | 10 +- .../src/consensus.rs | 320 ++++++++ crates/blockzilla-bank-stream-v2/src/lib.rs | 1 + .../tests/consensus.rs | 348 +++++++++ .../fixtures/agave-4.3.2-footer-v1.wincode | Bin 0 -> 207 bytes .../fixtures/captured-footer-3384311167.json | 21 + .../captured-footer-3384311167.wincode | Bin 0 -> 556 bytes .../architecture/alpenglow-consensus-facts.md | 195 +++++ .../evidence/alpenglow-format-20261023.json | 249 +++++++ hivezilla/direct-agave/README.md | 19 + hivezilla/direct-agave/src/consensus.rs | 638 ++++++++++++++++ hivezilla/direct-agave/src/consensus_tests.rs | 691 ++++++++++++++++++ hivezilla/direct-agave/src/lib.rs | 1 + hivezilla/direct-agave/src/main.rs | 87 ++- hivezilla/stream-relay/client/README.md | 7 + .../stream-relay/client/consensus-test.mjs | 92 +++ hivezilla/stream-relay/client/consensus.d.mts | 39 + hivezilla/stream-relay/client/consensus.mjs | 71 ++ .../client/decoder-consensus-v1.wasm | Bin 0 -> 821314 bytes hivezilla/stream-relay/client/package.json | 6 +- hivezilla/stream-relay/decoder/README.md | 13 + .../stream-relay/decoder/src/consensus.rs | 42 ++ hivezilla/stream-relay/decoder/src/lib.rs | 2 + 23 files changed, 2848 insertions(+), 4 deletions(-) create mode 100644 crates/blockzilla-bank-stream-v2/src/consensus.rs create mode 100644 crates/blockzilla-bank-stream-v2/tests/consensus.rs create mode 100644 crates/blockzilla-bank-stream-v2/tests/fixtures/agave-4.3.2-footer-v1.wincode create mode 100644 crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.json create mode 100644 crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.wincode create mode 100644 docs/architecture/alpenglow-consensus-facts.md create mode 100644 docs/operations/evidence/alpenglow-format-20261023.json create mode 100644 hivezilla/direct-agave/src/consensus.rs create mode 100644 hivezilla/direct-agave/src/consensus_tests.rs create mode 100644 hivezilla/stream-relay/client/consensus-test.mjs create mode 100644 hivezilla/stream-relay/client/consensus.d.mts create mode 100644 hivezilla/stream-relay/client/consensus.mjs create mode 100644 hivezilla/stream-relay/client/decoder-consensus-v1.wasm create mode 100644 hivezilla/stream-relay/decoder/src/consensus.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6e7c604..e4687a1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,9 +99,17 @@ jobs: hivezilla/stream-relay/examples/rust-consumer/Cargo.toml; do cargo test --locked --manifest-path "$manifest" done + - name: Build the shared consensus Wasm reader + env: + RUSTFLAGS: "" + CARGO_TARGET_DIR: target/consensus-wasm + run: | + rustup target add wasm32-unknown-unknown + cargo build --locked --release --target wasm32-unknown-unknown --manifest-path hivezilla/stream-relay/decoder/Cargo.toml + cp target/consensus-wasm/wasm32-unknown-unknown/release/blockzilla_stream_decoder.wasm hivezilla/stream-relay/client/decoder-consensus-v1.wasm - name: Test JavaScript SDK and Wasm fixtures working-directory: hivezilla/stream-relay/client - run: node --test test.mjs sdk-test.mjs banks-test.mjs + run: node --test test.mjs sdk-test.mjs banks-test.mjs consensus-test.mjs - name: Test release graph inspection run: python3 scripts/test_check_crate_release.py diff --git a/crates/blockzilla-bank-stream-v2/src/consensus.rs b/crates/blockzilla-bank-stream-v2/src/consensus.rs new file mode 100644 index 0000000..923e19f --- /dev/null +++ b/crates/blockzilla-bank-stream-v2/src/consensus.rs @@ -0,0 +1,320 @@ +//! Immutable, source-bound native footer facts. This profile is independent of +//! execution Frame v2. Native bytes use the pinned Agave 4.3.2 grammar; the view +//! preserves observations, not a claim that a certificate or BLS signature was verified. +use crate::{BankIdentity, SAFE, SourceIdentity, is_digest}; +use anyhow::{Context, Result, ensure}; +use serde::{Deserialize, Serialize, Serializer}; + +pub const PROFILE: &str = "native-consensus-fact-v1"; +pub const NATIVE_REVISION: &str = "87167f3906bdf5111e99ead64d8f4098b7874e33"; +pub const OFFICIAL_REVISION: &str = "a203300045b405f86c9c84308b2eae76af69ac3b"; +pub const NATIVE_SCHEMA: &str = "agave-4.3.2-versioned-block-footer-v1"; +pub const VERIFICATION: &str = "captured_not_verified"; +pub const MAGIC: &[u8; 8] = b"BZCNF001"; +pub const VERSION: u16 = 1; +pub const MAX_BINDING_BYTES: usize = 4096; +/// Agave's enclosing LengthPrefixed block marker has a u16 byte length. +pub const MAX_FOOTER_BYTES: usize = u16::MAX as usize; +pub const HEADER_BYTES: usize = 20; +pub const MAX_FACT_BYTES: usize = HEADER_BYTES + MAX_BINDING_BYTES + MAX_FOOTER_BYTES; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct FactBinding { + pub source: SourceIdentity, + pub bank: BankIdentity, + pub execution_payload_sha256: String, + pub source_event_sequence: u64, + pub source_event_sha256: String, +} +impl FactBinding { + pub fn validate(&self) -> Result<()> { + self.source.validate()?; + self.bank.validate()?; + ensure!( + (self.source.agave_revision == NATIVE_REVISION + || self.source.agave_revision == OFFICIAL_REVISION), + "unsupported_native_footer_revision" + ); + ensure!( + (1..=SAFE).contains(&self.source_event_sequence) + && is_digest(&self.execution_payload_sha256) + && is_digest(&self.source_event_sha256), + "invalid_consensus_fact_binding" + ); + Ok(()) + } +} + +/// The exact native footer occurs once in the stored fact. Its parsed view is +/// borrowed on demand. The event digest is a binding to external captured +/// evidence, not a digest of the footer alone; the exporter must check that evidence. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ConsensusFact { + pub binding: FactBinding, + footer_wire: Vec, +} +impl ConsensusFact { + pub fn new(binding: FactBinding, footer_wire: Vec) -> Result { + binding.validate()?; + decode_footer(&footer_wire)?; + Ok(Self { + binding, + footer_wire, + }) + } + pub fn footer_wire(&self) -> &[u8] { + &self.footer_wire + } + pub fn footer(&self) -> Result> { + decode_footer(&self.footer_wire) + } + pub fn validate_binding(&self, expected: &FactBinding) -> Result<()> { + self.binding.validate()?; + expected.validate()?; + ensure!(&self.binding == expected, "consensus_fact_binding_mismatch"); + Ok(()) + } +} + +/// Fixed little-endian header: magic8, portable version u16, native grammar +/// code u16 (=1), binding JSON length u32, native footer length u32. JSON +/// carries only the binding. The footer is exact pinned native Wincode bytes. +pub fn encode(fact: &ConsensusFact) -> Result> { + fact.binding.validate()?; + decode_footer(fact.footer_wire())?; + let binding = serde_json::to_vec(&fact.binding)?; + ensure!( + !binding.is_empty() && binding.len() <= MAX_BINDING_BYTES, + "consensus_binding_too_large" + ); + let mut output = Vec::with_capacity(HEADER_BYTES + binding.len() + fact.footer_wire.len()); + output.extend_from_slice(MAGIC); + output.extend_from_slice(&VERSION.to_le_bytes()); + output.extend_from_slice(&1_u16.to_le_bytes()); + output.extend_from_slice(&(binding.len() as u32).to_le_bytes()); + output.extend_from_slice(&(fact.footer_wire.len() as u32).to_le_bytes()); + output.extend_from_slice(&binding); + output.extend_from_slice(fact.footer_wire()); + Ok(output) +} +pub fn decode(bytes: &[u8]) -> Result { + ensure!(bytes.len() <= MAX_FACT_BYTES, "consensus_fact_too_large"); + let mut c = Cursor::new(bytes); + ensure!(c.take(8)? == MAGIC, "invalid_consensus_fact_magic"); + ensure!(c.u16()? == VERSION, "unsupported_consensus_fact_version"); + ensure!(c.u16()? == 1, "unsupported_native_footer_schema"); + let binding_len = c.u32()? as usize; + let footer_len = c.u32()? as usize; + ensure!( + (1..=MAX_BINDING_BYTES).contains(&binding_len) + && (1..=MAX_FOOTER_BYTES).contains(&footer_len), + "invalid_consensus_fact_lengths" + ); + let expected = HEADER_BYTES + .checked_add(binding_len) + .and_then(|n| n.checked_add(footer_len)) + .context("consensus_fact_length_overflow")?; + ensure!(bytes.len() == expected, "consensus_fact_length_mismatch"); + let binding: FactBinding = serde_json::from_slice(c.take(binding_len)?)?; + binding.validate()?; + let footer = c.take(footer_len)?; + decode_footer(footer)?; // Validate all lengths before copying the one raw value. + c.end()?; + ConsensusFact::new(binding, footer.to_vec()) +} +pub fn decode_bound(bytes: &[u8], expected: &FactBinding) -> Result { + let value = decode(bytes)?; + value.validate_binding(expected)?; + Ok(value) +} + +fn decimal_u64(value: &u64, serializer: S) -> std::result::Result { + serializer.serialize_str(&value.to_string()) +} +/// A Votor consensus target identity. It is deliberately a different type +/// from an execution bank hash or a recent blockhash. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] +#[serde(transparent)] +pub struct ConsensusBlockId(pub [u8; 32]); + +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct Aggregate<'a> { + /// Exactly 96 captured compressed BLS bytes. Not cryptographically verified. + pub signature: &'a [u8], + pub bitmap: &'a [u8], +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct FinalizationCertificate<'a> { + #[serde(serialize_with = "decimal_u64")] + pub slot: u64, + /// Consensus BlockId targeted by this certificate, not its carrier's ID. + pub block_id: ConsensusBlockId, + pub final_aggregate: Aggregate<'a>, + pub notar_aggregate: Option>, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct SkipRewardCertificate<'a> { + #[serde(serialize_with = "decimal_u64")] + pub slot: u64, + pub aggregate: Aggregate<'a>, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct NotarRewardCertificate<'a> { + #[serde(serialize_with = "decimal_u64")] + pub slot: u64, + pub block_id: ConsensusBlockId, + pub aggregate: Aggregate<'a>, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct FooterView<'a> { + pub native_schema: &'static str, + pub verification: &'static str, + /// Execution bank hash from the footer; not the consensus BlockId or the + /// BankIdentity recent blockhash. No equality between those is inferred. + pub bank_hash: [u8; 32], + #[serde(serialize_with = "decimal_u64")] + pub block_producer_time_nanos: u64, + pub block_user_agent: &'a [u8], + pub block_final_cert: Option>, + /// Reward aggregates are retained separately from finalization certificates. + pub skip_reward_cert: Option>, + pub notar_reward_cert: Option>, +} + +/// Decode exactly VersionedBlockFooter::V1 as serialized by the pinned plugin. +/// No outer BlockMarker tag/length prefix, PoH inference, trial schema decode, +/// current-bank consensus ID or signature verification is introduced. +pub fn decode_footer(bytes: &[u8]) -> Result> { + ensure!( + !bytes.is_empty() && bytes.len() <= MAX_FOOTER_BYTES, + "native_footer_size_invalid" + ); + let mut c = Cursor::new(bytes); + ensure!(c.u8()? == 1, "unsupported_native_footer_version"); + let bank_hash = c.hash()?; + let block_producer_time_nanos = c.u64()?; + let user_agent_len = c.u8()? as usize; + let block_user_agent = c.take(user_agent_len)?; + let block_final_cert = if c.option()? { + let slot = c.u64()?; + let block_id = ConsensusBlockId(c.hash()?); + let final_aggregate = c.aggregate(false)?; + let notar_aggregate = if c.option()? { + Some(c.aggregate(false)?) + } else { + None + }; + Some(FinalizationCertificate { + slot, + block_id, + final_aggregate, + notar_aggregate, + }) + } else { + None + }; + let skip_reward_cert = if c.option()? { + Some(SkipRewardCertificate { + slot: c.u64()?, + aggregate: c.aggregate(true)?, + }) + } else { + None + }; + let notar_reward_cert = if c.option()? { + Some(NotarRewardCertificate { + slot: c.u64()?, + block_id: ConsensusBlockId(c.hash()?), + aggregate: c.aggregate(true)?, + }) + } else { + None + }; + c.end()?; + Ok(FooterView { + native_schema: NATIVE_SCHEMA, + verification: VERIFICATION, + bank_hash, + block_producer_time_nanos, + block_user_agent, + block_final_cert, + skip_reward_cert, + notar_reward_cert, + }) +} + +struct Cursor<'a> { + bytes: &'a [u8], + position: usize, +} +impl<'a> Cursor<'a> { + fn new(bytes: &'a [u8]) -> Self { + Self { bytes, position: 0 } + } + fn take(&mut self, n: usize) -> Result<&'a [u8]> { + let end = self + .position + .checked_add(n) + .context("native_footer_length_overflow")?; + let value = self + .bytes + .get(self.position..end) + .context("truncated_consensus_fact")?; + self.position = end; + Ok(value) + } + fn u8(&mut self) -> Result { + Ok(self.take(1)?[0]) + } + fn u16(&mut self) -> Result { + Ok(u16::from_le_bytes(self.take(2)?.try_into()?)) + } + fn u32(&mut self) -> Result { + Ok(u32::from_le_bytes(self.take(4)?.try_into()?)) + } + fn u64(&mut self) -> Result { + Ok(u64::from_le_bytes(self.take(8)?.try_into()?)) + } + fn hash(&mut self) -> Result<[u8; 32]> { + Ok(self.take(32)?.try_into()?) + } + fn option(&mut self) -> Result { + match self.u8()? { + 0 => Ok(false), + 1 => Ok(true), + _ => anyhow::bail!("invalid_native_footer_option"), + } + } + fn short_u16(&mut self) -> Result { + let a = self.u8()?; + if a < 128 { + return Ok(a as usize); + } + let b = self.u8()?; + if b < 128 { + ensure!(b != 0, "noncanonical_short_u16"); + return Ok((a as usize & 127) | ((b as usize) << 7)); + } + let d = self.u8()?; + ensure!((1..=3).contains(&d), "invalid_short_u16"); + Ok((a as usize & 127) | ((b as usize & 127) << 7) | ((d as usize) << 14)) + } + fn aggregate(&mut self, short: bool) -> Result> { + let signature = self.take(96)?; + let len = if short { + self.short_u16()? + } else { + self.u16()? as usize + }; + let bitmap = self.take(len)?; + Ok(Aggregate { signature, bitmap }) + } + fn end(&self) -> Result<()> { + ensure!( + self.position == self.bytes.len(), + "trailing_consensus_fact_bytes" + ); + Ok(()) + } +} diff --git a/crates/blockzilla-bank-stream-v2/src/lib.rs b/crates/blockzilla-bank-stream-v2/src/lib.rs index 1c77161..621b141 100644 --- a/crates/blockzilla-bank-stream-v2/src/lib.rs +++ b/crates/blockzilla-bank-stream-v2/src/lib.rs @@ -654,6 +654,7 @@ impl Notice { } } +pub mod consensus; #[cfg(not(target_arch = "wasm32"))] pub mod artifact; pub mod chain; diff --git a/crates/blockzilla-bank-stream-v2/tests/consensus.rs b/crates/blockzilla-bank-stream-v2/tests/consensus.rs new file mode 100644 index 0000000..05a57a3 --- /dev/null +++ b/crates/blockzilla-bank-stream-v2/tests/consensus.rs @@ -0,0 +1,348 @@ +use blockzilla_bank_stream_v2::{BankIdentity, SourceIdentity, consensus::*}; + +fn binding() -> FactBinding { + FactBinding { + source: SourceIdentity { + genesis_hash: "11111111111111111111111111111111".into(), + node_identity: "11111111111111111111111111111111".into(), + agave_revision: NATIVE_REVISION.into(), + session_id: "native-test-1".into(), + }, + bank: BankIdentity { + slot: 460_000_100, + bank_id: 23, + blockhash: [8; 32], + parent_slot: 460_000_099, + parent_blockhash: [7; 32], + }, + execution_payload_sha256: "ab".repeat(32), + source_event_sequence: 123, + source_event_sha256: "cd".repeat(32), + } +} +fn short(n: usize) -> Vec { + let mut value = n; + let mut out = Vec::new(); + loop { + let low = (value & 127) as u8; + value >>= 7; + out.push(low | if value > 0 { 128 } else { 0 }); + if value == 0 { + return out; + } + } +} +fn aggregate(out: &mut Vec, byte: u8, bitmap: &[u8], is_short: bool) { + out.extend_from_slice(&[byte; 96]); + out.extend(if is_short { + short(bitmap.len()) + } else { + (bitmap.len() as u16).to_le_bytes().to_vec() + }); + out.extend_from_slice(bitmap); +} +// Fixed schema fixture follows Agave87167 entry/block_component.rs240–247, +//299–328 and votor-messages/reward_certificate.rs34–42,75–85. Signatures are +//deliberate test bytes; this fixture makes no BLS or mainnet-capture claim. +fn fixture() -> Vec { + let mut bytes = vec![1]; + bytes.extend_from_slice(&[9; 32]); + bytes.extend_from_slice(&1_792_737_800_123_456_789u64.to_le_bytes()); + bytes.push(3); + bytes.extend_from_slice(b"abc"); + bytes.push(1); + bytes.extend_from_slice(&459_999_900u64.to_le_bytes()); + bytes.extend_from_slice(&[10; 32]); + aggregate(&mut bytes, 0x11, &[0x80, 0xff], false); + bytes.push(1); + aggregate(&mut bytes, 0x22, &[0x03], false); + bytes.push(1); + bytes.extend_from_slice(&459_999_899u64.to_le_bytes()); + aggregate(&mut bytes, 0x33, &[0x55; 128], true); + bytes.push(1); + bytes.extend_from_slice(&459_999_898u64.to_le_bytes()); + bytes.extend_from_slice(&[11; 32]); + aggregate(&mut bytes, 0x44, &[0x66], true); + bytes +} +fn minimal() -> Vec { + let mut bytes = vec![1]; + bytes.extend_from_slice(&[3; 32]); + bytes.extend_from_slice(&u64::MAX.to_le_bytes()); + bytes.extend_from_slice(&[0, 0, 0, 0]); + bytes +} +#[test] +fn exact_footer_and_portable_fact_round_trip_without_duplicate_storage() { + let wire = fixture(); + let fact = ConsensusFact::new(binding(), wire.clone()).unwrap(); + let encoded = encode(&fact).unwrap(); + assert_eq!(&encoded[..8], b"BZCNF001"); + assert_eq!(&encoded[8..12], &[1, 0, 1, 0]); + let n = u32::from_le_bytes(encoded[12..16].try_into().unwrap()) as usize; + assert_eq!(encoded.len(), HEADER_BYTES + n + wire.len()); + assert_eq!(&encoded[HEADER_BYTES + n..], wire); + let decoded = decode_bound(&encoded, &binding()).unwrap(); + assert_eq!(decoded, fact); + assert_eq!(encode(&decoded).unwrap(), encoded); + let view = decoded.footer().unwrap(); + assert_eq!(view.bank_hash, [9; 32]); + assert_ne!(view.bank_hash, decoded.binding.bank.blockhash); + assert_eq!(view.block_producer_time_nanos, 1_792_737_800_123_456_789); + assert_eq!(view.block_user_agent, b"abc"); + let cert = view.block_final_cert.unwrap(); + assert_eq!(cert.slot, 459_999_900); + assert_eq!(cert.block_id, ConsensusBlockId([10; 32])); + assert_ne!(cert.slot, decoded.binding.bank.slot); + assert_eq!(cert.final_aggregate.signature, &[0x11; 96]); + assert_eq!(cert.final_aggregate.bitmap, &[0x80, 0xff]); + assert_eq!(cert.notar_aggregate.unwrap().signature, &[0x22; 96]); + assert_eq!( + view.skip_reward_cert.unwrap().aggregate.bitmap, + &[0x55; 128] + ); + assert_eq!( + view.notar_reward_cert.unwrap().block_id, + ConsensusBlockId([11; 32]) + ); +} +#[test] +fn json_preserves_nanos_and_unknown_is_never_tower_or_empty() { + let bytes = minimal(); + let view = decode_footer(&bytes).unwrap(); + let json = serde_json::to_value(view).unwrap(); + assert_eq!(json["block_producer_time_nanos"], u64::MAX.to_string()); + assert_eq!(json["verification"], "captured_not_verified"); + assert!(json.get("consensus_block_id").is_none()); + assert!(json["block_final_cert"].is_null()); + assert!(decode_footer(&[]).is_err()); + let mut unknown = bytes.clone(); + unknown[0] = 2; + assert!(decode_footer(&unknown).is_err()); + let mut bad = bytes; + bad[42] = 2; + assert!(decode_footer(&bad).is_err()); +} +#[test] +fn maximum_user_agent_is_bytes_not_utf8() { + let mut bytes = vec![1]; + bytes.extend_from_slice(&[0; 32]); + bytes.extend_from_slice(&0u64.to_le_bytes()); + bytes.push(255); + bytes.extend_from_slice(&[255; 255]); + bytes.extend_from_slice(&[0, 0, 0]); + assert_eq!(decode_footer(&bytes).unwrap().block_user_agent, &[255; 255]); +} +#[test] +fn every_native_truncation_and_trailing_byte_is_rejected() { + let bytes = fixture(); + for cut in 0..bytes.len() { + assert!(decode_footer(&bytes[..cut]).is_err(), "{cut}"); + } + let mut trailing = bytes; + trailing.push(0); + assert!(decode_footer(&trailing).is_err()); + assert!(decode_footer(&vec![0; MAX_FOOTER_BYTES + 1]).is_err()); +} +#[test] +fn source_bank_parent_payload_and_captured_event_cannot_be_rebound() { + let encoded = encode(&ConsensusFact::new(binding(), fixture()).unwrap()).unwrap(); + for field in 0..9 { + let mut other = binding(); + match field { + 0 => other.source.session_id = "native-other".into(), + 1 => other.source.node_identity = "SysvarC1ock11111111111111111111111111111111".into(), + 2 => other.source.genesis_hash = "SysvarC1ock11111111111111111111111111111111".into(), + 3 => other.bank.bank_id += 1, + 4 => other.bank.blockhash[0] ^= 1, + 5 => other.bank.parent_blockhash[0] ^= 1, + 6 => other.execution_payload_sha256 = "ef".repeat(32), + 7 => other.source_event_sequence += 1, + _ => other.source_event_sha256 = "12".repeat(32), + } + assert!(decode_bound(&encoded, &other).is_err(), "{field}"); + } + let mut other = binding(); + other.source.agave_revision = "00".repeat(20); + assert!(ConsensusFact::new(other, minimal()).is_err()); + let mut other = binding(); + other.execution_payload_sha256 = "AB".repeat(32); + assert!(ConsensusFact::new(other, minimal()).is_err()); +} +#[test] +fn portable_header_lengths_versions_and_json_are_strict() { + let good = encode(&ConsensusFact::new(binding(), minimal()).unwrap()).unwrap(); + for cut in 0..good.len() { + assert!(decode(&good[..cut]).is_err(), "{cut}"); + } + for index in [0, 8, 10] { + let mut bad = good.clone(); + bad[index] ^= 2; + assert!(decode(&bad).is_err()); + } + for index in [12, 16] { + let mut bad = good.clone(); + bad[index..index + 4].copy_from_slice(&u32::MAX.to_le_bytes()); + assert!(decode(&bad).is_err()); + } + let mut bad = good.clone(); + bad.push(0); + assert!(decode(&bad).is_err()); + assert!(decode(&vec![0; MAX_FACT_BYTES + 1]).is_err()); + let n = u32::from_le_bytes(good[12..16].try_into().unwrap()) as usize; + let original = std::str::from_utf8(&good[20..20 + n]).unwrap(); + for json in [ + original.replacen('{', "{\"unknown\":1,", 1), + original.replacen('{', "{\"source_event_sequence\":123,", 1), + ] { + let mut bad = good[..20].to_vec(); + bad[12..16].copy_from_slice(&(json.len() as u32).to_le_bytes()); + bad.extend(json.as_bytes()); + bad.extend(&good[20 + n..]); + assert!(decode(&bad).is_err()); + } +} +#[test] +fn option_tags_and_fixed_vs_short_bitmap_lengths_are_not_interchangeable() { + let good = fixture(); + // Tag1, hash32, nanos8, user-agent length1+3 => final option at45. + let mut bad = good.clone(); + bad[45] = 2; + assert!(decode_footer(&bad).is_err()); + let mut bad = good; + bad[45 + 1 + 8 + 32 + 96..45 + 1 + 8 + 32 + 96 + 2].copy_from_slice(&65535u16.to_le_bytes()); + assert!(decode_footer(&bad).is_err()); + for short in [ + &[0x80, 0][..], + &[0x80, 0x80, 0][..], + &[0x80, 0x80, 4][..], + &[0xff, 0xff, 0x80][..], + ] { + let mut bytes = vec![1]; + bytes.extend([0; 32]); + bytes.extend(0u64.to_le_bytes()); + bytes.extend([0, 0, 1]); + bytes.extend(0u64.to_le_bytes()); + bytes.extend([0; 96]); + bytes.extend(short); + bytes.push(0); + assert!(decode_footer(&bytes).is_err()); + } +} +#[test] +fn fixed_schema_fixture_has_stable_digest() { + assert_eq!( + blockzilla_bank_stream_v2::digest(&fixture()), + "45ec69d756fd88adf94d4ffa72ee4657b4ab74810385f8c109590722a0d8b06d" + ); +} + +#[test] +fn all_optional_native_certificate_positions_and_fast_finalization() { + for final_mode in 0..3 { + for skip in [false, true] { + for notar in [false, true] { + let mut b = vec![1]; + b.extend([4; 32]); + b.extend(123u64.to_le_bytes()); + b.push(0); + b.push(u8::from(final_mode > 0)); + if final_mode > 0 { + b.extend(5u64.to_le_bytes()); + b.extend([6; 32]); + aggregate(&mut b, 7, &[8], false); + b.push(u8::from(final_mode == 2)); + if final_mode == 2 { + aggregate(&mut b, 9, &[], false); + } + } + b.push(u8::from(skip)); + if skip { + b.extend(10u64.to_le_bytes()); + aggregate(&mut b, 11, &[], true); + } + b.push(u8::from(notar)); + if notar { + b.extend(12u64.to_le_bytes()); + b.extend([13; 32]); + aggregate(&mut b, 14, &[15], true); + } + let f = decode_footer(&b).unwrap(); + assert_eq!(f.block_final_cert.is_some(), final_mode > 0); + assert_eq!( + f.block_final_cert + .as_ref() + .is_some_and(|c| c.notar_aggregate.is_some()), + final_mode == 2 + ); + assert_eq!(f.skip_reward_cert.is_some(), skip); + assert_eq!(f.notar_reward_cert.is_some(), notar); + let value = ConsensusFact::new(binding(), b).unwrap(); + assert_eq!(decode(&encode(&value).unwrap()).unwrap(), value); + } + } + } +} +#[test] +fn verified_official_footer_grammar_revision_is_also_explicitly_admitted() { + let mut b = binding(); + b.source.agave_revision = OFFICIAL_REVISION.into(); + let f = ConsensusFact::new(b.clone(), minimal()).unwrap(); + assert_eq!(decode_bound(&encode(&f).unwrap(), &b).unwrap(), f); +} + +#[test] +fn independently_wincode_encoded_native_schema_fixture() { + // Produced by Wincode0.6.1 from the pinned native field declarations, + // not by this codec's manual fixture builder. Hash/signature wrappers are + // transparent fixed bytes. This is a schema test, not a signed live footer. + let wire = include_bytes!("fixtures/agave-4.3.2-footer-v1.wincode"); + assert_eq!( + blockzilla_bank_stream_v2::digest(wire), + "32c22ddb2fc144203ebe60c1e87226443d019b103ea798ada38e413f79f98817" + ); + let v = decode_footer(wire).unwrap(); + assert_eq!(v.bank_hash, [3; 32]); + assert_eq!(v.block_producer_time_nanos, 1_792_737_800_123_456_789); + assert_eq!(v.block_user_agent, b"pinned-schema-fixture"); + let c = v.block_final_cert.unwrap(); + assert_eq!(c.slot, 42); + assert_eq!(c.block_id, ConsensusBlockId([4; 32])); + assert_eq!(c.final_aggregate.signature, &[0x11; 96]); + assert_eq!(c.final_aggregate.bitmap, &[0xa5, 0xff]); + assert!(c.notar_aggregate.is_none()); + assert!(v.skip_reward_cert.is_none()); + assert!(v.notar_reward_cert.is_none()); + let f = ConsensusFact::new(binding(), wire.to_vec()).unwrap(); + assert_eq!(decode(&encode(&f).unwrap()).unwrap(), f); +} + +#[test] +fn actual_captured_native_footer_matches_pinned_public_provenance() { + let wire = include_bytes!("fixtures/captured-footer-3384311167.wincode"); + let proof: serde_json::Value = + serde_json::from_str(include_str!("fixtures/captured-footer-3384311167.json")).unwrap(); + assert_eq!( + blockzilla_bank_stream_v2::digest(wire), + proof["native_footer_sha256"] + ); + assert_eq!(wire.len() as u64, proof["native_footer_bytes"]); + let v = decode_footer(wire).unwrap(); + assert_eq!(v.verification, "captured_not_verified"); + assert_eq!( + v.block_producer_time_nanos.to_string(), + proof["producer_time_nanos"] + ); + let json = serde_json::to_value(&v).unwrap(); + assert_eq!( + json["block_producer_time_nanos"], + proof["producer_time_nanos"] + ); + assert!(json.get("carrier_consensus_block_id").is_none()); + let target = v.block_final_cert.unwrap(); + assert_eq!(target.slot, proof["finalization_target_slot"]); + assert_ne!(target.slot, proof["carrier_slot"]); + let mut damaged = wire.to_vec(); + damaged.push(0); + assert!(decode_footer(&damaged).is_err()); +} diff --git a/crates/blockzilla-bank-stream-v2/tests/fixtures/agave-4.3.2-footer-v1.wincode b/crates/blockzilla-bank-stream-v2/tests/fixtures/agave-4.3.2-footer-v1.wincode new file mode 100644 index 0000000000000000000000000000000000000000..5da76f601353cd3e0f947b5cb3411a175802471e GIT binary patch literal 207 zcmZQ%CICcbk3DY}eJCMXkeQd4nxb2roRONFsGF8qQBqoz%BaNv0W1W7AdLYN!_xmi GmjD1~pcL!? literal 0 HcmV?d00001 diff --git a/crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.json b/crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.json new file mode 100644 index 0000000..a90615e --- /dev/null +++ b/crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.json @@ -0,0 +1,21 @@ +{ + "bank_hash_hex": "c512cdbd4355a9c06d96696f63057b7fde6b113dac7a7b444a52c69d507ca5da", + "carrier_bank_id": 2403404, + "carrier_slot": 460170404, + "finalization_target_slot": 460170403, + "fixture_kind": "captured_retained_native_footer", + "native_footer_bytes": 556, + "native_footer_sha256": "b06c226b404ca15bf6c6b982e88dc951a453aefe7e27358088af04b0beb267d7", + "producer_time_nanos": "1792700777706079707", + "source": { + "agave_revision": "87167f3906bdf5111e99ead64d8f4098b7874e33", + "genesis_hash": "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d", + "node_identity": "J7qpvCEWhdBgPdYRV3s3btWPrRVXa2qnAzgvxWTvtbrQ", + "session_id": "000000000000000018df884b2474cf8e-20b258" + }, + "source_coverage": "Retained event from failed source; not a complete-history or execution-payload binding proof.", + "source_event_sequence": 3384311167, + "source_event_sha256": "82c851a4521b9cb334bf86573cfa2b7a124bc9445db3ec66e483ed52e0ab8f7c", + "user_agent_hex": "61676176652f342e332e3220287372633a36616131393564613b20666561743a63396164333464322c20636c69656e743a4861726d6f6e6963416761766529", + "verification": "captured_not_verified" +} diff --git a/crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.wincode b/crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.wincode new file mode 100644 index 0000000000000000000000000000000000000000..c329653a2eada476be57f26b63abcefd90f05ae2 GIT binary patch literal 556 zcmZQPDs*$zM`BTKeqLs> zBS@nrG8kPA+J|Hn)Kn|iKf1XpM5v99bRy0`uf>6jYZGzq_B7#TotqP z&9wSMZ>qGamn=LXmCk3H|dulnbI`+u_a-~X7n@85gw{ny;p&sXj_ z^dslks#%*I-j@Ac@n(C1`!p5p-ddTz2LqNc?qL3RzbcuLfq`)j)Qi2pt~S-L58k&{ zUc`F4@#k&q;z7$V96LCt{c`c0H+DvLlPqd48FW2x57)i@ahv}FMXjuZa?8D+nYq=7 zH^lrryC(4AuNk~gPGxMow|Q@BXB`*6g4w?1PhTAVm^MxCUZyoyX3K>12$}x=B5C4+_eiNbiJ0k$`9!FaM literal 0 HcmV?d00001 diff --git a/docs/architecture/alpenglow-consensus-facts.md b/docs/architecture/alpenglow-consensus-facts.md new file mode 100644 index 0000000..ca79f98 --- /dev/null +++ b/docs/architecture/alpenglow-consensus-facts.md @@ -0,0 +1,195 @@ +# Alpenglow consensus facts + +Date: 23 October 2026. Profile: `native-consensus-fact-v1`. + +The first release adds an offline writer, a strict Rust reader, and a shared +Rust/Wasm reader for JavaScript. It stores retained native footer evidence in +separate immutable files. It does not change a published execution payload or +any existing archive. It is not a production deployment or capture recovery. + +## Protocol basis + +Votor is active on mainnet. The migration genesis block is slot 459652999; +Alpenglow blocks start at 459653000. Rotor has a separate later rollout. Use +`getAgGenesisCert` and source evidence to identify the migration. A date or an +Agave version alone does not prove that a captured block used Alpenglow. See +the [official migration guide](https://solana.com/upgrades/alpenglow). + +The installed plugin already records exact native `VersionedBlockFooter` +Wincode bytes. The schema in this release admits the deployed Agave source +`87167f3906bdf5111e99ead64d8f4098b7874e33` and upstream Agave 4.3.2 commit +`a203300045b405f86c9c84308b2eae76af69ac3b`. Their footer types match. +See the pinned [footer types](https://github.com/anza-xyz/agave/blob/a203300045b405f86c9c84308b2eae76af69ac3b/entry/src/block_component.rs#L238-L361) +and [reward certificate types](https://github.com/anza-xyz/agave/blob/a203300045b405f86c9c84308b2eae76af69ac3b/votor-messages/src/reward_certificate.rs#L23-L88). + +## Separate identities and evidence + +| Value | Meaning | +| --- | --- | +| Source four-tuple and `(slot, bank_id)` | One node-local bank in one capture session | +| Execution blockhash and parent blockhash | Last-entry hashes used by the existing execution payload and expiry logic | +| Footer bank hash | Producer's expected execution state hash | +| Consensus `BlockId` | A distinct consensus identity; a certificate carries the identity of its own target | +| Execution payload SHA256 | Digest of the exact execution frame bytes that this fact supplements | +| Source event sequence and SHA256 | Position and digest of the exact captured JSON event, including its callback envelope | + +A footer does not contain its carrier's consensus `BlockId` or parent +`BlockId`. Readers report `carrier_consensus_block_id: null`. They must not +substitute the execution blockhash, bank hash, or a certificate target. +The certificate target can be older than its carrying bank. The native +[block ID rule](https://github.com/anza-xyz/agave/blob/a203300045b405f86c9c84308b2eae76af69ac3b/ledger/src/blockstore.rs#L3653-L3689) +also differs between Tower and Alpenglow. + +The old captured `ClearBank.parent_blockhash` field contains the consensus +parent `BlockId` from `UpdateParent`. A later event version must give it an +accurate type and name. Do not reinterpret or rewrite historical event bytes. + +Each fact retains the raw native footer once. Readers derive these fields: + +- Bank hash, exact producer Unix nanoseconds, and raw user-agent bytes. +- Optional block finalization certificate with its own slot and consensus + `BlockId`, final aggregate, and optional notarization aggregate. +- Optional skip reward and notarization reward aggregates as separate types. + +All signatures and bitmaps remain exact captured bytes. The verification +state is always `captured_not_verified`. A reward aggregate does not establish +finality or a skipped slot. This release does not verify BLS signatures, stake +thresholds, epoch ranks, bitmap meaning, or producer time bounds. JavaScript +receives nanoseconds and certificate target slots as decimal strings. It can +use `BigInt` for exact arithmetic. + +## Wire contract + +The portable header is 20 bytes, in this order: + +| Field | Encoding | +| --- | --- | +| Magic | Eight bytes: `BZCNF001` | +| Portable version | Little-endian u16, value 1 | +| Native grammar code | Little-endian u16, value 1 | +| Binding JSON byte length | Little-endian u32, 1 to 4096 | +| Native footer byte length | Little-endian u32, 1 to 65535 | + +The binding JSON and exact native footer follow the header. The binding has +`source`, `bank`, `execution_payload_sha256`, `source_event_sequence`, and +`source_event_sha256`. Source and bank use the existing strict native bank v2 +identities. The JSON accepts no unknown fields. The footer contains only native +`VersionedBlockFooter::V1`, without the outer block marker or length prefix. + +The reader rejects an unsupported profile version, schema, source revision, +invalid option tag, truncated value, noncanonical reward bitmap length, +oversized field, or trailing bytes. Finality bitmaps have a fixed u16 length; +reward bitmaps use ShortU16. These encodings are not interchangeable. +The footer limit follows the native marker's enclosing u16 byte length. + +`decode_bound` checks the full binding supplied by the caller. A consumer must +also check the complete fact digest from a trusted export receipt. A digest +proves byte identity; it does not independently prove the source's claims. + +## Writer and reader + +The direct Agave CLI provides four commands: + +```sh +hivezilla-direct-agave export-consensus binding.json footer-event.json execution-frame.bin export-dir +hivezilla-direct-agave export-consensus-source-events execution-binding.json source-events.json.zst execution-frame.bin export-dir +hivezilla-direct-agave inspect-consensus-export export-dir +hivezilla-direct-agave inspect-consensus-fact fact.bin binding.json +``` + +The single-event command accepts an exact `Event::Footer` JSON value or one +`RawEvidence` record. Its binding includes the exact event sequence and hash. +The source-events command accepts the retained per-bank JSON array or its +Zstandard form. Its execution binding contains only `source`, `bank`, and +`execution_payload_sha256`; each footer record supplies its own event binding. +Export accepts native bank v2 block frames. Other execution profiles fail +admission. Source-events input is bounded to 256 MiB, both stored and decoded. +Each export has at most 1024 facts and 1 MiB of raw footer bytes in total. +The writer checks input bounds and exact hashes before it writes a fact. +It rejects a source, bank, payload, or event mismatch. It creates immutable +fact files and an export receipt. An equal retry can reuse equal bytes; it +cannot replace conflicting output. + +The JavaScript entry point is `@blockzilla/stream-transport/consensus`: + +```js +import { loadConsensusDecoder, decodeConsensusFact } from './consensus.mjs'; +const decoder = await loadConsensusDecoder(); +const result = await decodeConsensusFact(factBytes, receiptDigest, expectedBinding, decoder); +const timeNanos = BigInt(result.decoded.footer.block_producer_time_nanos); +``` + +The SDK uses the same Rust parser as the native tools. It does not implement a +second native schema in JavaScript or change the bank client's root state. + +An export receipt grants **no source retirement authority**. Existing compact +markers, custody records, storage ledgers, caps, and archives remain separate. +The exporter can read retained evidence; it cannot claim that previously +retired events are available or that an entire epoch has footer coverage. + +## Legacy field policy + +For new Alpenglow consensus records, omit Tower lockout depths, the old +64-tick timing model, and a separate confirmed-to-finalized delay. Do not copy +execution transactions or old PoH timing fields into each consensus fact. +The new profile contains only the source binding and exact footer evidence. + +Keep transaction entries, counts, hashes, source gaps, execution parent links, +block height, expiry, rewards, and fork invalidation. Agave 4.3.2 still requires +a terminal empty Alpentick with `num_hashes == 1`. Footer arrival precedes that +entry callback. It does not prove block completeness. The current execution +format's `available-poh.wincode` name stays unchanged to preserve its published +contract; its retained entry records are not an independent PoH timing proof. +See the [terminal entry rule](https://github.com/anza-xyz/agave/blob/a203300045b405f86c9c84308b2eae76af69ac3b/runtime/src/block_component_processor.rs#L364-L390) +and [callback ordering regression](https://github.com/anza-xyz/agave/blob/a203300045b405f86c9c84308b2eae76af69ac3b/ledger/src/blockstore_processor.rs#L5814-L5893). + +Historical Tower readers and existing immutable archives remain supported. +Do not discard a real transaction because its program or `is_vote` flag looks +legacy. Do not infer Alpenglow from a missing footer. + +## Delivery and production plan + +1. **This release:** strict footer fact codec, offline immutable export and + inspection, shared Rust/Wasm JavaScript reader, tests and retained native + fixture checks. Existing execution v1/v2 byte contracts stay separate. +2. **Continuous evidence release:** give footer export its own durable source + cursor, conflict detection, inventory, cloud upload/readback proof, and + retention acknowledgement. Test a footer that arrives after the first rooted + custody receipt and a crash at each commit boundary. The current first + `CUSTODY.json` is immutable and does not cover later callbacks. A journal-only + cursor must not skip retired prefixes or claim full historical coverage. +3. **Live format release:** negotiate a new profile with the Rust relay, Wasm + reader, JavaScript SDK, publisher, and archive catalog. Reuse execution + payloads and send small fact references. Give entry evidence an accurate + name in that new contract. Keep explicit unknown/unsupported states. Add + consensus parent/header and carrier `BlockId` only from a proven native + source; the current footer callback cannot supply them. + Full Votor vote/skip-certificate capture needs another native source. + Independent certificate verification also needs exact epoch ranks, stakes, + registered BLS keys and proof-of-possession provenance, bitmap rules and + signature domains. Keep it distinct from a node's confirmation callback. +4. **Controlled deployment:** repair the source/registry/writable-path handoff, + validate free capacity over time, preserve the failed source and its gap, + and start a new capture session. Then prove actual capture, compaction, + publication, client decode, cloud readback, restart, and retirement progress. + Only enable new source retirement after all required fact custody is proved. + +The failed 22 October capture cannot be made complete by a worker restart. +Format tests do not recover that capture or establish current live block flow. +Production cutover needs the coordinated storage handoff described in the +[deployment record](../../hivezilla/deploy/direct-agave/README.md). + +## Acceptance + +The local targeted suites passed 104 tests: 21 portable codec tests, 41 native +library tests, 13 execution decoder tests and 29 JavaScript tests. Four explicit +helpers remain ignored in the normal runs: two require the real compact writer, +one exports decoder fixtures, and one is invoked by the relative-path test in +a subprocess. The WebAssembly release build passed. A real retained 556-byte +footer and an independent Wincode fixture test the native grammar. These tests +do not establish full historical coverage or production progress. + +CI now builds the consensus WebAssembly reader from source and tests it with +the v1/v2/consensus JavaScript suites. Read the +[acceptance receipt](../operations/evidence/alpenglow-format-20261023.json) +for artifact hashes, commands and limits. diff --git a/docs/operations/evidence/alpenglow-format-20261023.json b/docs/operations/evidence/alpenglow-format-20261023.json new file mode 100644 index 0000000..97aa8cd --- /dev/null +++ b/docs/operations/evidence/alpenglow-format-20261023.json @@ -0,0 +1,249 @@ +{ + "schema": "blockzilla-alpenglow-format-acceptance-v1", + "saved_utc": "2026-10-23T08:43:53.353584+00:00", + "state": "IMPLEMENTED_TESTED_NOT_DEPLOYED", + "base_commit": "b01231ce80c740730478198e521eac9367a11495", + "branch": "codex/alpenglow-footer-facts", + "profile": "native-consensus-fact-v1", + "owner_legacy_policy": "Remove obsolete fields from the new format; keep existing archives", + "implemented": [ + "Bounded portable source/bank/execution/event-bound native footer codec", + "Immutable offline native bank-v2 footer exporter and receipt inspection", + "Strict shared Rust/Wasm and JavaScript reader with exact decimal nanoseconds", + "CI source rebuild and SDK tests configured", + "Versioned wire contract and controlled live migration plan" + ], + "validation": { + "rustc": "1.99.0 (b940084d7 2026-09-28)", + "node": "26.12.0", + "build_jobs": 2, + "codec": { + "command": "cargo test --manifest-path crates/blockzilla-bank-stream-v2/Cargo.toml --locked --offline", + "passed": 21, + "failed": 0 + }, + "native": { + "command": "cargo test --manifest-path hivezilla/direct-agave/Cargo.toml --locked --offline --lib --bins", + "passed": 41, + "failed": 0, + "ignored": 3 + }, + "execution_decoder": { + "command": "cargo test --manifest-path hivezilla/stream-relay/decoder/Cargo.toml --locked --lib", + "passed": 13, + "failed": 0, + "ignored": 1 + }, + "wasm": { + "command": "cargo build --manifest-path hivezilla/stream-relay/decoder/Cargo.toml --locked --offline --release --target wasm32-unknown-unknown", + "result": "PASS", + "artifact": "hivezilla/stream-relay/client/decoder-consensus-v1.wasm" + }, + "javascript": { + "command": "node --test test.mjs sdk-test.mjs banks-test.mjs consensus-test.mjs", + "working_directory": "hivezilla/stream-relay/client", + "passed": 29, + "failed": 0 + }, + "total_passed": 104, + "ignored_reasons": [ + "Two existing native tests require the real compact writer", + "One native helper is invoked by the relative-output test in a subprocess", + "One decoder helper exports fixtures on explicit request" + ], + "cli_smoke": { + "commands": [ + "--help", + "inspect-consensus-fact" + ], + "result": "PASS", + "historical_execution_payload_binding_proven": false + }, + "formatting": "PASS", + "staged_diff_check": "PASS", + "ci_yaml_parse": "PASS", + "independent_protocol_and_code_review": "PASS", + "ci_when_saved": "CONFIGURED_NOT_RUN_YET" + }, + "native_fixture": { + "bank_hash_hex": "c512cdbd4355a9c06d96696f63057b7fde6b113dac7a7b444a52c69d507ca5da", + "carrier_bank_id": 2403404, + "carrier_slot": 460170404, + "finalization_target_slot": 460170403, + "fixture_kind": "captured_retained_native_footer", + "native_footer_bytes": 556, + "native_footer_sha256": "b06c226b404ca15bf6c6b982e88dc951a453aefe7e27358088af04b0beb267d7", + "producer_time_nanos": "1792700777706079707", + "source": { + "agave_revision": "87167f3906bdf5111e99ead64d8f4098b7874e33", + "genesis_hash": "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d", + "node_identity": "J7qpvCEWhdBgPdYRV3s3btWPrRVXa2qnAzgvxWTvtbrQ", + "session_id": "000000000000000018df884b2474cf8e-20b258" + }, + "source_coverage": "Retained event from failed source; not a complete-history or execution-payload binding proof.", + "source_event_sequence": 3384311167, + "source_event_sha256": "82c851a4521b9cb334bf86573cfa2b7a124bc9445db3ec66e483ed52e0ab8f7c", + "user_agent_hex": "61676176652f342e332e3220287372633a36616131393564613b20666561743a63396164333464322c20636c69656e743a4861726d6f6e6963416761766529", + "verification": "captured_not_verified" + }, + "limits": [ + "Offline per-bank export; no continuous late-evidence cursor or cloud custody", + "No source-retirement authority", + "No BLS, stake/quorum, producer clock or independent finality verification", + "Footer has no carrier consensus BlockId or parent BlockId", + "Retained failed-source evidence does not prove complete historical coverage", + "Existing v1/v2 execution contracts and archives stay separate", + "Local tests do not prove the validator plugin ABI or production recovery" + ], + "production_mutations_by_this_change": false, + "archives_deleted_by_this_change": false, + "files": [ + { + "path": ".github/workflows/ci.yml", + "bytes": 8663, + "sha256": "afdac19eeb620475d6dbec22e6f16f0b9d450d6a56f46f75e958529f91ededec" + }, + { + "path": "crates/blockzilla-bank-stream-v2/src/consensus.rs", + "bytes": 11607, + "sha256": "616dec11ce823a5c3a62b9e4403007d0fdb2b90ee11d0b6df6563ba9278b72dd" + }, + { + "path": "crates/blockzilla-bank-stream-v2/src/lib.rs", + "bytes": 23611, + "sha256": "2445e6f829ffb2e6b4091b75205b886f2a8a342fe7407e4eb0c96212609bce18" + }, + { + "path": "crates/blockzilla-bank-stream-v2/tests/consensus.rs", + "bytes": 13550, + "sha256": "ebda662e6f40ae49cc562287ff60266f5e53bbcde78b698e6e311f82147eeba1" + }, + { + "path": "crates/blockzilla-bank-stream-v2/tests/fixtures/agave-4.3.2-footer-v1.wincode", + "bytes": 207, + "sha256": "32c22ddb2fc144203ebe60c1e87226443d019b103ea798ada38e413f79f98817" + }, + { + "path": "crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.json", + "bytes": 1140, + "sha256": "a8390deab450d66055f048257829f1040c3319453c1566093e600abb42b8cf9a" + }, + { + "path": "crates/blockzilla-bank-stream-v2/tests/fixtures/captured-footer-3384311167.wincode", + "bytes": 556, + "sha256": "b06c226b404ca15bf6c6b982e88dc951a453aefe7e27358088af04b0beb267d7" + }, + { + "path": "docs/architecture/alpenglow-consensus-facts.md", + "bytes": 11358, + "sha256": "48bb0e30bcf588edb4cd56f9d3da507357c20d83edb4f48a25ef87a073c1e723" + }, + { + "path": "hivezilla/direct-agave/README.md", + "bytes": 10571, + "sha256": "25ff1cad5c920bb3e0f1f7d44e2c891f139f2eb6f915304b169f6de847b5a689" + }, + { + "path": "hivezilla/direct-agave/src/consensus.rs", + "bytes": 22061, + "sha256": "91a78b8c1cd27451226aff44313c8eee69ed72ebfd2ffa7bee0afcb5f8bc11cb" + }, + { + "path": "hivezilla/direct-agave/src/consensus_tests.rs", + "bytes": 23982, + "sha256": "c1a554b7fd58726da8f0f4f592bcc310ed690c8bfb347ffbd811fa0a882e90ff" + }, + { + "path": "hivezilla/direct-agave/src/lib.rs", + "bytes": 259, + "sha256": "4a055aac1e22aa051359e59cf8d47528eb697de01691fc2844784cf4d740252b" + }, + { + "path": "hivezilla/direct-agave/src/main.rs", + "bytes": 6399, + "sha256": "a037d59b20ddb5d93303f815b70574e76e2ea4a5704edb6ccbb6b149511820fd" + }, + { + "path": "hivezilla/stream-relay/client/README.md", + "bytes": 6298, + "sha256": "28cfde1cbf4b2d0b671fde37f11b3ed1f9af8979a109f41b4a5da470fc7520bc" + }, + { + "path": "hivezilla/stream-relay/client/consensus-test.mjs", + "bytes": 5236, + "sha256": "95c01a09b8048f26fd683ea931cdeaed31d3b7fe141df5350ddc41a85f3e7ed8" + }, + { + "path": "hivezilla/stream-relay/client/consensus.d.mts", + "bytes": 1876, + "sha256": "cb64926e7e1b04473cc18743d383b855d7f3ff9acd0215b421b2f3957885ae2f" + }, + { + "path": "hivezilla/stream-relay/client/consensus.mjs", + "bytes": 3940, + "sha256": "feb41a0b5e7ae6d948ca1c99e728eb1377bf364547ced3f6b1035f93020b1e14" + }, + { + "path": "hivezilla/stream-relay/client/decoder-consensus-v1.wasm", + "bytes": 821314, + "sha256": "4d8e99c58c7d2eb9ff1c4f977e6cdc0deab8180c9c4d41d00ee36ad9f3865451" + }, + { + "path": "hivezilla/stream-relay/client/package.json", + "bytes": 557, + "sha256": "03b44a952ae8b5976cb31e046053a2032f735ded18d968ef9b446355b1f3ebee" + }, + { + "path": "hivezilla/stream-relay/decoder/README.md", + "bytes": 2449, + "sha256": "aba1b97c1bebb168e2b15b8bc7b82bd3f49df13eed9964b6b40c1569cd91878d" + }, + { + "path": "hivezilla/stream-relay/decoder/src/consensus.rs", + "bytes": 1692, + "sha256": "022308d747998929326f4970109f7845be52138999748f920830fe721d7b6808" + }, + { + "path": "hivezilla/stream-relay/decoder/src/lib.rs", + "bytes": 29739, + "sha256": "0f222c908ae694bfbb508b7516748bb1ce697cc5f72ae7d8bedd6ed961125d5a" + } + ], + "local_evidence_logs": [ + { + "local_evidence": "format-review-agent/TEST-FINAL.log", + "bytes": 2435, + "sha256": "fa2f49bcae9a01e8ea74928ea4548ee45a27b52fdbe2e3f23c30086d0671305d" + }, + { + "local_evidence": "native-tests.log", + "bytes": 11588, + "sha256": "c2261dfb45f0a05e919153a697705532039c92acb466e36b6ef4718bb9947841" + }, + { + "local_evidence": "native-tests-final.log", + "bytes": 5873, + "sha256": "5596f17d628e9898900ee8a48fbb3d845285c0341927e45465567f10ef432162" + }, + { + "local_evidence": "wasm-build-final.log", + "bytes": 1720, + "sha256": "e9feb245df588e592b745bb64896e0e9425e38ec89f0e765830994c7136f83d0" + }, + { + "local_evidence": "client-tests-final.log", + "bytes": 2505, + "sha256": "c3b7ad4ab89c4180f71565fb69304277fdcb30f267b65e9db8d24536d27eff61" + }, + { + "local_evidence": "native-cli-build.log", + "bytes": 1559, + "sha256": "d045eebf557ba38175eda1d36ab4bba31a0e92f31e143dbd8d591d719e2d2e49" + }, + { + "local_evidence": "cli-smoke/inspection.json", + "bytes": 3290, + "sha256": "7f65e3b7dde56b5fc1baddeec869b3b96f36cc62ddcd44c625e3e926d2c2bfc4" + } + ] +} diff --git a/hivezilla/direct-agave/README.md b/hivezilla/direct-agave/README.md index 2fc60f3..90faee5 100644 --- a/hivezilla/direct-agave/README.md +++ b/hivezilla/direct-agave/README.md @@ -28,6 +28,25 @@ A plugin must use the same Rust compiler and dependency types as its validator. A successful build alone does not establish dynamic ABI compatibility. Test a bounded load beside Yellowstone before continuous use. +## Offline Alpenglow footer export + +The separate `native-consensus-fact-v1` profile stores exact retained Agave 4.3.2 +footer bytes with a source, bank, execution frame digest, and source event +binding. It derives leader nanoseconds, user-agent bytes, and optional finality +and reward aggregates. Their state is `captured_not_verified`. It does not +rewrite execution blocks or grant source retirement authority. + +Use `export-consensus`, `export-consensus-source-events`, +`inspect-consensus-export`, and `inspect-consensus-fact` for offline export and +inspection. Export requires a matching complete native bank v2 execution frame. +The source-events input can be uncompressed JSON or Zstandard JSON. Existing +archives stay unchanged. Read the [wire contract, commands, field policy and +production plan](../../docs/architecture/alpenglow-consensus-facts.md). + +Continuous late-footer export, cloud custody and a new live profile are later +steps. The current first rooted custody receipt does not cover callbacks that +arrive after it. Offline export does not restore a failed capture session. + ## Durability and failure contract Callbacks copy the transaction wire bytes, all native status metadata fields, diff --git a/hivezilla/direct-agave/src/consensus.rs b/hivezilla/direct-agave/src/consensus.rs new file mode 100644 index 0000000..50b12b8 --- /dev/null +++ b/hivezilla/direct-agave/src/consensus.rs @@ -0,0 +1,638 @@ +//! Offline export of already captured native footers. Export receipts do not +//! authorize source retirement, cloud custody, or a finality transition. +use anyhow::{Context, Result, ensure}; +use blockzilla_bank_stream_v2::{self as v2, BankIdentity, SourceIdentity}; +use serde::{Deserialize, Serialize}; +use std::{ + collections::BTreeSet, + fs::{self, File, OpenOptions}, + io::{Read, Write}, + path::{Path, PathBuf}, + time::{SystemTime, UNIX_EPOCH}, +}; +use v2::consensus::{self as codec, ConsensusFact, FactBinding}; + +pub const RECEIPT: &str = "CONSENSUS-EXPORT.v1.json"; +pub const MAX_EVENT_BYTES: usize = 16 * 1024 * 1024; +pub const MAX_SOURCE_BYTES: usize = 256 * 1024 * 1024; +pub const MAX_FACTS: usize = 1024; +pub const MAX_TOTAL_FOOTER_BYTES: usize = 1024 * 1024; +const MAX_RECORDS: usize = 1_000_000; +const MAX_RECEIPT_BYTES: usize = 4 * 1024 * 1024; +const SCHEMA: &str = "hivezilla-native-consensus-export-v1"; +const DOMAIN: &str = "exact execution frame bytes"; +const LOCK: &str = "EXPORT.lock"; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ExecutionBinding { + pub source: SourceIdentity, + pub bank: BankIdentity, + pub execution_payload_sha256: String, +} +impl ExecutionBinding { + fn validate(&self) -> Result<()> { + self.source.validate()?; + self.bank.validate()?; + ensure!( + v2::is_digest(&self.execution_payload_sha256), + "invalid_execution_digest" + ); + Ok(()) + } + fn matches(&self, fact: &FactBinding) -> bool { + self.source == fact.source + && self.bank == fact.bank + && self.execution_payload_sha256 == fact.execution_payload_sha256 + } +} +impl From<&FactBinding> for ExecutionBinding { + fn from(binding: &FactBinding) -> Self { + Self { + source: binding.source.clone(), + bank: binding.bank.clone(), + execution_payload_sha256: binding.execution_payload_sha256.clone(), + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct InputIdentity { + pub kind: String, + /// Digest and size of the supplied file, including compression if present. + pub bytes: usize, + pub sha256: String, + pub decoded_bytes: usize, + pub decoded_sha256: String, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct FactFile { + pub path: String, + pub bytes: usize, + pub sha256: String, + pub binding: FactBinding, + pub footer_bytes: usize, + pub footer_sha256: String, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ExportReceipt { + pub schema: String, + pub state: String, + pub profile: String, + pub execution: ExecutionBinding, + pub execution_digest_domain: String, + pub execution_frame_bytes: usize, + pub input: InputIdentity, + pub facts: Vec, + pub verification: String, + pub no_source_retirement_authority: bool, + pub continuous_late_evidence_coverage: bool, +} +#[derive(Debug, Serialize)] +pub struct ExportInspection { + pub receipt: ExportReceipt, + /// The receipt and its files agree. An external expected binding is still + /// needed to establish provenance; inspection does not authenticate input. + pub local_hashes_consistent: bool, + pub provenance_authenticated: bool, + pub footers: Vec, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Record { + sequence: u64, + sha256: String, + event: Box, +} +#[derive(Deserialize)] +struct EventKey { + kind: String, + slot: u64, + bank_id: Option, +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct FooterEvent { + kind: String, + slot: u64, + bank_id: u64, + wire_footer: Vec, +} + +fn open_regular(path: &Path) -> Result { + ensure!( + fs::symlink_metadata(path)?.file_type().is_file(), + "input_not_regular_file" + ); + let mut options = OpenOptions::new(); + options.read(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt; + options.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC); + } + let file = options.open(path)?; + ensure!(file.metadata()?.is_file(), "input_not_regular_file"); + Ok(file) +} +fn bounded_file(path: &Path, limit: usize) -> Result> { + let file = open_regular(path)?; + ensure!( + file.metadata()?.len() <= limit as u64, + "input_file_too_large" + ); + let mut bytes = Vec::new(); + file.take(limit as u64 + 1).read_to_end(&mut bytes)?; + ensure!(bytes.len() <= limit, "input_file_too_large"); + Ok(bytes) +} +fn verify_execution(binding: &ExecutionBinding, payload_path: &Path) -> Result { + binding.validate()?; + let bytes = bounded_file(payload_path, v2::MAX_FRAME)?; + ensure!( + v2::digest(&bytes) == binding.execution_payload_sha256, + "execution_frame_digest_mismatch" + ); + let frame = v2::decode(bytes.into())?; + ensure!( + frame.envelope.event.kind == "block" + && frame.source == binding.source + && frame.envelope.event.bank == binding.bank, + "execution_frame_binding_mismatch" + ); + Ok(frame.wire.len()) +} +fn footer(binding: &FactBinding, raw: &[u8]) -> Result { + binding.validate()?; + ensure!( + raw.len() <= MAX_EVENT_BYTES && v2::digest(raw) == binding.source_event_sha256, + "source_event_digest_mismatch" + ); + let event: FooterEvent = serde_json::from_slice(raw)?; + ensure!( + event.kind == "Footer" + && event.slot == binding.bank.slot + && event.bank_id == binding.bank.bank_id, + "footer_event_binding_mismatch" + ); + ConsensusFact::new(binding.clone(), event.wire_footer) +} +fn add_footer_bytes(total: &mut usize, bytes: usize) -> Result<()> { + *total = total.checked_add(bytes).context("footer_total_overflow")?; + ensure!(*total <= MAX_TOTAL_FOOTER_BYTES, "footer_total_too_large"); + Ok(()) +} + +fn input_identity(kind: &str, stored: &[u8], decoded: &[u8]) -> InputIdentity { + InputIdentity { + kind: kind.into(), + bytes: stored.len(), + sha256: v2::digest(stored), + decoded_bytes: decoded.len(), + decoded_sha256: v2::digest(decoded), + } +} + +/// Export exactly one Footer from an exact raw Event file or one RawEvidence +/// record. A supplied marker digest cannot substitute for the actual v2 frame. +pub fn export_event( + binding: &FactBinding, + event_path: &Path, + payload_path: &Path, + output: &Path, +) -> Result { + binding.validate()?; + let execution = ExecutionBinding::from(binding); + let frame_bytes = verify_execution(&execution, payload_path)?; + let input = bounded_file(event_path, MAX_EVENT_BYTES)?; + let shape: serde_json::Value = serde_json::from_slice(&input)?; + let (kind, fact) = if shape.get("kind").is_some() { + ("raw-footer-event", footer(binding, &input)?) + } else { + let record: Record = serde_json::from_slice(&input)?; + ensure!( + record.sequence == binding.source_event_sequence + && record.sha256 == binding.source_event_sha256, + "source_record_binding_mismatch" + ); + ( + "raw-evidence-record", + footer(binding, record.event.get().as_bytes())?, + ) + }; + publish( + output, + execution, + frame_bytes, + input_identity(kind, &input, &input), + vec![fact], + ) +} + +/// Export each captured Footer from one bank's retained source-events array. +/// Source identity comes from the caller and must also match the actual frame. +/// All records must have the same slot and exact bank (or a slot-only status). +pub fn export_source_events( + binding: &ExecutionBinding, + source_events_path: &Path, + payload_path: &Path, + output: &Path, +) -> Result { + let frame_bytes = verify_execution(binding, payload_path)?; + let stored = bounded_file(source_events_path, MAX_SOURCE_BYTES)?; + let compressed = stored.starts_with(&[0x28, 0xb5, 0x2f, 0xfd]); + let decoded = if compressed { + let mut bytes = Vec::new(); + zstd::stream::read::Decoder::new(stored.as_slice())? + .take(MAX_SOURCE_BYTES as u64 + 1) + .read_to_end(&mut bytes)?; + ensure!( + bytes.len() <= MAX_SOURCE_BYTES, + "source_events_decoded_too_large" + ); + bytes + } else { + stored.clone() + }; + let records: Vec = serde_json::from_slice(&decoded)?; + ensure!( + !records.is_empty() && records.len() <= MAX_RECORDS, + "source_record_count_invalid" + ); + let mut after = 0; + let mut facts = Vec::new(); + let mut total_footer_bytes = 0; + for record in records { + ensure!( + record.sequence > after && record.sequence <= v2::SAFE && v2::is_digest(&record.sha256), + "source_record_order_invalid" + ); + after = record.sequence; + let raw = record.event.get().as_bytes(); + ensure!( + raw.len() <= MAX_EVENT_BYTES && v2::digest(raw) == record.sha256, + "source_event_digest_mismatch" + ); + let key: EventKey = serde_json::from_slice(raw)?; + ensure!( + key.slot == binding.bank.slot + && (key.bank_id == Some(binding.bank.bank_id) + || (key.bank_id.is_none() + && matches!(key.kind.as_str(), "Status" | "BankStatusV2"))), + "source_events_mixed_bank" + ); + ensure!( + matches!( + key.kind.as_str(), + "BankStateV2" + | "BankStatusV2" + | "Transaction" + | "Entry" + | "Block" + | "Status" + | "ClearBank" + | "Footer" + ), + "unknown_source_event" + ); + if key.kind == "Footer" { + ensure!(facts.len() < MAX_FACTS, "too_many_footer_facts"); + let fact_binding = FactBinding { + source: binding.source.clone(), + bank: binding.bank.clone(), + execution_payload_sha256: binding.execution_payload_sha256.clone(), + source_event_sequence: record.sequence, + source_event_sha256: record.sha256, + }; + let fact = footer(&fact_binding, raw)?; + add_footer_bytes(&mut total_footer_bytes, fact.footer_wire().len())?; + facts.push(fact); + } + } + ensure!(!facts.is_empty(), "source_events_have_no_footer"); + let kind = if compressed { + "source-events-json-zstd" + } else { + "source-events-json" + }; + publish( + output, + binding.clone(), + frame_bytes, + input_identity(kind, &stored, &decoded), + facts, + ) +} + +fn fact_name(binding: &FactBinding) -> String { + format!( + "{:020}-{}.bzcnf", + binding.source_event_sequence, binding.source_event_sha256 + ) +} +fn directory_files(output: &Path, expected: &BTreeSet) -> Result<()> { + ensure!( + fs::symlink_metadata(output)?.file_type().is_dir(), + "output_not_directory" + ); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + ensure!( + fs::metadata(output)?.permissions().mode() & 0o022 == 0, + "output_directory_writable_by_others" + ); + } + let mut count = 0; + for row in fs::read_dir(output)? { + count += 1; + ensure!(count <= MAX_FACTS + 1024, "output_directory_too_large"); + let row = row?; + let name = row + .file_name() + .into_string() + .map_err(|_| anyhow::anyhow!("invalid_output_name"))?; + ensure!( + name == LOCK + || name == RECEIPT + || expected.contains(&name) + || name.starts_with(".consensus-tmp-"), + "output_contains_unrelated_files" + ); + ensure!( + row.file_type()?.is_file(), + "output_contains_nonregular_file" + ); + } + Ok(()) +} +fn output_lock(output: &Path) -> Result { + let mut options = OpenOptions::new(); + options.read(true).write(true).create(true).truncate(false); + #[cfg(unix)] + { + use std::os::unix::{fs::OpenOptionsExt, io::AsRawFd}; + options + .mode(0o600) + .custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC); + let file = options.open(output.join(LOCK))?; + ensure!(file.metadata()?.is_file(), "export_lock_not_regular"); + ensure!( + unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0, + "consensus_export_already_active" + ); + Ok(file) + } + #[cfg(not(unix))] + { + anyhow::bail!("consensus_export_requires_file_lock") + } +} +struct Scratch(PathBuf); +impl Drop for Scratch { + fn drop(&mut self) { + let _ = fs::remove_file(&self.0); + } +} +fn create_immutable(output: &Path, name: &str, bytes: &[u8]) -> Result<()> { + let destination = output.join(name); + if fs::symlink_metadata(&destination).is_ok() { + ensure!( + bounded_file(&destination, bytes.len())? == bytes, + "existing_export_file_conflict" + ); + return Ok(()); + } + let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos(); + let scratch = Scratch(output.join(format!(".consensus-tmp-{}-{nonce}", std::process::id()))); + let mut file = OpenOptions::new() + .create_new(true) + .write(true) + .open(&scratch.0)?; + file.write_all(bytes)?; + file.sync_all()?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + file.set_permissions(fs::Permissions::from_mode(0o444))?; + file.sync_all()?; + } + // link creates the destination atomically and never replaces it. A crash + // can leave only an uncommitted scratch name, not a partial fact/receipt. + match fs::hard_link(&scratch.0, &destination) { + Ok(()) => (), + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => { + ensure!( + bounded_file(&destination, bytes.len())? == bytes, + "existing_export_file_conflict" + ); + } + Err(error) => return Err(error.into()), + } + fs::remove_file(&scratch.0)?; + File::open(output)?.sync_all()?; + Ok(()) +} +fn publish( + output: &Path, + execution: ExecutionBinding, + frame_bytes: usize, + input: InputIdentity, + facts: Vec, +) -> Result { + ensure!( + !facts.is_empty() && facts.len() <= MAX_FACTS, + "invalid_footer_fact_count" + ); + let mut encoded = Vec::new(); + let mut files = Vec::new(); + let mut previous = 0; + let mut bank_footer_sha: Option = None; + let mut total_footer_bytes = 0; + for fact in facts { + ensure!( + execution.matches(&fact.binding) && fact.binding.source_event_sequence > previous, + "export_fact_binding_mismatch" + ); + previous = fact.binding.source_event_sequence; + add_footer_bytes(&mut total_footer_bytes, fact.footer_wire().len())?; + let footer_sha = v2::digest(fact.footer_wire()); + ensure!( + bank_footer_sha + .as_ref() + .is_none_or(|old| old == &footer_sha), + "conflicting_bank_footer" + ); + bank_footer_sha = Some(footer_sha.clone()); + let bytes = codec::encode(&fact)?; + files.push(FactFile { + path: fact_name(&fact.binding), + bytes: bytes.len(), + sha256: v2::digest(&bytes), + binding: fact.binding.clone(), + footer_bytes: fact.footer_wire().len(), + footer_sha256: footer_sha, + }); + encoded.push(bytes); + } + let receipt = ExportReceipt { + schema: SCHEMA.into(), + state: "COMPLETE".into(), + profile: codec::PROFILE.into(), + execution, + execution_digest_domain: DOMAIN.into(), + execution_frame_bytes: frame_bytes, + input, + facts: files, + verification: codec::VERIFICATION.into(), + no_source_retirement_authority: true, + continuous_late_evidence_coverage: false, + }; + let mut receipt_bytes = serde_json::to_vec_pretty(&receipt)?; + receipt_bytes.push(b'\n'); + ensure!( + receipt_bytes.len() <= MAX_RECEIPT_BYTES, + "export_receipt_too_large" + ); + let expected: BTreeSet<_> = receipt.facts.iter().map(|f| f.path.clone()).collect(); + if output.exists() { + directory_files(output, &expected)?; + } else { + let mut builder = fs::DirBuilder::new(); + #[cfg(unix)] + { + use std::os::unix::fs::DirBuilderExt; + builder.mode(0o700); + } + builder.create(output)?; + let parent = output + .parent() + .filter(|p| !p.as_os_str().is_empty()) + .unwrap_or(Path::new(".")); + File::open(parent)?.sync_all()?; + } + let _lock = output_lock(output)?; + directory_files(output, &expected)?; + if output.join(RECEIPT).exists() { + ensure!( + bounded_file(&output.join(RECEIPT), MAX_RECEIPT_BYTES)? == receipt_bytes, + "existing_export_receipt_conflict" + ); + // A committed receipt cannot be repaired with different or missing facts. + inspect_export(output)?; + return Ok(receipt); + } + for (row, bytes) in receipt.facts.iter().zip(encoded) { + create_immutable(output, &row.path, &bytes)?; + } + create_immutable(output, RECEIPT, &receipt_bytes)?; // Commit last. + Ok(receipt) +} + +pub fn inspect_export(output: &Path) -> Result { + let receipt: ExportReceipt = + serde_json::from_slice(&bounded_file(&output.join(RECEIPT), MAX_RECEIPT_BYTES)?)?; + receipt.execution.validate()?; + ensure!( + receipt.schema == SCHEMA + && receipt.state == "COMPLETE" + && receipt.profile == codec::PROFILE + && receipt.execution_digest_domain == DOMAIN + && receipt.verification == codec::VERIFICATION + && receipt.no_source_retirement_authority + && !receipt.continuous_late_evidence_coverage + && (16..=v2::MAX_FRAME).contains(&receipt.execution_frame_bytes) + && !receipt.facts.is_empty() + && receipt.facts.len() <= MAX_FACTS + && (1..=MAX_SOURCE_BYTES).contains(&receipt.input.bytes) + && (1..=MAX_SOURCE_BYTES).contains(&receipt.input.decoded_bytes) + && v2::is_digest(&receipt.input.sha256) + && v2::is_digest(&receipt.input.decoded_sha256) + && matches!( + receipt.input.kind.as_str(), + "raw-footer-event" + | "raw-evidence-record" + | "source-events-json" + | "source-events-json-zstd" + ), + "invalid_export_receipt" + ); + // Validate every digest and the derived flat filename before joining a + // receipt-controlled path. decode_bound happens after the file is opened. + let mut total_footer_bytes = 0; + for row in &receipt.facts { + row.binding.validate()?; + ensure!( + (1..=codec::MAX_FOOTER_BYTES).contains(&row.footer_bytes), + "invalid_footer_size" + ); + add_footer_bytes(&mut total_footer_bytes, row.footer_bytes)?; + ensure!( + row.path == fact_name(&row.binding), + "invalid_export_fact_path" + ); + } + let expected: BTreeSet<_> = receipt.facts.iter().map(|f| f.path.clone()).collect(); + ensure!( + expected.len() == receipt.facts.len(), + "duplicate_export_fact" + ); + directory_files(output, &expected)?; + let mut footers = Vec::new(); + let mut previous = 0; + let mut bank_footer_sha: Option = None; + for row in &receipt.facts { + ensure!( + receipt.execution.matches(&row.binding) + && row.path == fact_name(&row.binding) + && row.binding.source_event_sequence > previous, + "export_fact_binding_mismatch" + ); + previous = row.binding.source_event_sequence; + let bytes = bounded_file(&output.join(&row.path), codec::MAX_FACT_BYTES)?; + ensure!( + bytes.len() == row.bytes && v2::digest(&bytes) == row.sha256, + "export_fact_digest_mismatch" + ); + let fact = codec::decode_bound(&bytes, &row.binding)?; + ensure!( + fact.footer_wire().len() == row.footer_bytes + && v2::digest(fact.footer_wire()) == row.footer_sha256, + "export_footer_digest_mismatch" + ); + ensure!( + bank_footer_sha + .as_ref() + .is_none_or(|old| old == &row.footer_sha256), + "conflicting_bank_footer" + ); + bank_footer_sha = Some(row.footer_sha256.clone()); + footers.push(serde_json::to_value(fact.footer()?)?); + } + Ok(ExportInspection { + receipt, + local_hashes_consistent: true, + provenance_authenticated: false, + footers, + }) +} + +/// Inspect one bounded fact. Callers that require trusted provenance must use +/// decode_bound with their independent expected binding instead of this view. +pub fn inspect_fact(path: &Path) -> Result { + let bytes = bounded_file(path, codec::MAX_FACT_BYTES)?; + let fact = codec::decode(&bytes)?; + Ok( + serde_json::json!({"profile":codec::PROFILE,"sha256":v2::digest(&bytes), + "bytes":bytes.len(),"binding":fact.binding,"footer":fact.footer()?, + "provenance_authenticated":false,"no_source_retirement_authority":true}), + ) +} + +#[cfg(test)] +#[path = "consensus_tests.rs"] +mod tests; diff --git a/hivezilla/direct-agave/src/consensus_tests.rs b/hivezilla/direct-agave/src/consensus_tests.rs new file mode 100644 index 0000000..ceffb36 --- /dev/null +++ b/hivezilla/direct-agave/src/consensus_tests.rs @@ -0,0 +1,691 @@ +use super::*; +use serde_json::{Value, json}; +use tempfile::TempDir; + +fn source() -> SourceIdentity { + SourceIdentity { + genesis_hash: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d".into(), + node_identity: "J7qpvCEWhdBgPdYRV3s3btWPrRVXa2qnAzgvxWTvtbrQ".into(), + agave_revision: codec::NATIVE_REVISION.into(), + session_id: "fixture-source-session".into(), + } +} +fn bank(id: u64) -> BankIdentity { + BankIdentity { + slot: 460170404, + bank_id: id, + parent_slot: 460170403, + blockhash: [4; 32], + parent_blockhash: [3; 32], + } +} +fn block_frame(source: SourceIdentity, bank: BankIdentity) -> Vec { + let event = v2::BankEvent { + sequence: 7, + source_sequence: 15, + kind: "block".into(), + bank: bank.clone(), + payload_sha256: v2::digest(b"the exact old execution marker"), + payload_frame_sha256: None, + commitment: Some("processed".into()), + confirmation_basis: Some("operator-trusted-agave-processed-bank-callback".into()), + block_height: Some(438202794), + recent_blockhash: None, + observed_at_unix_ms: 1792700777890, + reason: None, + }; + let objects: Vec<_> = v2::REQUIRED + .iter() + .enumerate() + .map(|(offset, name)| v2::Object { + path: (*name).into(), + offset, + bytes: 1, + sha256: v2::digest(&[42]), + }) + .collect(); + let mut marker = serde_json::to_value(&source).unwrap(); + marker["schema"] = "hivezilla-direct-agave-processed-compact-v1".into(); + marker["state"] = "COMPLETE".into(); + marker["source_profile"] = "agave-bank-callbacks-v1".into(); + marker["canonical"] = false.into(); + marker["publication_ready"] = false.into(); + marker["finalized"] = false.into(); + marker["produced_blocks"] = json!([bank]); + marker["files"] = json!( + objects + .iter() + .map(|o| json!({"path":o.path,"bytes":o.bytes,"sha256":o.sha256})) + .collect::>() + ); + v2::encode( + v2::Envelope { + schema: v2::ENVELOPE.into(), + profile: v2::PROFILE.into(), + evidence_included: false, + marker, + objects, + event, + }, + &vec![42; v2::REQUIRED.len()], + ) + .unwrap() + .wire + .to_vec() +} +fn wire() -> Vec { + let mut bytes = vec![1]; // VersionedBlockFooter::V1, no marker wrapper. + bytes.extend_from_slice(&[0x55; 32]); + bytes.extend_from_slice(&1_792_700_777_890_000_123_u64.to_le_bytes()); + bytes.push(3); + bytes.extend_from_slice(&[0xff, 0, 0xfe]); // User agent is not UTF-8. + bytes.extend_from_slice(&[0, 0, 0]); // No optional certificates. + bytes +} +fn raw_footer(id: u64, footer_wire: &[u8]) -> Vec { + serde_json::to_vec( + &json!({"kind":"Footer","slot":460170404,"bank_id":id,"wire_footer":footer_wire}), + ) + .unwrap() +} +fn evidence(sequence: u64, raw: &[u8]) -> Value { + // This fixture returns a Value, which sorts object keys. Hash the exact + // event serialization that source_file() will emit, not its input spelling. + let event: Value = serde_json::from_slice(raw).unwrap(); + let emitted = serde_json::to_vec(&event).unwrap(); + json!({"sequence":sequence,"sha256":v2::digest(&emitted),"event":event}) +} +struct Fixture { + _root: TempDir, + root: PathBuf, + binding: FactBinding, + event: PathBuf, + payload: PathBuf, + output: PathBuf, + raw: Vec, +} +impl Fixture { + fn new() -> Self { + let temp = TempDir::new().unwrap(); + let root = temp.path().to_owned(); + let payload = root.join("payload.bzstrm"); + let frame = block_frame(source(), bank(2403404)); + fs::write(&payload, &frame).unwrap(); + let raw = raw_footer(2403404, &wire()); + let event = root.join("event.json"); + fs::write(&event, &raw).unwrap(); + let binding = FactBinding { + source: source(), + bank: bank(2403404), + execution_payload_sha256: v2::digest(&frame), + source_event_sequence: 3384311167, + source_event_sha256: v2::digest(&raw), + }; + let output = root.join("export"); + Self { + _root: temp, + root, + binding, + event, + payload, + output, + raw, + } + } + fn export(&self) -> Result { + export_event(&self.binding, &self.event, &self.payload, &self.output) + } + fn source_file(&self, rows: &[Value], compressed: bool) -> PathBuf { + let bytes = serde_json::to_vec(rows).unwrap(); + let path = self.root.join(if compressed { + "source-events.json.zst" + } else { + "source-events.json" + }); + fs::write( + &path, + if compressed { + zstd::stream::encode_all(bytes.as_slice(), 1).unwrap() + } else { + bytes + }, + ) + .unwrap(); + path + } +} +fn replace(path: &Path, bytes: &[u8]) { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + fs::set_permissions(path, fs::Permissions::from_mode(0o600)).unwrap(); + } + fs::write(path, bytes).unwrap(); +} + +#[test] +fn consensus_export_binds_actual_frame_and_exact_event_then_replays_without_rewrite() { + let f = Fixture::new(); + let receipt = f.export().unwrap(); + assert_eq!( + receipt.execution_digest_domain, + "exact execution frame bytes" + ); + assert!(receipt.no_source_retirement_authority); + assert!(!receipt.continuous_late_evidence_coverage); + assert_eq!(receipt.verification, "captured_not_verified"); + assert_eq!(receipt.facts[0].binding, f.binding); + assert_eq!(receipt.input.sha256, v2::digest(&f.raw)); + let path = f.output.join(&receipt.facts[0].path); + let fact_bytes = fs::read(&path).unwrap(); + let fact = codec::decode_bound(&fact_bytes, &f.binding).unwrap(); + assert_eq!(fact.footer_wire(), wire()); + let time = fs::metadata(&path).unwrap().modified().unwrap(); + let original_receipt = fs::read(f.output.join(RECEIPT)).unwrap(); + assert_eq!(f.export().unwrap(), receipt); + assert_eq!(fs::read(f.output.join(RECEIPT)).unwrap(), original_receipt); + assert_eq!(fs::metadata(path).unwrap().modified().unwrap(), time); + let inspected = inspect_export(&f.output).unwrap(); + assert!(inspected.local_hashes_consistent); + assert!(!inspected.provenance_authenticated); + assert_eq!( + inspected.footers[0]["block_producer_time_nanos"], + "1792700777890000123" + ); + assert_eq!( + inspected.footers[0]["block_user_agent"], + json!([255, 0, 254]) + ); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + assert_eq!( + fs::metadata(f.output.join(RECEIPT)) + .unwrap() + .permissions() + .mode() + & 0o777, + 0o444 + ); + } +} + +#[test] +fn consensus_export_checks_raw_evidence_sequence_and_original_event_bytes() { + let f = Fixture::new(); + // Pretty printing the outer record must not change the inner event's SHA. + let record = format!( + "{{\n\"sequence\":{},\n\"sha256\":\"{}\",\n\"event\":{}\n}}", + f.binding.source_event_sequence, + f.binding.source_event_sha256, + String::from_utf8(f.raw.clone()).unwrap() + ); + fs::write(&f.event, record).unwrap(); + let receipt = f.export().unwrap(); + assert_eq!(receipt.input.kind, "raw-evidence-record"); + assert_eq!( + receipt.facts[0].binding.source_event_sha256, + v2::digest(&f.raw) + ); + let bad = Fixture::new(); + fs::write( + &bad.event, + serde_json::to_vec(&evidence(bad.binding.source_event_sequence + 1, &bad.raw)).unwrap(), + ) + .unwrap(); + assert!(bad.export().is_err()); + assert!(!bad.output.exists()); +} + +#[test] +fn consensus_export_rejects_payload_digest_source_bank_and_nonframe_before_writes() { + for fault in ["digest", "source", "bank", "nonframe"] { + let mut f = Fixture::new(); + match fault { + "digest" => f.binding.execution_payload_sha256 = "00".repeat(32), + "source" => f.binding.source.session_id = "another-session".into(), + "bank" => f.binding.bank.bank_id += 1, + "nonframe" => { + fs::write(&f.payload, b"small arbitrary file").unwrap(); + f.binding.execution_payload_sha256 = v2::digest(b"small arbitrary file"); + } + _ => unreachable!(), + } + assert!(f.export().is_err(), "{fault}"); + assert!(!f.output.exists(), "{fault}"); + } +} + +#[test] +fn consensus_export_rejects_control_frame_even_with_matching_source_bank_and_sha() { + let mut f = Fixture::new(); + let payload = v2::decode(fs::read(&f.payload).unwrap().into()).unwrap(); + let mut event = payload.envelope.event.clone(); + event.sequence += 1; + event.kind = "invalidate".into(); + event.payload_frame_sha256 = Some(payload.sha256.clone()); + event.commitment = None; + event.confirmation_basis = None; + event.block_height = None; + event.reason = Some("agave_bank_invalidated".into()); + let frame = v2::encode( + v2::Envelope { + schema: v2::ENVELOPE.into(), + profile: v2::PROFILE.into(), + evidence_included: false, + marker: v2::control_marker(&f.binding.source, &event), + objects: vec![], + event, + }, + &[], + ) + .unwrap(); + f.binding.execution_payload_sha256 = frame.sha256; + fs::write(&f.payload, &frame.wire).unwrap(); + assert!(f.export().is_err()); + assert!(!f.output.exists()); +} + +#[test] +fn consensus_source_export_creates_one_bound_fact_per_footer_from_json_and_zstd() { + for compressed in [false, true] { + let f = Fixture::new(); + let raw_status = serde_json::to_vec(&json!({"kind":"Status","slot":460170404,"bank_id":null,"status":"processed","parent":460170403,"dead_error":null})).unwrap(); + let path = f.source_file( + &[ + evidence(100, &raw_status), + evidence(101, &f.raw), + evidence(102, &f.raw), + ], + compressed, + ); + let receipt = export_source_events( + &ExecutionBinding::from(&f.binding), + &path, + &f.payload, + &f.output, + ) + .unwrap(); + assert_eq!(receipt.facts.len(), 2); + assert_eq!(receipt.facts[0].binding.source_event_sequence, 101); + assert_eq!(receipt.facts[1].binding.source_event_sequence, 102); + assert_eq!( + receipt.facts[0].footer_sha256, + receipt.facts[1].footer_sha256 + ); + assert_ne!(receipt.facts[0].sha256, receipt.facts[1].sha256); + assert_eq!(receipt.input.sha256, v2::digest(&fs::read(path).unwrap())); + assert_eq!(inspect_export(&f.output).unwrap().footers.len(), 2); + } +} + +#[test] +fn consensus_source_export_stops_on_conflicting_footer_bytes_for_the_same_bank() { + let f = Fixture::new(); + let mut changed = wire(); + changed[1] ^= 1; // A different, well-formed claimed bank hash. + let other = raw_footer(f.binding.bank.bank_id, &changed); + let path = f.source_file(&[evidence(101, &f.raw), evidence(102, &other)], false); + let error = export_source_events( + &ExecutionBinding::from(&f.binding), + &path, + &f.payload, + &f.output, + ) + .unwrap_err(); + assert_eq!(error.to_string(), "conflicting_bank_footer"); + assert!(!f.output.exists()); +} + +#[test] +fn consensus_export_caps_aggregate_footer_bytes_before_output_or_json_inspection() { + let f = Fixture::new(); + let mut large = vec![1]; + large.extend_from_slice(&[0x55; 32]); + large.extend_from_slice(&1_792_700_777_890_000_123_u64.to_le_bytes()); + large.push(0); // Empty user agent. + large.push(1); // Finalization cert with an opaque 60,000-byte bitmap. + large.extend_from_slice(&460170400_u64.to_le_bytes()); + large.extend_from_slice(&[8; 32]); + large.extend_from_slice(&[0; 96]); + large.extend_from_slice(&60000_u16.to_le_bytes()); + large.extend_from_slice(&vec![0; 60000]); + large.extend_from_slice(&[0, 0, 0]); + codec::decode_footer(&large).unwrap(); + let raw = raw_footer(f.binding.bank.bank_id, &large); + let count = MAX_TOTAL_FOOTER_BYTES / large.len() + 1; + let mut input = Vec::new(); + input.push(b'['); + for sequence in 1..=count { + if sequence > 1 { + input.push(b','); + } + input.extend_from_slice( + format!( + "{{\"sequence\":{sequence},\"sha256\":\"{}\",\"event\":", + v2::digest(&raw) + ) + .as_bytes(), + ); + input.extend_from_slice(&raw); + input.push(b'}'); + } + input.push(b']'); + let path = f.root.join("large-source.json"); + fs::write(&path, input).unwrap(); + let error = export_source_events( + &ExecutionBinding::from(&f.binding), + &path, + &f.payload, + &f.output, + ) + .unwrap_err(); + assert_eq!(error.to_string(), "footer_total_too_large"); + assert!(!f.output.exists()); + + let receipt = f.export().unwrap(); + let mut forged = receipt.clone(); + forged.facts = (1..=count) + .map(|sequence| { + let mut row = receipt.facts[0].clone(); + row.binding.source_event_sequence = sequence as u64; + row.path = fact_name(&row.binding); + row.footer_bytes = large.len(); + row + }) + .collect(); + replace( + &f.output.join(RECEIPT), + &serde_json::to_vec(&forged).unwrap(), + ); + // Fail before reading the nonexistent paths or constructing footer JSON. + assert_eq!( + inspect_export(&f.output).unwrap_err().to_string(), + "footer_total_too_large" + ); +} + +#[test] +fn consensus_source_export_rejects_mixed_banks_bad_hash_order_and_unknown_records() { + for fault in ["bank", "slot", "hash", "order", "duplicate", "unknown"] { + let f = Fixture::new(); + let mut row = evidence(102, &f.raw); + match fault { + "bank" | "slot" | "unknown" => { + let mut event: Value = serde_json::from_slice(&f.raw).unwrap(); + match fault { + "bank" => event["bank_id"] = 1.into(), + "slot" => event["slot"] = 1.into(), + _ => event["kind"] = "UnknownCallback".into(), + } + row = evidence(102, &serde_json::to_vec(&event).unwrap()); + } + "hash" => row["sha256"] = "00".repeat(32).into(), + "order" => row["sequence"] = 100.into(), + "duplicate" => row["sequence"] = 101.into(), + _ => unreachable!(), + } + let path = f.source_file(&[evidence(101, &f.raw), row], false); + assert!( + export_source_events( + &ExecutionBinding::from(&f.binding), + &path, + &f.payload, + &f.output + ) + .is_err(), + "{fault}" + ); + assert!(!f.output.exists()); + } +} + +#[test] +fn consensus_source_export_does_not_claim_absence_is_preactivation() { + let f = Fixture::new(); + let raw = br#"{"kind":"Entry","slot":460170404,"bank_id":2403404}"#; + let path = f.source_file(&[evidence(101, raw)], false); + let error = export_source_events( + &ExecutionBinding::from(&f.binding), + &path, + &f.payload, + &f.output, + ) + .unwrap_err(); + assert_eq!(error.to_string(), "source_events_have_no_footer"); + assert!(!f.output.exists()); +} + +#[test] +fn consensus_export_rejects_event_identity_digest_and_invalid_footer_without_receipt() { + for fault in ["hash", "bank", "footer", "duplicate-key", "oversized"] { + let mut f = Fixture::new(); + match fault { + "hash" => f.binding.source_event_sha256 = "00".repeat(32), + "bank" => { + let raw = raw_footer(42, &wire()); + f.binding.source_event_sha256 = v2::digest(&raw); + fs::write(&f.event, raw).unwrap(); + } + "footer" => { + let raw = raw_footer(f.binding.bank.bank_id, &[1, 2, 3]); + f.binding.source_event_sha256 = v2::digest(&raw); + fs::write(&f.event, raw).unwrap(); + } + "duplicate-key" => { + let raw = String::from_utf8(f.raw.clone()).unwrap().replacen( + "{", + "{\"kind\":\"Footer\",", + 1, + ); + f.binding.source_event_sha256 = v2::digest(raw.as_bytes()); + fs::write(&f.event, raw).unwrap(); + } + "oversized" => { + File::create(&f.event) + .unwrap() + .set_len(MAX_EVENT_BYTES as u64 + 1) + .unwrap(); + } + _ => unreachable!(), + } + assert!(f.export().is_err(), "{fault}"); + assert!(!f.output.exists()); + } +} + +#[test] +fn consensus_export_resumes_after_fact_publication_before_receipt_without_rewriting_fact() { + let f = Fixture::new(); + let receipt = f.export().unwrap(); + let fact_path = f.output.join(&receipt.facts[0].path); + let fact_time = fs::metadata(&fact_path).unwrap().modified().unwrap(); + let original = fs::read(&fact_path).unwrap(); + fs::remove_file(f.output.join(RECEIPT)).unwrap(); + assert_eq!(f.export().unwrap(), receipt); + assert_eq!(fs::read(&fact_path).unwrap(), original); + assert_eq!( + fs::metadata(fact_path).unwrap().modified().unwrap(), + fact_time + ); + assert!(inspect_export(&f.output).is_ok()); +} + +#[test] +fn consensus_export_never_repairs_committed_missing_or_changed_fact_and_never_overwrites() { + for missing in [true, false] { + let f = Fixture::new(); + let receipt = f.export().unwrap(); + let receipt_before = fs::read(f.output.join(RECEIPT)).unwrap(); + let path = f.output.join(&receipt.facts[0].path); + if missing { + fs::remove_file(&path).unwrap(); + } else { + replace(&path, b"corrupt fact bytes"); + } + assert!(f.export().is_err()); + assert!(inspect_export(&f.output).is_err()); + assert_eq!(fs::read(f.output.join(RECEIPT)).unwrap(), receipt_before); + if !missing { + assert_eq!(fs::read(path).unwrap(), b"corrupt fact bytes"); + } else { + assert!(!path.exists()); + } + } +} + +#[test] +fn consensus_export_refuses_different_input_receipt_or_unrelated_output_files() { + let f = Fixture::new(); + f.export().unwrap(); + let receipt_before = fs::read(f.output.join(RECEIPT)).unwrap(); + fs::write( + &f.event, + serde_json::to_vec(&evidence(f.binding.source_event_sequence, &f.raw)).unwrap(), + ) + .unwrap(); + assert!(f.export().is_err()); + assert_eq!(fs::read(f.output.join(RECEIPT)).unwrap(), receipt_before); + let other = Fixture::new(); + fs::create_dir(&other.output).unwrap(); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + fs::set_permissions(&other.output, fs::Permissions::from_mode(0o700)).unwrap(); + } + fs::write( + other.output.join("DIRECT-AGAVE-COMPACT.v1.json"), + b"old execution marker", + ) + .unwrap(); + assert!(other.export().is_err()); + assert!(!other.output.join(LOCK).exists()); + assert_eq!( + fs::read(other.output.join("DIRECT-AGAVE-COMPACT.v1.json")).unwrap(), + b"old execution marker" + ); +} + +#[test] +fn consensus_export_inspection_rejects_false_authority_and_binding_claims() { + for field in [ + "no_source_retirement_authority", + "continuous_late_evidence_coverage", + "binding", + ] { + let f = Fixture::new(); + f.export().unwrap(); + let mut receipt: Value = + serde_json::from_slice(&fs::read(f.output.join(RECEIPT)).unwrap()).unwrap(); + match field { + "no_source_retirement_authority" => receipt[field] = false.into(), + "continuous_late_evidence_coverage" => receipt[field] = true.into(), + _ => receipt["facts"][0]["binding"]["bank"]["bank_id"] = 42.into(), + } + replace( + &f.output.join(RECEIPT), + &serde_json::to_vec(&receipt).unwrap(), + ); + assert!(inspect_export(&f.output).is_err(), "{field}"); + } +} + +#[test] +fn consensus_export_validates_untrusted_digest_and_flat_path_before_opening_fact() { + for fault in ["digest", "path"] { + let f = Fixture::new(); + f.export().unwrap(); + let mut receipt: Value = + serde_json::from_slice(&fs::read(f.output.join(RECEIPT)).unwrap()).unwrap(); + match fault { + "digest" => { + receipt["facts"][0]["binding"]["source_event_sha256"] = "../outside".into(); + receipt["facts"][0]["path"] = "00000000003384311167-../outside.bzcnf".into(); + } + _ => receipt["facts"][0]["path"] = "../outside.bzcnf".into(), + } + replace( + &f.output.join(RECEIPT), + &serde_json::to_vec(&receipt).unwrap(), + ); + let error = inspect_export(&f.output).unwrap_err().to_string(); + assert!( + matches!( + error.as_str(), + "invalid_consensus_fact_binding" | "invalid_export_fact_path" + ), + "{error}" + ); + } +} + +#[test] +fn consensus_export_relative_output_works_in_a_separate_process() { + let f = Fixture::new(); + fs::write( + f.root.join("binding.json"), + serde_json::to_vec(&f.binding).unwrap(), + ) + .unwrap(); + let result = std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "consensus::tests::consensus_relative_output_child", + "--ignored", + ]) + .env("HIVEZILLA_CONSENSUS_TEST_INPUT", &f.root) + .current_dir(&f.root) + .output() + .unwrap(); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + assert!(f.root.join("relative-export").join(RECEIPT).is_file()); + assert!(inspect_export(&f.root.join("relative-export")).is_ok()); +} + +#[test] +#[ignore = "subprocess entry point for the relative output regression"] +fn consensus_relative_output_child() { + let root = PathBuf::from( + std::env::var_os("HIVEZILLA_CONSENSUS_TEST_INPUT").expect("subprocess fixture"), + ); + let binding: FactBinding = + serde_json::from_slice(&fs::read(root.join("binding.json")).unwrap()).unwrap(); + export_event( + &binding, + &root.join("event.json"), + &root.join("payload.bzstrm"), + Path::new("relative-export"), + ) + .unwrap(); +} + +#[test] +fn consensus_export_refuses_an_active_output_writer() { + let f = Fixture::new(); + f.export().unwrap(); + let _owner = output_lock(&f.output).unwrap(); + assert!(f.export().is_err()); +} + +#[cfg(unix)] +#[test] +fn consensus_export_rejects_symlink_input_output_and_fact() { + use std::os::unix::fs::symlink; + let f = Fixture::new(); + let event_link = f.root.join("linked-event.json"); + symlink(&f.event, &event_link).unwrap(); + assert!(export_event(&f.binding, &event_link, &f.payload, &f.output).is_err()); + assert!(!f.output.exists()); + symlink(&f.root, &f.output).unwrap(); + assert!(f.export().is_err()); + fs::remove_file(&f.output).unwrap(); + let receipt = f.export().unwrap(); + let fact_path = f.output.join(&receipt.facts[0].path); + fs::remove_file(&fact_path).unwrap(); + symlink(&f.event, fact_path).unwrap(); + assert!(inspect_export(&f.output).is_err()); +} diff --git a/hivezilla/direct-agave/src/lib.rs b/hivezilla/direct-agave/src/lib.rs index 1e13af5..038dfe9 100644 --- a/hivezilla/direct-agave/src/lib.rs +++ b/hivezilla/direct-agave/src/lib.rs @@ -1,5 +1,6 @@ //! Bank-aware Agave execution capture. Queue acceptance is not a durable acknowledgement. pub mod confirmed; +pub mod consensus; pub mod event; pub mod journal; #[cfg(feature = "plugin")] diff --git a/hivezilla/direct-agave/src/main.rs b/hivezilla/direct-agave/src/main.rs index b19d4b5..b4ddbc4 100644 --- a/hivezilla/direct-agave/src/main.rs +++ b/hivezilla/direct-agave/src/main.rs @@ -1,6 +1,9 @@ -use anyhow::Result; +use anyhow::{Result, ensure}; use clap::{Parser, Subcommand}; -use std::path::PathBuf; +use std::{ + io::Read, + path::{Path, PathBuf}, +}; #[derive(Parser)] struct Args { #[command(subcommand)] @@ -8,6 +11,24 @@ struct Args { } #[derive(Subcommand)] enum Command { + /// Export one captured native Footer as a separate immutable consensus fact. + ExportConsensus { + binding: PathBuf, + event: PathBuf, + execution_payload: PathBuf, + output: PathBuf, + }, + /// Export captured footers from one bank's retained source-events JSON or Zstd JSON. + ExportConsensusSourceEvents { + binding: PathBuf, + source_events: PathBuf, + execution_payload: PathBuf, + output: PathBuf, + }, + /// Validate an export receipt and all referenced immutable consensus facts. + InspectConsensusExport { directory: PathBuf }, + /// Read a consensus fact with an independently supplied source/bank/payload binding. + InspectConsensusFact { fact: PathBuf, binding: PathBuf }, /// Build v2 controls and frames from already committed compact banks and native observations. BuildConfirmed { processed: PathBuf, @@ -43,6 +64,59 @@ enum Command { } fn main() -> Result<()> { match Args::parse().command { + Command::ExportConsensus { + binding, + event, + execution_payload, + output, + } => { + let binding = serde_json::from_slice(&read_bounded(&binding, 4096)?)?; + let receipt = hivezilla_direct_agave::consensus::export_event( + &binding, + &event, + &execution_payload, + &output, + )?; + println!("{}", serde_json::to_string(&receipt)?); + Ok(()) + } + Command::ExportConsensusSourceEvents { + binding, + source_events, + execution_payload, + output, + } => { + let binding = serde_json::from_slice(&read_bounded(&binding, 4096)?)?; + let receipt = hivezilla_direct_agave::consensus::export_source_events( + &binding, + &source_events, + &execution_payload, + &output, + )?; + println!("{}", serde_json::to_string(&receipt)?); + Ok(()) + } + Command::InspectConsensusExport { directory } => { + let report = hivezilla_direct_agave::consensus::inspect_export(&directory)?; + println!("{}", serde_json::to_string(&report)?); + Ok(()) + } + Command::InspectConsensusFact { fact, binding } => { + use blockzilla_bank_stream_v2::consensus as c; + let binding = + serde_json::from_slice(&read_bounded(&binding, c::MAX_BINDING_BYTES as u64)?)?; + let bytes = read_bounded(&fact, c::MAX_FACT_BYTES as u64)?; + let value = c::decode_bound(&bytes, &binding)?; + println!( + "{}", + serde_json::json!({ + "profile": c::PROFILE, "binding": value.binding, + "verification": c::VERIFICATION, "carrier_consensus_block_id": null, + "footer": value.footer()?, + }) + ); + Ok(()) + } Command::BuildConfirmed { processed, output, @@ -98,3 +172,12 @@ fn main() -> Result<()> { } } } + +fn read_bounded(path: &Path, limit: u64) -> Result> { + let mut bytes = Vec::new(); + std::fs::File::open(path)? + .take(limit + 1) + .read_to_end(&mut bytes)?; + ensure!(bytes.len() as u64 <= limit, "input_file_too_large"); + Ok(bytes) +} diff --git a/hivezilla/stream-relay/client/README.md b/hivezilla/stream-relay/client/README.md index 6aa619b..389adb8 100644 --- a/hivezilla/stream-relay/client/README.md +++ b/hivezilla/stream-relay/client/README.md @@ -5,6 +5,13 @@ locally. It runs the same Rust decoder in Node.js and browsers through `decoder.wasm`. There are no JavaScript package dependencies or generated Wasm bindings. This package is private and has not been published to npm. +The separate `./consensus` entry point reads immutable retained Alpenglow footer +facts with `decoder-consensus-v1.wasm`. It preserves leader nanoseconds and +certificate target slots as decimal strings. It checks the complete fact digest +and caller-supplied source/bank/execution binding. Certificates remain +`captured_not_verified`; this API does not set a bank's finality state. Read +the [format and delivery plan](../../../docs/architecture/alpenglow-consensus-facts.md). + Start with [Live stream](../../../docs/start/live-stream.md) for connection and transport examples, or [Program dumper](../../../docs/start/program-dumper.md) for a program watch list. The separate [token indexer](../../../docs/start/token-indexer.md) diff --git a/hivezilla/stream-relay/client/consensus-test.mjs b/hivezilla/stream-relay/client/consensus-test.mjs new file mode 100644 index 0000000..3f8c344 --- /dev/null +++ b/hivezilla/stream-relay/client/consensus-test.mjs @@ -0,0 +1,92 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFile } from 'node:fs/promises'; +import { createHash } from 'node:crypto'; +import { loadConsensusDecoder, decodeConsensusFact, MAX_CONSENSUS_FACT_BYTES } from './consensus.mjs'; + +const fixtureBase = new URL('../../../crates/blockzilla-bank-stream-v2/tests/fixtures/', import.meta.url); +const footer = await readFile(new URL('captured-footer-3384311167.wincode', fixtureBase)); +const provenance = JSON.parse(await readFile(new URL('captured-footer-3384311167.json', fixtureBase))); +const decoder = await loadConsensusDecoder(); +const sha = bytes => createHash('sha256').update(bytes).digest('hex'); +// This reader test binds retained native bytes to a synthetic execution identity. +// Only the native exporter tests check a matching execution frame. +const binding = { + source: provenance.source, + bank: { slot: provenance.carrier_slot, bank_id: provenance.carrier_bank_id, + blockhash: Array(32).fill(8), parent_slot: provenance.carrier_slot - 1, parent_blockhash: Array(32).fill(7) }, + execution_payload_sha256: 'ab'.repeat(32), + source_event_sequence: provenance.source_event_sequence, + source_event_sha256: provenance.source_event_sha256, +}; +function frame(native = footer) { + const json = Buffer.from(JSON.stringify(binding)), header = Buffer.alloc(20); + header.write('BZCNF001'); header.writeUInt16LE(1, 8); header.writeUInt16LE(1, 10); + header.writeUInt32LE(json.length, 12); header.writeUInt32LE(native.length, 16); + return Buffer.concat([header, json, native]); +} + +test('shared Wasm reader keeps native nanoseconds, bytes and older certificate target', async () => { + assert.equal(sha(footer), provenance.native_footer_sha256); + const bytes = frame(); + const value = (await decodeConsensusFact(bytes, sha(bytes), binding, decoder)).decoded; + assert.equal(value.verification, 'captured_not_verified'); + assert.equal(value.carrier_consensus_block_id, null); + assert.equal(value.footer_sha256, provenance.native_footer_sha256); + assert.equal(value.footer.block_producer_time_nanos, provenance.producer_time_nanos); + assert.equal(BigInt(value.footer.block_producer_time_nanos), 1792700777706079707n); + assert.equal(value.footer.block_final_cert.slot, '460170403'); + assert.notEqual(BigInt(value.footer.block_final_cert.slot), BigInt(binding.bank.slot)); + assert.equal(Buffer.from(value.footer.bank_hash).toString('hex'), provenance.bank_hash_hex); + assert.equal(Buffer.from(value.footer.block_user_agent).toString('hex'), provenance.user_agent_hex); + assert.equal(value.footer.block_final_cert.final_aggregate.signature.length, 96); + assert.equal(value.footer.block_final_cert.notar_aggregate, null); // Captured fast-final path. + assert.equal(value.footer.skip_reward_cert, null); + assert.equal(value.footer.notar_reward_cert.aggregate.signature.length, 96); +}); + +test('SDK rejects altered bytes and a different source, bank, payload or event binding', async () => { + const wire = frame(); + await assert.rejects(decodeConsensusFact(wire, '00'.repeat(32), binding, decoder), /consensus_digest_mismatch/); + const alternatives = [ + b => { b.source.session_id = 'different-session'; }, + b => { b.bank.bank_id++; }, + b => { b.bank.parent_blockhash[0] ^= 1; }, + b => { b.execution_payload_sha256 = '12'.repeat(32); }, + b => { b.source_event_sequence++; }, + b => { b.source_event_sha256 = '34'.repeat(32); }, + ]; + for (const alter of alternatives) { + const other = structuredClone(binding); alter(other); + await assert.rejects(decodeConsensusFact(wire, sha(wire), other, decoder), /consensus_decode_failed/); + } +}); + +test('shared parser rejects an unknown grammar, invalid option and every truncated footer', async () => { + const good = frame(); + for (const at of [0, 8, 10]) { + const bad = Buffer.from(good); bad[at] ^= 2; + await assert.rejects(decodeConsensusFact(bad, sha(bad), binding, decoder), /consensus_decode_failed/); + } + const native = Buffer.from(footer), optionAt = 42 + native[41]; + native[optionAt] = 2; + const bad = frame(native); + await assert.rejects(decodeConsensusFact(bad, sha(bad), binding, decoder), /consensus_decode_failed/); + for (let n = 0; n < footer.length; n++) { + assert.throws(() => decoder.decode(frame(footer.subarray(0, n)), binding), /consensus_decode_failed/); + } + assert.throws(() => decoder.decode(new Uint8Array(MAX_CONSENSUS_FACT_BYTES + 1), binding), /invalid_consensus_fact_size/); +}); + +test('full u64 time and absent certificates stay exact without a Tower fallback', () => { + const native = Buffer.alloc(45); native[0] = 1; native.writeBigUInt64LE(0xffffffffffffffffn, 33); + const value = decoder.decode(frame(native), binding); + assert.equal(value.footer.block_producer_time_nanos, '18446744073709551615'); + assert.equal(value.footer.block_final_cert, null); + assert.equal(value.footer.skip_reward_cert, null); + assert.equal(value.footer.notar_reward_cert, null); + assert.equal(value.verification, 'captured_not_verified'); + const before = decoder.memoryBytes; + for (let n = 0; n < 200; n++) decoder.decode(frame(), binding); + assert.ok(decoder.memoryBytes <= before + 4 * 65536, 'owned Wasm buffers must be released'); +}); diff --git a/hivezilla/stream-relay/client/consensus.d.mts b/hivezilla/stream-relay/client/consensus.d.mts new file mode 100644 index 0000000..f9e29a2 --- /dev/null +++ b/hivezilla/stream-relay/client/consensus.d.mts @@ -0,0 +1,39 @@ +export const CONSENSUS_PROFILE: 'native-consensus-fact-v1'; +export const MAX_CONSENSUS_FACT_BYTES: number; +export interface ConsensusBinding { + source: { genesis_hash: string; node_identity: string; agave_revision: string; session_id: string }; + bank: { slot: number; bank_id: number; blockhash: number[]; parent_slot: number; parent_blockhash: number[] }; + execution_payload_sha256: string; + source_event_sequence: number; + source_event_sha256: string; +} +export interface CapturedAggregate { signature: number[]; bitmap: number[] } +export interface ConsensusProjection { + profile: 'native-consensus-fact-v1'; + binding: ConsensusBinding; + verification: 'captured_not_verified'; + carrier_consensus_block_id: null; + footer_bytes: number; + footer_sha256: string; + footer: { + native_schema: 'agave-4.3.2-versioned-block-footer-v1'; + verification: 'captured_not_verified'; + bank_hash: number[]; + /** Exact Unix nanoseconds. Use BigInt(value) for arithmetic. */ + block_producer_time_nanos: string; + block_user_agent: number[]; + block_final_cert: null | { + slot: string; block_id: number[]; + final_aggregate: CapturedAggregate; notar_aggregate: CapturedAggregate | null; + }; + skip_reward_cert: null | { slot: string; aggregate: CapturedAggregate }; + notar_reward_cert: null | { slot: string; block_id: number[]; aggregate: CapturedAggregate }; + }; +} +export interface ConsensusDecoder { + decode(wire: Uint8Array, binding: ConsensusBinding): ConsensusProjection; + readonly memoryBytes: number; +} +export function loadConsensusDecoder(wasm?: URL | string | BufferSource | WebAssembly.Module): Promise; +export function decodeConsensusFact(wire: Uint8Array, expectedDigest: string, binding: ConsensusBinding, + decoder: ConsensusDecoder): Promise<{ wire: Uint8Array; digest: string; decoded: ConsensusProjection }>; diff --git a/hivezilla/stream-relay/client/consensus.mjs b/hivezilla/stream-relay/client/consensus.mjs new file mode 100644 index 0000000..6aad726 --- /dev/null +++ b/hivezilla/stream-relay/client/consensus.mjs @@ -0,0 +1,71 @@ +// Independent immutable footer facts. Existing v1/v2 execution readers stay separate. +import { StreamError } from './index.mjs'; + +export const CONSENSUS_PROFILE = 'native-consensus-fact-v1'; +export const MAX_CONSENSUS_FACT_BYTES = 20 + 4096 + 65535; +const MAX_BINDING_BYTES = 4096, MAX_OUTPUT_BYTES = 1024 * 1024; +const encoder = new TextEncoder(), text = new TextDecoder('utf-8', { fatal: true }); +const check = (ok, code, detail) => { if (!ok) throw new StreamError(code, detail); }; +const sha = async bytes => [...new Uint8Array(await crypto.subtle.digest('SHA-256', bytes))] + .map(n => n.toString(16).padStart(2, '0')).join(''); + +/** Use the same strict Rust footer grammar in Node.js and the browser. */ +export async function loadConsensusDecoder(wasm = new URL('./decoder-consensus-v1.wasm', import.meta.url)) { + if (wasm instanceof URL || typeof wasm === 'string') { + const url = new URL(wasm, import.meta.url); + if (url.protocol === 'file:' && typeof process !== 'undefined' && process.versions?.node) { + wasm = await (await import('node:fs/promises')).readFile(url); + } else { + const response = await fetch(url, { redirect: 'error' }); + check(response.ok, 'decoder_download_failed'); + wasm = await response.arrayBuffer(); + } + } + const result = await WebAssembly.instantiate(wasm, {}); + const api = (result instanceof WebAssembly.Instance ? result : result.instance).exports; + check(api.memory instanceof WebAssembly.Memory + && ['bz_alloc', 'bz_free', 'bz_decode_consensus'].every(k => typeof api[k] === 'function'), + 'invalid_consensus_decoder_abi'); + return { + decode(wire, binding) { + check(wire instanceof Uint8Array && wire.length >= 20 && wire.length <= MAX_CONSENSUS_FACT_BYTES, + 'invalid_consensus_fact_size'); + const options = encoder.encode(JSON.stringify(binding)); + check(options.length <= MAX_BINDING_BYTES, 'consensus_binding_too_large'); + let input = 0, opts = 0, output = 0, n = 0; + try { + input = api.bz_alloc(wire.length); + new Uint8Array(api.memory.buffer, input, wire.length).set(wire); + opts = api.bz_alloc(options.length); + new Uint8Array(api.memory.buffer, opts, options.length).set(options); + const packed = api.bz_decode_consensus(input, wire.length, opts, options.length); + output = Number(packed & 0xffffffffn); n = Number(packed >> 32n); + check(n > 0 && n <= MAX_OUTPUT_BYTES, 'consensus_output_limit_exceeded'); + const value = JSON.parse(text.decode(new Uint8Array(api.memory.buffer, output, n))); + check(!value.error, 'consensus_decode_failed', { reason: value.error }); + check(value.profile === CONSENSUS_PROFILE && value.verification === 'captured_not_verified' + && value.carrier_consensus_block_id === null, 'invalid_consensus_projection'); + return value; + } finally { + if (output) api.bz_free(output, n); + if (opts) api.bz_free(opts, options.length); + if (input) api.bz_free(input, wire.length); + } + }, + get memoryBytes() { return api.memory.buffer.byteLength; }, + }; +} + +/** Bind the whole fact to a trusted receipt and its execution payload. The + * decoded certificate target can be older than the carrying block. This call + * does not set a bank's confirmed/rooted state or verify BLS signatures. */ +export async function decodeConsensusFact(wire, expectedDigest, binding, decoder) { + check(wire instanceof Uint8Array && wire.length >= 20 && wire.length <= MAX_CONSENSUS_FACT_BYTES, + 'invalid_consensus_fact_size'); + check(typeof expectedDigest === 'string' && /^[a-f0-9]{64}$/.test(expectedDigest), 'invalid_consensus_digest'); + const copy = wire.slice(), expected = structuredClone(binding); + const digest = await sha(copy); + check(digest === expectedDigest, 'consensus_digest_mismatch'); + const decoded = decoder.decode(copy, expected); + return { wire: copy, digest, decoded }; +} diff --git a/hivezilla/stream-relay/client/decoder-consensus-v1.wasm b/hivezilla/stream-relay/client/decoder-consensus-v1.wasm new file mode 100644 index 0000000000000000000000000000000000000000..6ed9b4643f5273e319e62dc7328237a66cc8b95b GIT binary patch literal 821314 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 E#nW+mdTsG^te&nbp2+Hs^6QHyuJ(xX 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%0DiJ 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 P*Zc-r;oJ3$=22" diff --git a/hivezilla/stream-relay/decoder/README.md b/hivezilla/stream-relay/decoder/README.md index ff44f63..5b89b9f 100644 --- a/hivezilla/stream-relay/decoder/README.md +++ b/hivezilla/stream-relay/decoder/README.md @@ -30,3 +30,16 @@ The supported result is semantic compact transaction data. Exact signed wire reconstruction, full RPC rendering, portable log expansion, and a shared stable live dictionary are separate work. Do not present this projection as canonical archive data or interpret absent inner metadata as proved absence of CPI calls. + +## Native consensus facts + +The separate `bz_decode_consensus` export reads `native-consensus-fact-v1` +through the shared Rust codec. Its configuration is the full expected +`FactBinding`, supplied independently by the caller. It returns exact leader +nanoseconds as a decimal string. Captured certificate targets remain separate +from the carrying block. This reader does not verify BLS signatures or change +the existing execution decoder's admission rules. + +Copy the Wasm output to `../client/decoder-consensus-v1.wasm` for the opt-in +`consensus.mjs` reader. Keep the existing v1/v2 decoder files separate. See the +[format and delivery plan](../../../docs/architecture/alpenglow-consensus-facts.md). diff --git a/hivezilla/stream-relay/decoder/src/consensus.rs b/hivezilla/stream-relay/decoder/src/consensus.rs new file mode 100644 index 0000000..d4f77c7 --- /dev/null +++ b/hivezilla/stream-relay/decoder/src/consensus.rs @@ -0,0 +1,42 @@ +//! Read the independent native consensus fact profile with the shared parser. +//! A bound captured footer is an observation, not a verified BLS certificate. +use anyhow::{Result, ensure}; +use blockzilla_bank_stream_v2::{consensus as fact, digest}; + +/// The caller must supply the exact binding from its trusted execution/evidence +/// receipt. In particular, a footer must not select its own execution dependency. +pub fn decode(wire: &[u8], expected: &fact::FactBinding) -> Result> { + let value = fact::decode_bound(wire, expected)?; + let output = serde_json::to_vec(&serde_json::json!({ + "profile": fact::PROFILE, + "binding": value.binding, + "verification": fact::VERIFICATION, + "carrier_consensus_block_id": null, + "footer_bytes": value.footer_wire().len(), + "footer_sha256": digest(value.footer_wire()), + "footer": value.footer()?, + }))?; + ensure!(output.len() <= 1_048_576, "consensus_output_limit_exceeded"); + Ok(output) +} + +#[cfg(target_arch = "wasm32")] +#[unsafe(no_mangle)] +pub unsafe extern "C" fn bz_decode_consensus( + ptr: u32, + len: u32, + binding_ptr: u32, + binding_len: u32, +) -> u64 { + super::bank_output((|| { + ensure!( + len as usize <= fact::MAX_FACT_BYTES && binding_len as usize <= fact::MAX_BINDING_BYTES, + "consensus_input_limit_exceeded" + ); + let wire = unsafe { std::slice::from_raw_parts(ptr as *const u8, len as usize) }; + let expected: fact::FactBinding = serde_json::from_slice(unsafe { + std::slice::from_raw_parts(binding_ptr as *const u8, binding_len as usize) + })?; + decode(wire, &expected) + })()) +} diff --git a/hivezilla/stream-relay/decoder/src/lib.rs b/hivezilla/stream-relay/decoder/src/lib.rs index 36281b8..daac0b6 100644 --- a/hivezilla/stream-relay/decoder/src/lib.rs +++ b/hivezilla/stream-relay/decoder/src/lib.rs @@ -13,6 +13,8 @@ use std::{ io::{Read, Write}, }; +pub mod consensus; + const MAX_FRAME: usize = 16 * 1024 * 1024 + 65_536 + 16; const MAX_BLOCK: usize = 64 * 1024 * 1024; const MAX_OUTPUT: usize = 32 * 1024 * 1024; From 8b8ca989673ba4232091a8acfd0d4d9fcad9a7a4 Mon Sep 17 00:00:00 2001 From: augustin Date: Fri, 23 Oct 2026 10:54:42 +0200 Subject: [PATCH 2/3] Fix consensus module order and record existing CI blockers --- crates/blockzilla-bank-stream-v2/src/lib.rs | 2 +- .../architecture/alpenglow-consensus-facts.md | 4 +- .../evidence/alpenglow-format-20261023.json | 56 +++++++++++++++++-- 3 files changed, 53 insertions(+), 9 deletions(-) diff --git a/crates/blockzilla-bank-stream-v2/src/lib.rs b/crates/blockzilla-bank-stream-v2/src/lib.rs index 621b141..a15ceb0 100644 --- a/crates/blockzilla-bank-stream-v2/src/lib.rs +++ b/crates/blockzilla-bank-stream-v2/src/lib.rs @@ -654,11 +654,11 @@ impl Notice { } } -pub mod consensus; #[cfg(not(target_arch = "wasm32"))] pub mod artifact; pub mod chain; pub mod client; +pub mod consensus; #[cfg(any(test, feature = "test-fixtures"))] pub mod fixtures; #[cfg(test)] diff --git a/docs/architecture/alpenglow-consensus-facts.md b/docs/architecture/alpenglow-consensus-facts.md index ca79f98..710387c 100644 --- a/docs/architecture/alpenglow-consensus-facts.md +++ b/docs/architecture/alpenglow-consensus-facts.md @@ -189,7 +189,7 @@ a subprocess. The WebAssembly release build passed. A real retained 556-byte footer and an independent Wincode fixture test the native grammar. These tests do not establish full historical coverage or production progress. -CI now builds the consensus WebAssembly reader from source and tests it with -the v1/v2/consensus JavaScript suites. Read the +The CI job is configured to build the consensus WebAssembly reader from source +and test it with the v1/v2/consensus JavaScript suites. Read the [acceptance receipt](../operations/evidence/alpenglow-format-20261023.json) for artifact hashes, commands and limits. diff --git a/docs/operations/evidence/alpenglow-format-20261023.json b/docs/operations/evidence/alpenglow-format-20261023.json index 97aa8cd..ad12b7c 100644 --- a/docs/operations/evidence/alpenglow-format-20261023.json +++ b/docs/operations/evidence/alpenglow-format-20261023.json @@ -59,11 +59,24 @@ "result": "PASS", "historical_execution_payload_binding_proven": false }, - "formatting": "PASS", + "formatting": "Changed files PASS; whole manifests also report pre-existing processed.rs and publisher.rs formatting failures", "staged_diff_check": "PASS", "ci_yaml_parse": "PASS", "independent_protocol_and_code_review": "PASS", - "ci_when_saved": "CONFIGURED_NOT_RUN_YET" + "ci_when_saved": "INITIAL_RUN_FAILED; own module-order issue corrected; pre-existing main failures remain visible", + "ci_baseline": { + "main_commit": "b01231ce80c740730478198e521eac9367a11495", + "main_run": "https://github.com/FernoLabs/blockzilla/actions/runs/39429692313", + "pr_initial_run": "https://github.com/FernoLabs/blockzilla/actions/runs/39926960388", + "baseline_failure_categories": [ + "processed.rs formatting", + "publisher.rs formatting", + "Missing local hivezilla/deploy/validator-tunnel/access-application.json link target", + "Reachable-history scanner:135 findings on main and initial PR run" + ], + "individual_history_findings_compared": false, + "checks_weakened": false + } }, "native_fixture": { "bank_hash_hex": "c512cdbd4355a9c06d96696f63057b7fde6b113dac7a7b444a52c69d507ca5da", @@ -111,7 +124,7 @@ { "path": "crates/blockzilla-bank-stream-v2/src/lib.rs", "bytes": 23611, - "sha256": "2445e6f829ffb2e6b4091b75205b886f2a8a342fe7407e4eb0c96212609bce18" + "sha256": "35cf5ce103f4ee7e0196ed59db2e85671ce9ac153168a07fa8ed95ae484d23d4" }, { "path": "crates/blockzilla-bank-stream-v2/tests/consensus.rs", @@ -135,8 +148,8 @@ }, { "path": "docs/architecture/alpenglow-consensus-facts.md", - "bytes": 11358, - "sha256": "48bb0e30bcf588edb4cd56f9d3da507357c20d83edb4f48a25ef87a073c1e723" + "bytes": 11377, + "sha256": "8586ce678a0c4d9abc9659c7fdf8ed501b3b88e1cef15fb6dda0a99f73e1ac55" }, { "path": "hivezilla/direct-agave/README.md", @@ -244,6 +257,37 @@ "local_evidence": "cli-smoke/inspection.json", "bytes": 3290, "sha256": "7f65e3b7dde56b5fc1baddeec869b3b96f36cc62ddcd44c625e3e926d2c2bfc4" + }, + { + "local_evidence": "wasm-build-after-ci.log", + "bytes": 1871, + "sha256": "3ef7fdcbdd9b81a724e21d244961d0ad38fa370fca3d137dce8ef5f92f1a37e6" + }, + { + "local_evidence": "client-tests-after-ci.log", + "bytes": 2489, + "sha256": "da41c42b860cd7231a12bcda3565b18ff425135515a4e536f46e6877b6b13a45" + }, + { + "local_evidence": "ci-stream-39926960388.log", + "bytes": 17184, + "sha256": "1271feaaccfaca33ae8093a212e4010dd7f89b682e6e1979bfacbd4fc5039960" + }, + { + "local_evidence": "ci-rust-39926960388.log", + "bytes": 51574, + "sha256": "f26105281b48320bfb8192a93c577b89ba1b6c18e152de504b846f7f1c32196b" + }, + { + "local_evidence": "ci-docs-39926960388.log", + "bytes": 25294, + "sha256": "ad1a68f3de7b7b3ce834525cc99ff4c82ec34044ffe88c9687914221b257a06a" + }, + { + "local_evidence": "ci-secrets-39926960388.log", + "bytes": 18036, + "sha256": "2939a9d0645b668f2294f599c8b00d848176dcf504b2b030d188ea8748f8e6bb" } - ] + ], + "updated_utc": "2026-10-23T08:54:03.772317+00:00" } From 6324f2e91f685aa4f6b1d98d8536199cef5ad982 Mon Sep 17 00:00:00 2001 From: augustin Date: Sat, 24 Oct 2026 00:48:17 +0200 Subject: [PATCH 3/3] Copy consensus Buffer input before digest verification --- hivezilla/stream-relay/client/consensus-test.mjs | 14 ++++++++++++++ hivezilla/stream-relay/client/consensus.mjs | 2 +- 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/hivezilla/stream-relay/client/consensus-test.mjs b/hivezilla/stream-relay/client/consensus-test.mjs index 3f8c344..5a9e599 100644 --- a/hivezilla/stream-relay/client/consensus-test.mjs +++ b/hivezilla/stream-relay/client/consensus-test.mjs @@ -62,6 +62,20 @@ test('SDK rejects altered bytes and a different source, bank, payload or event b } }); +test('SDK keeps Buffer bytes private while the digest is pending', async () => { + const wire = frame(), original = Buffer.from(wire), expectedDigest = sha(original); + const pending = decodeConsensusFact(wire, expectedDigest, binding, decoder); + // Change a valid footer field after hashing starts and before decoding resumes. + wire[wire.length - footer.length + 1] ^= 1; + assert.notEqual(sha(wire), expectedDigest); + const result = await pending; + assert.equal(result.digest, expectedDigest); + assert.equal(sha(result.wire), expectedDigest); + assert.deepEqual(Buffer.from(result.wire), original); + assert.equal(result.decoded.footer_sha256, provenance.native_footer_sha256); + assert.equal(Buffer.from(result.decoded.footer.bank_hash).toString('hex'), provenance.bank_hash_hex); +}); + test('shared parser rejects an unknown grammar, invalid option and every truncated footer', async () => { const good = frame(); for (const at of [0, 8, 10]) { diff --git a/hivezilla/stream-relay/client/consensus.mjs b/hivezilla/stream-relay/client/consensus.mjs index 6aad726..15229e8 100644 --- a/hivezilla/stream-relay/client/consensus.mjs +++ b/hivezilla/stream-relay/client/consensus.mjs @@ -63,7 +63,7 @@ export async function decodeConsensusFact(wire, expectedDigest, binding, decoder check(wire instanceof Uint8Array && wire.length >= 20 && wire.length <= MAX_CONSENSUS_FACT_BYTES, 'invalid_consensus_fact_size'); check(typeof expectedDigest === 'string' && /^[a-f0-9]{64}$/.test(expectedDigest), 'invalid_consensus_digest'); - const copy = wire.slice(), expected = structuredClone(binding); + const copy = new Uint8Array(wire), expected = structuredClone(binding); const digest = await sha(copy); check(digest === expectedDigest, 'consensus_digest_mismatch'); const decoded = decoder.decode(copy, expected);