open-standards/smart-byte/smart-byte-rs/crates/smart-byte-state/src/demo.rs

//! A deterministic workload for simulations and tests: one issuer, a ring of
//! holders, and the bytes the issuer mints to them passed around the ring.
//!
//! Frame 0 carries every party's inception and the mints; each later frame
//! moves every byte one holder along. Keys derive from labels, so the same
//! workload produces the same inputs — and so the same state hashes — on
//! every run.

use smart_byte_core::keys::IndexedSignature;
use smart_byte_core::ownership::Transition;
use smart_byte_core::{Aid, Blake3Hash, Cargo, Envelope, JouleCost, Said, Signer, SigningKey};
use smart_byte_keri_witness::{Controller, KeyEvent, KeyPair, Threshold};

use crate::input::Input;
use crate::state::State;

/// The cargo type the demo issuer is registered for: USD.
pub const USD: u64 = 1;

/// The demo cluster's identifier.
pub fn cluster() -> Said {
    Said::hash(b"smart-byte demo cluster")
}

fn key(label: &str) -> KeyPair {
    let seed = Said::hash(format!("smart-byte demo key {label}").as_bytes()).0;
    KeyPair::from_signing(SigningKey::from_bytes(&seed))
}

/// A party: its controller (whose current keys sign) and its inception, as
/// an input.
struct Party {
    controller: Controller,
    inception: Vec<u8>,
}

impl Party {
    fn new(label: &str) -> Self {
        let (controller, icp) = Controller::incept(
            vec![key(&format!("{label}-0"))],
            vec![key(&format!("{label}-1"))],
            Threshold(1),
            Threshold(1),
            vec![],
            Threshold(0),
        )
        .expect("a one-key inception");
        let event = KeyEvent::Inception(icp);
        let signatures: Vec<IndexedSignature> = controller
            .sign_event(&event)
            .expect("the controller signs its inception")
            .into_iter()
            .map(|(index, signature)| IndexedSignature {
                index: u64::from(index),
                signature,
            })
            .collect();
        Party {
            inception: Input::key_event(&event, &signatures),
            controller,
        }
    }

    fn signer(&self) -> Signer {
        self.controller.signer()
    }

    fn aid(&self) -> Aid {
        self.controller.aid
    }
}

/// A byte in the workload: its identity, owner and history hash.
struct Held {
    identity: Said,
    owner: usize,
    history: Blake3Hash,
}

/// The workload.
pub struct Workload {
    issuer: Party,
    holders: Vec<Party>,
    bytes: Vec<Held>,
    mints: Vec<Vec<u8>>,
}

impl Workload {
    /// One issuer, `holders` holders, and `per_holder` USD bytes minted to
    /// each.
    pub fn new(holders: usize, per_holder: usize) -> Self {
        let issuer = Party::new("issuer");
        let holders: Vec<Party> = (0..holders.max(1))
            .map(|i| Party::new(&format!("holder-{i}")))
            .collect();
        let mut bytes = Vec::new();
        let mut mints = Vec::new();
        for (owner, holder) in holders.iter().enumerate() {
            for k in 0..per_holder {
                let nonce: [u8; 16] =
                    Said::hash(format!("smart-byte demo nonce {owner}-{k}").as_bytes()).0[..16]
                        .try_into()
                        .expect("sixteen bytes");
                let micros = 1_000_000 * (1 + (owner * per_holder + k) as i64);
                let byte = Envelope::issue(
                    &issuer.signer(),
                    holder.aid(),
                    nonce,
                    Cargo::usd_micros(micros),
                    JouleCost::default(),
                );
                mints.push(Input::mint(&byte.provenance));
                bytes.push(Held {
                    identity: byte.identity(),
                    owner,
                    history: byte.identity().0,
                });
            }
        }
        Workload {
            issuer,
            holders,
            bytes,
            mints,
        }
    }

    /// The genesis state of the demo cluster: the issuer registered for USD,
    /// no peers, and no governance delay.
    pub fn genesis(&self) -> State {
        State::genesis(cluster(), [(self.issuer.aid(), USD)], [], 0)
    }

    /// Frame `frame`'s inputs. Frame 0 incepts every party and mints; each
    /// later frame moves every byte to the next holder. Frames must be taken
    /// in order.
    pub fn frame(&mut self, frame: u64) -> Vec<Vec<u8>> {
        if frame == 0 {
            let mut inputs = vec![self.issuer.inception.clone()];
            inputs.extend(self.holders.iter().map(|h| h.inception.clone()));
            inputs.extend(self.mints.iter().cloned());
            return inputs;
        }
        let ring = self.holders.len();
        self.bytes
            .iter_mut()
            .map(|held| {
                let to = (held.owner + 1) % ring;
                let t = Transition::sign(
                    &self.holders[held.owner].signer(),
                    &held.identity,
                    held.history,
                    self.holders[to].aid(),
                    frame,
                );
                held.owner = to;
                held.history = t.next_history_hash();
                Input::transfer(&held.identity, &t)
            })
            .collect()
    }
}