lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

receipt_issuance.rs (4334B)


      1 use super::*;
      2 #[path = "receipt_recovery.rs"]
      3 mod recovery;
      4 use core::cell::Cell;
      5 use radroots_nostr::{
      6     key::parse_secret_key,
      7     signing::{LocalSigner, OsNonceSource},
      8 };
      9 use radroots_signing::{
     10     issuance::{OutcomeKind, SigningIntent},
     11     provider::{ParticipantProvider, ProviderCall},
     12     request::CancellationSignal,
     13 };
     14 use radroots_storage::command::{
     15     ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, SigningAttempt,
     16 };
     17 thread_local! {static CALLS:Cell<usize>=const {Cell::new(0)};static MISSING:Cell<bool>=const {Cell::new(false)};}
     18 fn signer_clock() -> Result<u64, radroots_signing::Error> {
     19     let count = CALLS.with(|calls| {
     20         let value = calls.get() + 1;
     21         calls.set(value);
     22         value
     23     });
     24     if count > 1 && MISSING.with(Cell::get) {
     25         Err(radroots_signing::Error::new(
     26             radroots_signing::error::Kind::InternalError,
     27         ))
     28     } else {
     29         Ok(100_000)
     30     }
     31 }
     32 pub(super) fn selection(
     33     binding: &WorkspaceBinding,
     34     prepared: &PreparedOperation,
     35     plan_digest: [u8; 32],
     36     recipient: PublicKey,
     37 ) -> ClaimAttemptRequest {
     38     ClaimAttemptRequest::new(
     39         binding.clone(),
     40         prepared.identity().operation_id(),
     41         prepared.identity().command_digest(),
     42         plan_digest,
     43         recipient,
     44     )
     45 }
     46 pub(super) fn claim(outcome: ClaimAttemptOutcome) -> SigningAttempt {
     47     match outcome {
     48         ClaimAttemptOutcome::Claimed(value) => value,
     49         _ => panic!("first actual claim must confirm its commit"),
     50     }
     51 }
     52 pub(super) async fn prepare(
     53     fixture: &Fixture,
     54     store: &NativeWorkspace,
     55     binding: &WorkspaceBinding,
     56     proof: &AttachmentProof,
     57     id: u8,
     58     large: bool,
     59 ) -> (PreparedOperation, [u8; 32], Vec<PublicKey>) {
     60     let mut captured = peer_request(binding, id);
     61     if large {
     62         let mut value: serde_json::Value =
     63             serde_json::from_slice(captured.command().protected_wire()).unwrap();
     64         value["input"]["text"] = "\0".repeat(3500).into();
     65         captured = AdmissionRequest::from_protected_wire(
     66             binding.clone(),
     67             &serde_json::to_vec(&value).unwrap(),
     68         )
     69         .unwrap();
     70     }
     71     let prepared = committed(
     72         store
     73             .admit_command_and_hold(captured, copy(proof))
     74             .await
     75             .unwrap(),
     76     );
     77     let plan = plan(
     78         prepared.request().chat_command().unwrap(),
     79         100,
     80         "native-issuance",
     81     );
     82     let digest = *plan.digest();
     83     let recipients = plan.seals().iter().map(|seal| seal.recipient()).collect();
     84     bound(
     85         store
     86             .bind_signing_intents(binding.clone(), (plan).into(), copy(proof))
     87             .await
     88             .unwrap(),
     89     );
     90     let _ = fixture;
     91     (prepared, digest, recipients)
     92 }
     93 pub(super) async fn obtain(attempt: &SigningAttempt, missing: bool) -> ArtifactEvidence {
     94     CALLS.with(|calls| calls.set(0));
     95     MISSING.with(|value| value.set(missing));
     96     // Published synthetic key in a qualified local provider, isolated from all host custody.
     97     let signer = LocalSigner::with_clock(
     98         parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001")
     99             .unwrap(),
    100         signer_clock,
    101     )
    102     .unwrap()
    103     .with_nonce_source(Arc::new(OsNonceSource));
    104     let observed = signer.provider_state().await.unwrap();
    105     assert_eq!(observed.identity(), key());
    106     assert_eq!(
    107         observed.exact_issuance(),
    108         Some(radroots_signing::recovery::ReplayCapability::NonReplayable)
    109     );
    110     let intent = SigningIntent::from_chat_seal(
    111         attempt.binding().operation_id(),
    112         attempt.bound_plan().prepared().identity().command_digest(),
    113         attempt.seal().unwrap(),
    114         ProviderCall::new(key(), attempt.deadline_unix_ms(), CancellationSignal::new()),
    115     )
    116     .unwrap();
    117     assert_eq!(intent.binding(), attempt.binding());
    118     let outcome = signer.sign_exact(intent).await;
    119     assert_eq!(outcome.binding(), attempt.binding());
    120     let (_, kind) = outcome.into_parts();
    121     let OutcomeKind::Obtained(artifact) = kind else {
    122         panic!("actual local exact signing must obtain")
    123     };
    124     assert_eq!(artifact.observed_at_unix_ms().is_none(), missing);
    125     artifact.with_json(|raw| {
    126         ArtifactEvidence::verify(attempt, raw, artifact.observed_at_unix_ms()).unwrap()
    127     })
    128 }