lib

v1.rs (6584B)

---

 //! Frozen NIP-01 verification-v1 semantics.
 
 #[cfg(not(feature = "std"))]
 use alloc::string::String;
 
 use core::fmt;
 
 use radroots_event::contract::registry_v7::{
     ContractValidationError, EventContract,
     validate_event_contract_registry_v7 as validate_radroots_event_contract_registry_v7,
 };
 use radroots_event::envelope::EventEnvelope;
 use radroots_event::wire::v1::compute_canonical_nip01_event_id_v1;
 use secp256k1::{Message, Secp256k1, XOnlyPublicKey, schnorr::Signature};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RadrootsIdVerifiedEvent {
     event: EventEnvelope,
 }
 
 impl RadrootsIdVerifiedEvent {
     pub fn event(&self) -> &EventEnvelope {
         &self.event
     }
 
     pub fn into_event(self) -> EventEnvelope {
         self.event
     }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RadrootsSignatureVerifiedEvent {
     event: EventEnvelope,
 }
 
 impl RadrootsSignatureVerifiedEvent {
     pub fn event(&self) -> &EventEnvelope {
         &self.event
     }
 
     pub fn into_event(self) -> EventEnvelope {
         self.event
     }
 }
 
 /// A NIP-01 verified event whose registry-selected contract shape is valid.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RadrootsContractValidatedEvent {
     verified_event: RadrootsSignatureVerifiedEvent,
     contract: &'static EventContract,
 }
 
 impl RadrootsContractValidatedEvent {
     pub fn verified_event(&self) -> &RadrootsSignatureVerifiedEvent {
         &self.verified_event
     }
 
     pub fn event(&self) -> &EventEnvelope {
         self.verified_event.event()
     }
 
     pub fn contract(&self) -> &'static EventContract {
         self.contract
     }
 
     pub fn contract_id(&self) -> &'static str {
         self.contract.id
     }
 
     pub fn into_verified_event(self) -> RadrootsSignatureVerifiedEvent {
         self.verified_event
     }
 
     pub fn into_event(self) -> EventEnvelope {
         self.verified_event.into_event()
     }
 }
 
 #[non_exhaustive]
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum RadrootsNip01VerificationError {
     MalformedEnvelope,
     KindOutOfRange { kind: u32 },
     IdMismatch { expected: String, actual: String },
     SignatureInvalid,
 }
 
 impl RadrootsNip01VerificationError {
     pub const fn code(&self) -> &'static str {
         match self {
             Self::MalformedEnvelope => "malformed_envelope",
             Self::KindOutOfRange { .. } => "kind_out_of_range",
             Self::IdMismatch { .. } => "id_mismatch",
             Self::SignatureInvalid => "signature_invalid",
         }
     }
 }
 
 impl fmt::Display for RadrootsNip01VerificationError {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::MalformedEnvelope => formatter.write_str("malformed NIP-01 event envelope"),
             Self::KindOutOfRange { kind } => {
                 write!(formatter, "NIP-01 event kind {kind} exceeds {}", u16::MAX)
             }
             Self::IdMismatch { expected, actual } => {
                 write!(
                     formatter,
                     "NIP-01 event id mismatch: expected {expected}, got {actual}"
                 )
             }
             Self::SignatureInvalid => formatter.write_str("invalid NIP-01 event signature"),
         }
     }
 }
 
 #[cfg(feature = "std")]
 impl std::error::Error for RadrootsNip01VerificationError {}
 
 pub fn verify_event_id(
     event: EventEnvelope,
 ) -> Result<RadrootsIdVerifiedEvent, RadrootsNip01VerificationError> {
     verify_event_id_v1(event)
 }
 
 /// Verifies the canonical identifier with reconciliation-v1 semantics.
 pub fn verify_event_id_v1(
     event: EventEnvelope,
 ) -> Result<RadrootsIdVerifiedEvent, RadrootsNip01VerificationError> {
     u16::try_from(event.kind_u32()).map_err(|_| {
         RadrootsNip01VerificationError::KindOutOfRange {
             kind: event.kind_u32(),
         }
     })?;
     let expected = compute_canonical_nip01_event_id_v1(
         &event.author().to_hex(),
         event.created_at_u64(),
         event.kind_u32(),
         &event.tags_as_vec(),
         event.content(),
     )
     .map_err(|_| RadrootsNip01VerificationError::MalformedEnvelope)?;
     if event.id() != &expected {
         return Err(RadrootsNip01VerificationError::IdMismatch {
             expected: expected.to_hex(),
             actual: event.id_hex(),
         });
     }
     Ok(RadrootsIdVerifiedEvent { event })
 }
 
 pub fn verify_event_signature(
     event: RadrootsIdVerifiedEvent,
 ) -> Result<RadrootsSignatureVerifiedEvent, RadrootsNip01VerificationError> {
     verify_event_signature_v1(event)
 }
 
 /// Verifies the Schnorr signature with reconciliation-v1 semantics.
 pub fn verify_event_signature_v1(
     event: RadrootsIdVerifiedEvent,
 ) -> Result<RadrootsSignatureVerifiedEvent, RadrootsNip01VerificationError> {
     let public_key = XOnlyPublicKey::from_slice(event.event.author().as_bytes())
         .map_err(|_| RadrootsNip01VerificationError::MalformedEnvelope)?;
     let signature = Signature::from_slice(event.event.sig().as_bytes())
         .map_err(|_| RadrootsNip01VerificationError::MalformedEnvelope)?;
     let message = Message::from_digest(*event.event.id().as_bytes());
     Secp256k1::verification_only()
         .verify_schnorr(&signature, &message, &public_key)
         .map_err(|_| RadrootsNip01VerificationError::SignatureInvalid)?;
     Ok(RadrootsSignatureVerifiedEvent { event: event.event })
 }
 
 /// Verifies the canonical NIP-01 identifier and Schnorr signature in order.
 pub fn verify_nip01_event(
     event: EventEnvelope,
 ) -> Result<RadrootsSignatureVerifiedEvent, RadrootsNip01VerificationError> {
     verify_nip01_event_v1(event)
 }
 
 /// Verifies a NIP-01 event with the behavior frozen for reconciliation v1.
 pub fn verify_nip01_event_v1(
     event: EventEnvelope,
 ) -> Result<RadrootsSignatureVerifiedEvent, RadrootsNip01VerificationError> {
     verify_event_signature_v1(verify_event_id_v1(event)?)
 }
 
 /// Applies full registry contract-shape validation to an already verified event.
 pub fn validate_event_contract(
     event: RadrootsSignatureVerifiedEvent,
 ) -> Result<RadrootsContractValidatedEvent, ContractValidationError> {
     validate_event_contract_registry_v7(event)
 }
 
 /// Applies the immutable registry-v7 contract-shape validation boundary.
 pub fn validate_event_contract_registry_v7(
     event: RadrootsSignatureVerifiedEvent,
 ) -> Result<RadrootsContractValidatedEvent, ContractValidationError> {
     let contract = validate_radroots_event_contract_registry_v7(event.event())?;
     Ok(RadrootsContractValidatedEvent {
         verified_event: event,
         contract,
     })
 }
 
 #[cfg(test)]
 mod tests;