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 }