commonware-log 2026.5.0

Commit to a secret log and agree to its hash.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use super::{
    ingress::{Mailbox, Message},
    reporter::Reporter,
    Config, Scheme,
};
use commonware_actor::mailbox::{self, Receiver};
use commonware_cryptography::Hasher;
use commonware_formatting::hex;
use commonware_runtime::{spawn_cell, ContextCell, Handle, Metrics, Spawner};
use rand::Rng;
use tracing::info;

/// Application actor.
pub struct Application<R: Rng + Spawner + Metrics, H: Hasher> {
    context: ContextCell<R>,
    hasher: H,
    mailbox: Receiver<Message<H::Digest>>,
}

impl<R: Rng + Spawner + Metrics, H: Hasher> Application<R, H> {
    /// Create a new application actor.
    #[allow(clippy::type_complexity)]
    pub fn new(
        context: R,
        config: Config<H>,
    ) -> (Self, Scheme, Reporter<H::Digest>, Mailbox<H::Digest>) {
        let (sender, receiver) = mailbox::new(context.child("mailbox"), config.mailbox_size);
        let mailbox = Mailbox::new(sender);
        let reporter = Reporter::new();
        (
            Self {
                context: ContextCell::new(context),
                hasher: config.hasher,
                mailbox: receiver,
            },
            config.scheme,
            reporter,
            mailbox,
        )
    }

    /// Run the application actor.
    pub fn start(mut self) -> Handle<()> {
        spawn_cell!(self.context, self.run())
    }

    async fn run(mut self) {
        while let Some(message) = self.mailbox.recv().await {
            match message {
                Message::Propose { response } => {
                    // Generate a random message (secret to us)
                    let mut msg = vec![0; 16];
                    self.context.fill(&mut msg[..]);

                    // Hash the message
                    self.hasher.update(&msg);
                    let digest = self.hasher.finalize();
                    info!(msg = hex(&msg), payload = ?digest, "proposed");

                    // Send digest to consensus
                    let _ = response.send(digest);
                }
                Message::Verify { response } => {
                    // Digests are already verified by consensus, so we don't need to check they are valid.
                    //
                    // If we linked payloads to their parent, we would verify
                    // the parent included in the payload matches the provided context.
                    let _ = response.send(true);
                }
            }
        }
    }
}