FROST Quorum

use chio_core_types::{sha256_hex, Keypair};
use chio_federation::frost::*;
use chio_federation_authority::*;
use rand_core::OsRng;
use std::collections::BTreeMap;

fn ceremony_and_roster() -> Result<
    (
        FrostRosterV1,
        FrostAuthorizationBodyV1,
        Vec<FrostCeremonyCompletion>,
    ),
    Box<dyn std::error::Error>,
> {
    let registration = frost_action_registration(FrostAuthorizationDomain::SettleCommitment)
        .ok_or("unregistered action")?;
    let participant_ids: Vec<_> = (1..=registration.quorum_m)
        .map(|i| format!("operator-{i}"))
        .collect();
    let keys: Vec<_> = participant_ids
        .iter()
        .map(|_| Keypair::generate())
        .collect();
    let participants: Vec<_> = participant_ids
        .iter()
        .zip(&keys)
        .map(|(id, key)| FrostCeremonyParticipant {
            participant_id: id.clone(),
            transport_key_id: format!("{id}.transport"),
            transport_public_key: key.public_key(),
        })
        .collect();
    let configs: Vec<_> = participant_ids
        .iter()
        .map(|id| FrostCeremonyConfig {
            scope_id: "settlement.atlantic.v1".into(),
            key_epoch: 1,
            threshold: registration.quorum_n,
            predecessor_roster_digest: None,
            participants: participants.clone(),
            local_participant_id: id.clone(),
        })
        .collect();
    // Each participant holds its own secret. Only packages cross these boundaries.
    let mut round1 = Vec::new();
    let mut secrets1 = Vec::new();
    for (config, key) in configs.iter().zip(&keys) {
        let transition = begin_frost_ceremony(config, key, &mut OsRng)?;
        round1.push(transition.package);
        secrets1.push(transition.secret);
    }
    let mut round2 = Vec::new();
    let mut secrets2 = Vec::new();
    for ((config, key), secret) in configs.iter().zip(&keys).zip(secrets1) {
        let transition = advance_frost_ceremony(config, key, secret, &round1)?;
        round2.extend(transition.packages);
        secrets2.push(transition.secret);
    }
    let mut completed = Vec::new();
    for (config, secret) in configs.iter().zip(secrets2) {
        completed.push(complete_frost_ceremony(config, secret, &round1, &round2)?);
    }
    assert!(completed
        .windows(2)
        .all(|pair| pair[0].group_public_key == pair[1].group_public_key));
    let roster_authority = Keypair::generate();
    let mut roster = FrostRosterV1 {
        schema: CHIO_FROST_ROSTER_SCHEMA.to_string(),
        roster_id: String::new(),
        roster_digest: String::new(),
        authority_scope: registration.quorum_scope.to_string(),
        scope_id: "settlement.atlantic.v1".to_string(),
        allowed_domains: vec![FrostAuthorizationDomain::SettleCommitment],
        key_epoch: 1,
        threshold: registration.quorum_n,
        participant_count: registration.quorum_m,
        participants: participant_ids
            .iter()
            .map(|participant_id| FrostParticipantV1 {
                participant_id: participant_id.clone(),
                verification_share: completed[0].verification_shares[participant_id].clone(),
            })
            .collect(),
        group_public_key: completed[0].group_public_key.clone(),
        suite_id: FROST_ED25519_SHA512_SUITE_ID.to_string(),
        key_origin: FrostRosterKeyOrigin::DistributedDkg,
        ceremony_transcript_digest: completed[0].transcript_digest.clone(),
        predecessor_roster_digest: None,
        valid_from: swarm_authority_examples::now_ms() / 1000 - 1,
        valid_until: swarm_authority_examples::now_ms() / 1000 + 60,
        roster_authority_key_id: "roster-authority.v1".to_string(),
        roster_authority_signature: String::new(),
    };
    roster.roster_id = roster
        .recompute_roster_id()
        .unwrap_or_else(|error| panic!("roster id: {error}"));
    roster.roster_authority_signature = roster_authority
        .sign(
            &roster
                .signing_bytes()
                .unwrap_or_else(|error| panic!("roster bytes: {error}")),
        )
        .to_hex();
    roster.roster_digest = roster
        .recompute_roster_digest()
        .unwrap_or_else(|error| panic!("roster digest: {error}"));
    let action = FrostActionPreimageV1::SettleCommitment(FrostSettleCommitmentActionV1 {
        schema: CHIO_FROST_SETTLE_COMMITMENT_ACTION_SCHEMA.to_string(),
        settlement_body_digest: "94".repeat(32),
        payer_id: "payer-1".to_string(),
        payee_id: "payee-1".to_string(),
        amount_base_units: "100".to_string(),
        asset_id: "usd.test".to_string(),
        operation_id: "settlement-operation-1".to_string(),
        rail_idempotency_key: "rail-settlement-operation-1".to_string(),
        resource_version: 1,
        resource_fence: 7,
    });
    let mut body = FrostAuthorizationBodyV1 {
        schema: CHIO_FROST_AUTHORIZATION_BODY_SCHEMA.to_string(),
        authorization_id: String::new(),
        domain: FrostAuthorizationDomain::SettleCommitment,
        ladder_action_class: registration.ladder_action_class.to_string(),
        ladder_contract_digest: registration
            .ladder_contract_digest()
            .unwrap_or_else(|error| panic!("ladder digest: {error}")),
        quorum_n: registration.quorum_n,
        quorum_m: registration.quorum_m,
        quorum_scope: registration.quorum_scope.to_string(),
        scope_id: roster.scope_id.clone(),
        resource_id: "settlement-operation-1".to_string(),
        resource_version: 1,
        resource_fence: 7,
        action_digest: action
            .action_digest()
            .unwrap_or_else(|error| panic!("action digest: {error}")),
        roster_digest: roster.roster_digest.clone(),
        key_epoch: roster.key_epoch,
        issued_at: swarm_authority_examples::now_ms() / 1000 - 1,
        expires_at: swarm_authority_examples::now_ms() / 1000 + 60,
    };
    body.authorization_id = body
        .recompute_authorization_id()
        .unwrap_or_else(|error| panic!("authorization id: {error}"));
    Ok((roster, body, completed))
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (roster, body, completed) = ceremony_and_roster()?;
    println!(
        "DKG complete: {} participants; threshold {}",
        roster.participant_count, roster.threshold
    );
    let mut commitments = BTreeMap::new();
    let mut preparations = BTreeMap::new();
    for (participant, completion) in roster.participants.iter().zip(&completed) {
        let prepared = prepare_frost_signer(&completion.key_package, &mut OsRng)?;
        validate_frost_signing_commitment(
            &roster,
            &participant.participant_id,
            prepared.signer_identifier_bytes(),
            prepared.commitment_bytes(),
        )?;
        commitments.insert(
            participant.participant_id.clone(),
            prepared.commitment_bytes().to_vec(),
        );
        preparations.insert(participant.participant_id.clone(), prepared);
    }
    let package = build_frost_signing_package(&body, &roster, &commitments)?;
    let message_digest = sha256_hex(&body.signing_bytes()?);
    let mut shares = BTreeMap::new();
    for id in package.participant_ids() {
        let index = roster
            .participants
            .iter()
            .position(|p| &p.participant_id == id)
            .ok_or("unknown signer")?;
        let prepared = preparations.remove(id).ok_or("missing nonce")?;
        // Consuming this nonce prevents accidental reuse within this process.
        let share = create_frost_signature_share(
            &completed[index].key_package,
            prepared.into_nonce_secret(),
            package.bytes(),
            &message_digest,
            &commitments[id],
        )?;
        verify_frost_signature_share(&body, &roster, package.bytes(), id, share.share_bytes())?;
        shares.insert(id.clone(), share.share_bytes().to_vec());
    }
    let authorization = aggregate_frost_authorization(&body, &roster, package.bytes(), &shares)?;
    println!("aggregate authorization: {} shares", shares.len());
    std::fs::write(
        "frost-authorization.json",
        serde_json::to_vec_pretty(&authorization)?,
    )?;
    let mut changed = body.clone();
    changed.resource_fence += 1;
    changed.authorization_id = changed.recompute_authorization_id()?;
    let error = aggregate_frost_authorization(&changed, &roster, package.bytes(), &shares)
        .expect_err("changed action must refuse");
    println!("changed resource fence: {error}");
    Ok(())
}