myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

nip46_work.rs (47349B)


      1 //! Transaction-free NIP-46 decryption, method admission, and provider work.
      2 
      3 use core::fmt;
      4 use std::error::Error;
      5 
      6 use nostr::UnsignedEvent as NostrUnsignedEvent;
      7 use radroots_nostr_connect::{
      8     message::{Request, RequestMessage, UnsignedEvent as ConnectUnsignedEvent},
      9     server::required_permission,
     10 };
     11 use sha2::{Digest, Sha256};
     12 
     13 use crate::{
     14     MycConnectionAdmissionPolicy, MycConnectionAdmissionRequest, MycConnectionNonce,
     15     MycConnectionPermission, MycConnectionPermissionSet, MycConnectionPolicyGeneration,
     16     MycConnectionRecord, MycConnectionStatus, MycConnectionTimeUnixMs, MycNip46AdmissionLimits,
     17     MycNip46EncryptionContext, MycProviderBinding, MycProviderContract, MycProviderCorrelationId,
     18     MycProviderDeadlineUnixMs, MycProviderNip44Version, MycProviderOperation,
     19     MycProviderOperationId, MycProviderOperationInput, MycProviderPublicIdentity, MycProviderRole,
     20     MycRateRelayId, MycReplayBoundNip46Request, MycRequestReceivedAtUnixMs,
     21     MycSignerOperationNonce, MycSignerRequest, MycSignerRequestMethod, MycSignerRequestRecord,
     22     MycVerifiedNip46Event, MycVerifiedProviderResponse, admit_myc_nip46_request,
     23     bind_myc_nip46_replay, verify_myc_nip46_request,
     24 };
     25 
     26 const DECRYPT_OPERATION_ID_DOMAIN: &[u8] = b"radroots.myc.nip46.decrypt.operation.v1\0";
     27 const DECRYPT_CORRELATION_ID_DOMAIN: &[u8] = b"radroots.myc.nip46.decrypt.correlation.v1\0";
     28 
     29 /// Stable source-free Step 145 failure classification.
     30 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
     31 pub enum MycNip46WorkErrorKind {
     32     InvalidBinding,
     33     DecryptionRejected,
     34     UnsupportedMethod,
     35     PermissionDenied,
     36     ConnectionExpired,
     37     ProviderWorkRejected,
     38 }
     39 
     40 impl MycNip46WorkErrorKind {
     41     /// Returns the stable machine-facing safe code.
     42     #[must_use]
     43     pub const fn code(self) -> &'static str {
     44         match self {
     45             Self::InvalidBinding => "nip46_work_binding_invalid",
     46             Self::DecryptionRejected => "nip46_decryption_rejected",
     47             Self::UnsupportedMethod => "nip46_method_unsupported",
     48             Self::PermissionDenied => "nip46_permission_denied",
     49             Self::ConnectionExpired => "nip46_connection_inactive",
     50             Self::ProviderWorkRejected => "nip46_provider_work_rejected",
     51         }
     52     }
     53 
     54     const fn message(self) -> &'static str {
     55         match self {
     56             Self::InvalidBinding => "NIP-46 work binding is invalid",
     57             Self::DecryptionRejected => "NIP-46 decrypted request was rejected",
     58             Self::UnsupportedMethod => "NIP-46 method is unsupported",
     59             Self::PermissionDenied => "NIP-46 permission was denied",
     60             Self::ConnectionExpired => "NIP-46 connection is not active",
     61             Self::ProviderWorkRejected => "NIP-46 provider work was rejected",
     62         }
     63     }
     64 }
     65 
     66 /// One redacted source-free Step 145 failure.
     67 #[derive(Clone, Copy, PartialEq, Eq)]
     68 pub struct MycNip46WorkError {
     69     kind: MycNip46WorkErrorKind,
     70 }
     71 
     72 impl MycNip46WorkError {
     73     /// Returns the stable failure classification.
     74     #[must_use]
     75     pub const fn kind(self) -> MycNip46WorkErrorKind {
     76         self.kind
     77     }
     78 
     79     /// Returns the stable machine-facing safe code.
     80     #[must_use]
     81     pub const fn code(self) -> &'static str {
     82         self.kind.code()
     83     }
     84 }
     85 
     86 impl fmt::Debug for MycNip46WorkError {
     87     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     88         formatter
     89             .debug_struct("MycNip46WorkError")
     90             .field("kind", &self.kind)
     91             .finish()
     92     }
     93 }
     94 
     95 impl fmt::Display for MycNip46WorkError {
     96     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     97         formatter.write_str(self.kind.message())
     98     }
     99 }
    100 
    101 impl Error for MycNip46WorkError {}
    102 
    103 const fn work_error(kind: MycNip46WorkErrorKind) -> MycNip46WorkError {
    104     MycNip46WorkError { kind }
    105 }
    106 
    107 /// Provider-bound work that must complete before plaintext request admission.
    108 pub struct MycNip46DecryptWork {
    109     event: MycVerifiedNip46Event,
    110     operation: MycProviderOperation,
    111 }
    112 
    113 impl MycNip46DecryptWork {
    114     /// Returns the exact transport-provider operation for external execution.
    115     #[must_use]
    116     pub const fn operation(&self) -> &MycProviderOperation {
    117         &self.operation
    118     }
    119 
    120     /// Binds an independently verified provider result to the exact event.
    121     pub fn complete(
    122         self,
    123         response: MycVerifiedProviderResponse,
    124         limits: MycNip46AdmissionLimits,
    125     ) -> Result<MycDecryptedNip46Request, MycNip46WorkError> {
    126         let expected_capability = self.operation.input().capability();
    127         if response.operation_id() != self.operation.operation_id()
    128             || response.correlation_id() != self.operation.correlation_id()
    129             || response.instance() != self.operation.instance()
    130             || response.role() != MycProviderRole::Transport
    131             || response.capability() != expected_capability
    132             || response.nip44_version() != self.operation.input().nip44_version()
    133             || !response.matches_operation(&self.operation)
    134         {
    135             return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    136         }
    137         let plaintext = response
    138             .protected_payload()
    139             .ok_or_else(|| work_error(MycNip46WorkErrorKind::DecryptionRejected))?;
    140         let bounded = admit_myc_nip46_request(limits, plaintext)
    141             .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?;
    142         let request = verify_myc_nip46_request(bounded)
    143             .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?;
    144         let replay = bind_myc_nip46_replay(self.event, request)
    145             .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?;
    146         Ok(MycDecryptedNip46Request { replay })
    147     }
    148 }
    149 
    150 impl fmt::Debug for MycNip46DecryptWork {
    151     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    152         formatter
    153             .debug_struct("MycNip46DecryptWork")
    154             .field("event", &"[redacted]")
    155             .field("operation", &self.operation)
    156             .finish()
    157     }
    158 }
    159 
    160 /// Constructs the exact transport-provider decryption work for one verified event.
    161 pub fn prepare_myc_nip46_decrypt_work(
    162     event: MycVerifiedNip46Event,
    163     transport: &MycProviderBinding,
    164     deadline: MycProviderDeadlineUnixMs,
    165 ) -> Result<MycNip46DecryptWork, MycNip46WorkError> {
    166     if transport.role() != MycProviderRole::Transport
    167         || transport.expected_identity() != event.receiver_public_key()
    168     {
    169         return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    170     }
    171     let operation_id = MycProviderOperationId::from_bytes(derive_decrypt_identity(
    172         DECRYPT_OPERATION_ID_DOMAIN,
    173         event.event_id().as_bytes(),
    174     ));
    175     let correlation_id = MycProviderCorrelationId::from_bytes(derive_decrypt_identity(
    176         DECRYPT_CORRELATION_ID_DOMAIN,
    177         event.event_id().as_bytes(),
    178     ));
    179     let peer = MycProviderPublicIdentity::new(event.client_public_key().as_hex())
    180         .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding))?;
    181     let input = match event.encryption_context() {
    182         MycNip46EncryptionContext::Nip04 => {
    183             MycProviderOperationInput::nip04_decrypt(peer, event.encrypted_content().as_bytes())
    184         }
    185         MycNip46EncryptionContext::Nip44V2 => MycProviderOperationInput::nip44_decrypt(
    186             peer,
    187             MycProviderNip44Version::V2,
    188             event.encrypted_content().as_bytes(),
    189         ),
    190     }
    191     .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    192     let operation =
    193         MycProviderOperation::new(transport, operation_id, correlation_id, deadline, input)
    194             .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    195     Ok(MycNip46DecryptWork { event, operation })
    196 }
    197 
    198 fn derive_decrypt_identity(domain: &[u8], event_id: &[u8; 32]) -> [u8; 32] {
    199     let mut hasher = Sha256::new();
    200     hasher.update(domain);
    201     hasher.update(event_id);
    202     hasher.finalize().into()
    203 }
    204 
    205 /// Non-forgeable proof that the typed request came from the exact decrypt work.
    206 pub struct MycDecryptedNip46Request {
    207     replay: MycReplayBoundNip46Request,
    208 }
    209 
    210 impl fmt::Debug for MycDecryptedNip46Request {
    211     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    212         formatter.write_str("MycDecryptedNip46Request([redacted])")
    213     }
    214 }
    215 
    216 /// Exact request ready for durable admission but not provider execution.
    217 pub struct MycPreparedNip46Request {
    218     signer_request: MycSignerRequest,
    219     request: Request,
    220     encryption_context: MycNip46EncryptionContext,
    221 }
    222 
    223 impl MycPreparedNip46Request {
    224     /// Returns the exact input for the short durable request-admission transaction.
    225     #[must_use]
    226     pub const fn signer_request(&self) -> &MycSignerRequest {
    227         &self.signer_request
    228     }
    229 
    230     /// Returns the exact closed method admitted before persistence.
    231     #[must_use]
    232     pub const fn method(&self) -> MycSignerRequestMethod {
    233         self.signer_request.method()
    234     }
    235 }
    236 
    237 impl fmt::Debug for MycPreparedNip46Request {
    238     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    239         formatter
    240             .debug_struct("MycPreparedNip46Request")
    241             .field("method", &self.method())
    242             .field("request", &"[redacted]")
    243             .finish()
    244     }
    245 }
    246 
    247 /// Converts one proven decrypted request into exact durable-admission input.
    248 pub fn prepare_myc_nip46_request(
    249     decrypted: MycDecryptedNip46Request,
    250     nonce: MycSignerOperationNonce,
    251     received_at: MycRequestReceivedAtUnixMs,
    252 ) -> Result<MycPreparedNip46Request, MycNip46WorkError> {
    253     let encryption_context = decrypted.replay.encryption_context();
    254     let method = MycSignerRequestMethod::parse(decrypted.replay.method())
    255         .ok_or_else(|| work_error(MycNip46WorkErrorKind::UnsupportedMethod))?;
    256     let message: RequestMessage = serde_json::from_slice(decrypted.replay.canonical_request())
    257         .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding))?;
    258     if message.payload().method().as_str() != method.as_str()
    259         || message
    260             .request_id()
    261             .map(|request_id| request_id.as_str() != decrypted.replay.request_id().as_str())
    262             .unwrap_or(true)
    263     {
    264         return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    265     }
    266     let signer_request = MycSignerRequest::new(
    267         decrypted.replay.client_public_key().clone(),
    268         decrypted.replay.request_id().clone(),
    269         decrypted.replay.event_id(),
    270         method,
    271         decrypted.replay.request_digest(),
    272         nonce,
    273         received_at,
    274     );
    275     Ok(MycPreparedNip46Request {
    276         signer_request,
    277         request: message.request,
    278         encryption_context,
    279     })
    280 }
    281 
    282 /// Exact Step 145 work classification.
    283 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    284 pub enum MycNip46WorkKind {
    285     Connect,
    286     Local,
    287     Provider,
    288 }
    289 
    290 enum Nip46WorkPayload {
    291     Connect {
    292         client: crate::MycNip46ClientPublicKey,
    293         permissions: MycConnectionPermissionSet,
    294     },
    295     Local,
    296     Provider(MycProviderOperation),
    297 }
    298 
    299 /// Sealed request work constructed only after durable request admission.
    300 pub struct MycNip46Work {
    301     request: MycSignerRequestRecord,
    302     connection: Option<MycConnectionRecord>,
    303     method: MycSignerRequestMethod,
    304     encryption_context: MycNip46EncryptionContext,
    305     payload: Nip46WorkPayload,
    306 }
    307 
    308 impl MycNip46Work {
    309     #[cfg(all(test, any(target_os = "linux", target_os = "macos")))]
    310     pub(crate) fn local_for_test(
    311         request: MycSignerRequestRecord,
    312         connection: MycConnectionRecord,
    313         method: MycSignerRequestMethod,
    314     ) -> Self {
    315         assert!(matches!(
    316             method,
    317             MycSignerRequestMethod::GetPublicKey
    318                 | MycSignerRequestMethod::GetSessionCapability
    319                 | MycSignerRequestMethod::Ping
    320                 | MycSignerRequestMethod::SwitchRelays
    321                 | MycSignerRequestMethod::Logout
    322         ));
    323         Self {
    324             request,
    325             connection: Some(connection),
    326             method,
    327             encryption_context: MycNip46EncryptionContext::Nip44V2,
    328             payload: Nip46WorkPayload::Local,
    329         }
    330     }
    331 
    332     /// Returns the exact admitted durable request record.
    333     #[must_use]
    334     pub const fn request_record(&self) -> &MycSignerRequestRecord {
    335         &self.request
    336     }
    337 
    338     /// Returns the exact active connection used for non-connect work.
    339     #[must_use]
    340     pub const fn connection(&self) -> Option<&MycConnectionRecord> {
    341         self.connection.as_ref()
    342     }
    343 
    344     /// Returns the exact admitted request method.
    345     #[must_use]
    346     pub const fn method(&self) -> MycSignerRequestMethod {
    347         self.method
    348     }
    349 
    350     pub(crate) const fn encryption_context(&self) -> MycNip46EncryptionContext {
    351         self.encryption_context
    352     }
    353 
    354     /// Returns the work class without exposing protected parameters.
    355     #[must_use]
    356     pub const fn kind(&self) -> MycNip46WorkKind {
    357         match &self.payload {
    358             Nip46WorkPayload::Connect { .. } => MycNip46WorkKind::Connect,
    359             Nip46WorkPayload::Local => MycNip46WorkKind::Local,
    360             Nip46WorkPayload::Provider(_) => MycNip46WorkKind::Provider,
    361         }
    362     }
    363 
    364     /// Returns the provider operation only for provider-bearing work.
    365     #[must_use]
    366     pub const fn provider_operation(&self) -> Option<&MycProviderOperation> {
    367         match &self.payload {
    368             Nip46WorkPayload::Provider(operation) => Some(operation),
    369             Nip46WorkPayload::Connect { .. } | Nip46WorkPayload::Local => None,
    370         }
    371     }
    372 
    373     /// Constructs the exact Step 144 admission request for connect work.
    374     pub fn connection_admission_request(
    375         &self,
    376         policy_generation: MycConnectionPolicyGeneration,
    377         nonce: MycConnectionNonce,
    378         observed_at: MycConnectionTimeUnixMs,
    379         authorized_until: Option<MycConnectionTimeUnixMs>,
    380         policy: MycConnectionAdmissionPolicy,
    381         relay_id: MycRateRelayId,
    382     ) -> Result<MycConnectionAdmissionRequest, MycNip46WorkError> {
    383         let Nip46WorkPayload::Connect {
    384             client,
    385             permissions,
    386         } = &self.payload
    387         else {
    388             return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    389         };
    390         MycConnectionAdmissionRequest::new(
    391             self.request.operation_id(),
    392             client.clone(),
    393             permissions.clone(),
    394             policy_generation,
    395             nonce,
    396             observed_at,
    397             authorized_until,
    398             policy,
    399             relay_id,
    400         )
    401         .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding))
    402     }
    403 }
    404 
    405 impl fmt::Debug for MycNip46Work {
    406     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    407         formatter
    408             .debug_struct("MycNip46Work")
    409             .field("method", &self.method)
    410             .field("kind", &self.kind())
    411             .field("request", &"[redacted]")
    412             .field(
    413                 "connection",
    414                 &self.connection.as_ref().map(|_| "[redacted]"),
    415             )
    416             .finish()
    417     }
    418 }
    419 
    420 /// Binds an admitted request and optional active connection to exact work.
    421 ///
    422 /// This function accepts no repository, host, transaction, provider executor,
    423 /// clock, or entropy source. Provider execution therefore starts only after
    424 /// the caller's durable request-admission transaction has ended.
    425 pub fn prepare_myc_nip46_work(
    426     prepared: MycPreparedNip46Request,
    427     record: MycSignerRequestRecord,
    428     connection: Option<MycConnectionRecord>,
    429     providers: &MycProviderContract,
    430     observed_at: MycConnectionTimeUnixMs,
    431     provider_deadline: Option<MycProviderDeadlineUnixMs>,
    432 ) -> Result<MycNip46Work, MycNip46WorkError> {
    433     let MycPreparedNip46Request {
    434         signer_request,
    435         request,
    436         encryption_context,
    437     } = prepared;
    438     if !record.matches_request(&signer_request) || observed_at.get() < record.received_at().get() {
    439         return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    440     }
    441     let method = signer_request.method();
    442     let request = match request {
    443         Request::Connect {
    444             remote_signer_public_key,
    445             secret,
    446             requested_permissions,
    447             client_metadata: _,
    448         } => {
    449             if connection.is_some() || provider_deadline.is_some() || secret.is_some() {
    450                 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    451             }
    452             let transport = transport_binding(providers)?;
    453             if remote_signer_public_key.to_hex() != transport.expected_identity().as_hex() {
    454                 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    455             }
    456             let permissions = connect_permissions(requested_permissions.as_slice())?;
    457             return Ok(MycNip46Work {
    458                 request: record,
    459                 connection: None,
    460                 method,
    461                 encryption_context,
    462                 payload: Nip46WorkPayload::Connect {
    463                     client: signer_request.client_public_key().clone(),
    464                     permissions,
    465                 },
    466             });
    467         }
    468         Request::Custom { .. } => {
    469             return Err(work_error(MycNip46WorkErrorKind::UnsupportedMethod));
    470         }
    471         request => request,
    472     };
    473 
    474     let connection = connection.ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))?;
    475     if connection.client_public_key() != signer_request.client_public_key() {
    476         return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    477     }
    478     if connection.status() != MycConnectionStatus::Active
    479         || connection
    480             .authorized_until()
    481             .is_some_and(|until| observed_at > until)
    482     {
    483         return Err(work_error(MycNip46WorkErrorKind::ConnectionExpired));
    484     }
    485     if let Some(permission) = required_permission(&request) {
    486         let permission = protocol_permission(&permission.to_string())?;
    487         if !connection.granted_permissions().contains(permission) {
    488             return Err(work_error(MycNip46WorkErrorKind::PermissionDenied));
    489         }
    490     }
    491 
    492     let payload = match request {
    493         Request::GetPublicKey
    494         | Request::GetSessionCapability
    495         | Request::Ping
    496         | Request::SwitchRelays
    497         | Request::Logout => {
    498             if provider_deadline.is_some() {
    499                 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding));
    500             }
    501             Nip46WorkPayload::Local
    502         }
    503         Request::SignEvent(event) => {
    504             let input = sign_event_input(&event, providers)?;
    505             provider_work(
    506                 providers,
    507                 &record,
    508                 observed_at,
    509                 provider_deadline,
    510                 Ok(input),
    511             )?
    512         }
    513         Request::Nip04Encrypt {
    514             public_key,
    515             plaintext,
    516         } => provider_work(
    517             providers,
    518             &record,
    519             observed_at,
    520             provider_deadline,
    521             MycProviderOperationInput::nip04_encrypt(
    522                 provider_identity(&public_key.to_hex())?,
    523                 plaintext.as_bytes(),
    524             ),
    525         )?,
    526         Request::Nip04Decrypt {
    527             public_key,
    528             ciphertext,
    529         } => provider_work(
    530             providers,
    531             &record,
    532             observed_at,
    533             provider_deadline,
    534             MycProviderOperationInput::nip04_decrypt(
    535                 provider_identity(&public_key.to_hex())?,
    536                 ciphertext.as_bytes(),
    537             ),
    538         )?,
    539         Request::Nip44Encrypt {
    540             public_key,
    541             plaintext,
    542         } => provider_work(
    543             providers,
    544             &record,
    545             observed_at,
    546             provider_deadline,
    547             MycProviderOperationInput::nip44_encrypt(
    548                 provider_identity(&public_key.to_hex())?,
    549                 MycProviderNip44Version::V2,
    550                 plaintext.as_bytes(),
    551             ),
    552         )?,
    553         Request::Nip44Decrypt {
    554             public_key,
    555             ciphertext,
    556         } => provider_work(
    557             providers,
    558             &record,
    559             observed_at,
    560             provider_deadline,
    561             MycProviderOperationInput::nip44_decrypt(
    562                 provider_identity(&public_key.to_hex())?,
    563                 MycProviderNip44Version::V2,
    564                 ciphertext.as_bytes(),
    565             ),
    566         )?,
    567         Request::Connect { .. } | Request::Custom { .. } => {
    568             return Err(work_error(MycNip46WorkErrorKind::UnsupportedMethod));
    569         }
    570     };
    571 
    572     Ok(MycNip46Work {
    573         request: record,
    574         connection: Some(connection),
    575         method,
    576         encryption_context,
    577         payload,
    578     })
    579 }
    580 
    581 fn provider_work(
    582     providers: &MycProviderContract,
    583     record: &MycSignerRequestRecord,
    584     observed_at: MycConnectionTimeUnixMs,
    585     deadline: Option<MycProviderDeadlineUnixMs>,
    586     input: Result<MycProviderOperationInput, crate::MycProviderContractError>,
    587 ) -> Result<Nip46WorkPayload, MycNip46WorkError> {
    588     let deadline = deadline.ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))?;
    589     if deadline.get() <= observed_at.get() {
    590         return Err(work_error(MycNip46WorkErrorKind::ProviderWorkRejected));
    591     }
    592     let input = input.map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    593     let operation = MycProviderOperation::new(
    594         user_binding(providers)?,
    595         MycProviderOperationId::from_bytes(*record.operation_id().as_bytes()),
    596         MycProviderCorrelationId::from_bytes(*record.correlation_id().as_bytes()),
    597         deadline,
    598         input,
    599     )
    600     .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    601     Ok(Nip46WorkPayload::Provider(operation))
    602 }
    603 
    604 fn user_binding(providers: &MycProviderContract) -> Result<&MycProviderBinding, MycNip46WorkError> {
    605     providers
    606         .binding(MycProviderRole::User)
    607         .ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))
    608 }
    609 
    610 fn transport_binding(
    611     providers: &MycProviderContract,
    612 ) -> Result<&MycProviderBinding, MycNip46WorkError> {
    613     providers
    614         .binding(MycProviderRole::Transport)
    615         .ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))
    616 }
    617 
    618 fn sign_event_input(
    619     event: &ConnectUnsignedEvent,
    620     providers: &MycProviderContract,
    621 ) -> Result<MycProviderOperationInput, MycNip46WorkError> {
    622     let canonical = event.as_json();
    623     let unsigned: NostrUnsignedEvent = serde_json::from_str(&canonical)
    624         .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    625     let reencoded = serde_json::to_vec(&unsigned)
    626         .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?;
    627     if reencoded.as_slice() != canonical.as_bytes()
    628         || unsigned.verify_id().is_err()
    629         || unsigned.pubkey.to_hex() != user_binding(providers)?.expected_identity().as_hex()
    630     {
    631         return Err(work_error(MycNip46WorkErrorKind::ProviderWorkRejected));
    632     }
    633     MycProviderOperationInput::sign_event(canonical.as_bytes())
    634         .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))
    635 }
    636 
    637 fn provider_identity(value: &str) -> Result<MycProviderPublicIdentity, MycNip46WorkError> {
    638     MycProviderPublicIdentity::new(value)
    639         .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))
    640 }
    641 
    642 fn protocol_permission(value: &str) -> Result<MycConnectionPermission, MycNip46WorkError> {
    643     MycConnectionPermission::parse(value)
    644         .ok_or_else(|| work_error(MycNip46WorkErrorKind::UnsupportedMethod))
    645 }
    646 
    647 fn connect_permissions(
    648     permissions: &[radroots_nostr_connect::permission::Permission],
    649 ) -> Result<MycConnectionPermissionSet, MycNip46WorkError> {
    650     let permissions = permissions
    651         .iter()
    652         .map(connect_permission)
    653         .collect::<Result<Vec<_>, _>>()?;
    654     if permissions.iter().any(|permission| {
    655         !matches!(
    656             permission,
    657             MycConnectionPermission::SignEvent(_)
    658                 | MycConnectionPermission::Nip04Encrypt
    659                 | MycConnectionPermission::Nip04Decrypt
    660                 | MycConnectionPermission::Nip44Encrypt
    661                 | MycConnectionPermission::Nip44Decrypt
    662                 | MycConnectionPermission::SwitchRelays
    663         )
    664     }) {
    665         return Err(work_error(MycNip46WorkErrorKind::PermissionDenied));
    666     }
    667     MycConnectionPermissionSet::new(&permissions)
    668         .map_err(|_| work_error(MycNip46WorkErrorKind::PermissionDenied))
    669 }
    670 
    671 fn connect_permission(
    672     permission: &radroots_nostr_connect::permission::Permission,
    673 ) -> Result<MycConnectionPermission, MycNip46WorkError> {
    674     if permission.method() == &radroots_nostr_connect::Method::SignEvent {
    675         let parameter = permission
    676             .parameter()
    677             .ok_or_else(|| work_error(MycNip46WorkErrorKind::PermissionDenied))?;
    678         let kind = parameter.strip_prefix("kind:").unwrap_or(parameter);
    679         let parsed = kind
    680             .parse::<u32>()
    681             .ok()
    682             .filter(|parsed| kind == parsed.to_string())
    683             .ok_or_else(|| work_error(MycNip46WorkErrorKind::PermissionDenied))?;
    684         return Ok(MycConnectionPermission::SignEvent(parsed));
    685     }
    686     if permission.parameter().is_some() {
    687         return Err(work_error(MycNip46WorkErrorKind::PermissionDenied));
    688     }
    689     protocol_permission(permission.method().as_str())
    690 }
    691 
    692 #[cfg(test)]
    693 mod tests {
    694     use nostr::{
    695         EventBuilder, JsonUtil as _, Keys, Kind, Tag, Timestamp,
    696         UnsignedEvent as NostrUnsignedEvent,
    697         nips::{nip04, nip44},
    698     };
    699     use radroots_nostr_connect::{
    700         Method,
    701         message::{Request, RequestMessage, UnsignedEvent as ConnectUnsignedEvent},
    702     };
    703 
    704     use crate::{
    705         MycConfigDocumentV1, MycConfigProfile, MycNip46AuthoredTimePolicy,
    706         MycNip46ObservedAtUnixSeconds, MycProviderCapability, MycProviderResponseObservedAtUnixMs,
    707         admit_myc_nip46_event, parse_myc_config_v1,
    708         provider_verification::verify_protected_response_for_test, verify_myc_nip46_event,
    709     };
    710 
    711     use super::*;
    712 
    713     const CONFIG: &str = include_str!("../contracts/services_hardening/config.v1.example.toml");
    714     const OBSERVED_AT_SECONDS: u64 = 1_725_000_000;
    715     const RECEIVED_AT_MS: u64 = 1_725_000_000_000;
    716     const PROVIDER_DEADLINE_MS: u64 = RECEIVED_AT_MS + 10_000;
    717 
    718     fn keys(seed: u8) -> Keys {
    719         Keys::parse(&format!("{seed:02x}{}", "00".repeat(31))).expect("test keys")
    720     }
    721 
    722     fn configuration() -> MycConfigDocumentV1 {
    723         let source = CONFIG
    724             .replacen(
    725                 "4444444444444444444444444444444444444444444444444444444444444444",
    726                 &keys(2).public_key().to_hex(),
    727                 1,
    728             )
    729             .replacen(
    730                 "2222222222222222222222222222222222222222222222222222222222222222",
    731                 &keys(3).public_key().to_hex(),
    732                 1,
    733             );
    734         parse_myc_config_v1(source.as_bytes(), MycConfigProfile::RepoLocal)
    735             .expect("test configuration")
    736     }
    737 
    738     fn verified_event(
    739         request: &Request,
    740         nip44_v2: bool,
    741         created_at: u64,
    742     ) -> (MycVerifiedNip46Event, Vec<u8>) {
    743         let client = keys(1);
    744         let transport = keys(2);
    745         let message = RequestMessage::try_new(format!("request-{created_at}"), request.clone())
    746             .expect("request message");
    747         let plaintext = serde_json::to_vec(&message).expect("canonical request");
    748         let content = if nip44_v2 {
    749             nip44::encrypt(
    750                 client.secret_key(),
    751                 &transport.public_key(),
    752                 &plaintext,
    753                 nip44::Version::V2,
    754             )
    755             .expect("NIP-44 encryption")
    756         } else {
    757             nip04::encrypt(client.secret_key(), &transport.public_key(), &plaintext)
    758                 .expect("NIP-04 encryption")
    759         };
    760         let event = EventBuilder::new(Kind::Custom(24_133), content)
    761             .tag(Tag::public_key(transport.public_key()))
    762             .custom_created_at(Timestamp::from_secs(created_at))
    763             .sign_with_keys(&client)
    764             .expect("signed request event");
    765         let config = configuration();
    766         let limits = MycNip46AdmissionLimits::from_config(&config).expect("admission limits");
    767         let wire = serde_json::to_vec(&event).expect("event wire");
    768         let event = verify_myc_nip46_event(
    769             admit_myc_nip46_event(limits, &wire).expect("bounded event"),
    770             config
    771                 .provider_contract()
    772                 .binding(MycProviderRole::Transport)
    773                 .expect("transport binding"),
    774             MycNip46ObservedAtUnixSeconds::new(OBSERVED_AT_SECONDS).expect("observation"),
    775             MycNip46AuthoredTimePolicy::new(120, 120).expect("authored-time policy"),
    776         )
    777         .expect("verified event");
    778         (event, plaintext)
    779     }
    780 
    781     fn decrypted(request: &Request, nip44_v2: bool, created_at: u64) -> MycDecryptedNip46Request {
    782         let (event, plaintext) = verified_event(request, nip44_v2, created_at);
    783         let config = configuration();
    784         let transport = config
    785             .provider_contract()
    786             .binding(MycProviderRole::Transport)
    787             .expect("transport binding");
    788         let work = prepare_myc_nip46_decrypt_work(
    789             event,
    790             transport,
    791             MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"),
    792         )
    793         .expect("decrypt work");
    794         let response = verify_protected_response_for_test(transport, work.operation(), &plaintext)
    795             .expect("verified provider response");
    796         work.complete(
    797             response,
    798             MycNip46AdmissionLimits::from_config(&config).expect("admission limits"),
    799         )
    800         .expect("decrypted request")
    801     }
    802 
    803     fn prepared_request(request: Request, seed: u8) -> MycPreparedNip46Request {
    804         prepare_myc_nip46_request(
    805             decrypted(&request, true, OBSERVED_AT_SECONDS + u64::from(seed)),
    806             MycSignerOperationNonce::from_injected_entropy([seed; 32]),
    807             MycRequestReceivedAtUnixMs::new(RECEIVED_AT_MS + u64::from(seed))
    808                 .expect("received time"),
    809         )
    810         .expect("prepared request")
    811     }
    812 
    813     fn active_connection(
    814         prepared: &MycPreparedNip46Request,
    815         permissions: &[MycConnectionPermission],
    816         authorized_until: Option<u64>,
    817     ) -> MycConnectionRecord {
    818         MycConnectionRecord::active_for_test(
    819             prepared.signer_request.client_public_key().clone(),
    820             MycConnectionPermissionSet::new(permissions).expect("permissions"),
    821             authorized_until
    822                 .map(|value| MycConnectionTimeUnixMs::new(value).expect("authorization deadline")),
    823         )
    824     }
    825 
    826     fn unsigned_sign_event() -> ConnectUnsignedEvent {
    827         unsigned_sign_event_for(3)
    828     }
    829 
    830     fn unsigned_sign_event_for(author_seed: u8) -> ConnectUnsignedEvent {
    831         let event = NostrUnsignedEvent::new(
    832             keys(author_seed).public_key(),
    833             Timestamp::from_secs(OBSERVED_AT_SECONDS),
    834             Kind::TextNote,
    835             Vec::<Tag>::new(),
    836             "bounded test event",
    837         );
    838         ConnectUnsignedEvent::from_json(&event.as_json()).expect("connect unsigned event")
    839     }
    840 
    841     fn protocol_request(method: Method, params: Vec<String>) -> Request {
    842         Request::from_parts(method, params).expect("protocol request")
    843     }
    844 
    845     #[test]
    846     fn verified_decryption_is_bound_to_the_exact_event_and_context() {
    847         let request = Request::Ping;
    848         for (nip44_v2, expected_capability, expected_version) in [
    849             (false, MycProviderCapability::Nip04Decrypt, None),
    850             (
    851                 true,
    852                 MycProviderCapability::Nip44Decrypt,
    853                 Some(MycProviderNip44Version::V2),
    854             ),
    855         ] {
    856             let (event, plaintext) = verified_event(&request, nip44_v2, OBSERVED_AT_SECONDS);
    857             let config = configuration();
    858             let transport = config
    859                 .provider_contract()
    860                 .binding(MycProviderRole::Transport)
    861                 .expect("transport binding");
    862             let work = prepare_myc_nip46_decrypt_work(
    863                 event,
    864                 transport,
    865                 MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"),
    866             )
    867             .expect("decrypt work");
    868             assert_eq!(work.operation().role(), MycProviderRole::Transport);
    869             assert_eq!(work.operation().input().capability(), expected_capability);
    870             assert_eq!(work.operation().input().nip44_version(), expected_version);
    871             let response =
    872                 verify_protected_response_for_test(transport, work.operation(), &plaintext)
    873                     .expect("verified response");
    874             work.complete(
    875                 response,
    876                 MycNip46AdmissionLimits::from_config(&config).expect("limits"),
    877             )
    878             .expect("exact event completion");
    879         }
    880 
    881         let (first_event, plaintext) = verified_event(&request, true, OBSERVED_AT_SECONDS + 1);
    882         let (second_event, _) = verified_event(&request, true, OBSERVED_AT_SECONDS + 2);
    883         let config = configuration();
    884         let transport = config
    885             .provider_contract()
    886             .binding(MycProviderRole::Transport)
    887             .expect("transport binding");
    888         let first = prepare_myc_nip46_decrypt_work(
    889             first_event,
    890             transport,
    891             MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"),
    892         )
    893         .expect("first work");
    894         let second = prepare_myc_nip46_decrypt_work(
    895             second_event,
    896             transport,
    897             MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"),
    898         )
    899         .expect("second work");
    900         let response = verify_protected_response_for_test(transport, first.operation(), &plaintext)
    901             .expect("first response");
    902         assert_ne!(
    903             first.operation().operation_id(),
    904             second.operation().operation_id()
    905         );
    906         assert_eq!(
    907             second
    908                 .complete(
    909                     response,
    910                     MycNip46AdmissionLimits::from_config(&config).expect("limits"),
    911                 )
    912                 .expect_err("cross-event response"),
    913             work_error(MycNip46WorkErrorKind::InvalidBinding)
    914         );
    915     }
    916 
    917     #[test]
    918     fn exact_method_inventory_maps_to_local_and_user_provider_work() {
    919         let peer = keys(4).public_key().to_hex();
    920         let cases = vec![
    921             (Request::GetPublicKey, None, MycNip46WorkKind::Local, None),
    922             (
    923                 Request::GetSessionCapability,
    924                 None,
    925                 MycNip46WorkKind::Local,
    926                 None,
    927             ),
    928             (Request::Ping, None, MycNip46WorkKind::Local, None),
    929             (Request::Logout, None, MycNip46WorkKind::Local, None),
    930             (
    931                 Request::SwitchRelays,
    932                 Some(MycConnectionPermission::SwitchRelays),
    933                 MycNip46WorkKind::Local,
    934                 None,
    935             ),
    936             (
    937                 Request::SignEvent(unsigned_sign_event()),
    938                 Some(MycConnectionPermission::SignEvent(1)),
    939                 MycNip46WorkKind::Provider,
    940                 Some(MycProviderCapability::SignEvent),
    941             ),
    942             (
    943                 protocol_request(Method::Nip04Encrypt, vec![peer.clone(), "bounded".into()]),
    944                 Some(MycConnectionPermission::Nip04Encrypt),
    945                 MycNip46WorkKind::Provider,
    946                 Some(MycProviderCapability::Nip04Encrypt),
    947             ),
    948             (
    949                 protocol_request(
    950                     Method::Nip04Decrypt,
    951                     vec![
    952                         peer.clone(),
    953                         "QUFBQUFBQUFBQUFBQUFBQQ==?iv=QUFBQUFBQUFBQUFBQUFBQQ==".into(),
    954                     ],
    955                 ),
    956                 Some(MycConnectionPermission::Nip04Decrypt),
    957                 MycNip46WorkKind::Provider,
    958                 Some(MycProviderCapability::Nip04Decrypt),
    959             ),
    960             (
    961                 protocol_request(Method::Nip44Encrypt, vec![peer.clone(), "bounded".into()]),
    962                 Some(MycConnectionPermission::Nip44Encrypt),
    963                 MycNip46WorkKind::Provider,
    964                 Some(MycProviderCapability::Nip44Encrypt),
    965             ),
    966             (
    967                 protocol_request(
    968                     Method::Nip44Decrypt,
    969                     vec![
    970                         peer,
    971                         "AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
    972                     ],
    973                 ),
    974                 Some(MycConnectionPermission::Nip44Decrypt),
    975                 MycNip46WorkKind::Provider,
    976                 Some(MycProviderCapability::Nip44Decrypt),
    977             ),
    978         ];
    979         for (index, (request, permission, expected_kind, expected_capability)) in
    980             cases.into_iter().enumerate()
    981         {
    982             let prepared = prepared_request(request, u8::try_from(index + 1).expect("seed"));
    983             let record = prepared.signer_request.admitted_record_for_test();
    984             let permissions = permission.into_iter().collect::<Vec<_>>();
    985             let connection =
    986                 active_connection(&prepared, &permissions, Some(RECEIVED_AT_MS + 100_000));
    987             let provider_deadline = (expected_kind == MycNip46WorkKind::Provider)
    988                 .then(|| MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"));
    989             let work = prepare_myc_nip46_work(
    990                 prepared,
    991                 record,
    992                 Some(connection),
    993                 configuration().provider_contract(),
    994                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
    995                 provider_deadline,
    996             )
    997             .expect("governed work");
    998             assert_eq!(work.kind(), expected_kind);
    999             assert_eq!(
   1000                 work.provider_operation()
   1001                     .map(|operation| operation.input().capability()),
   1002                 expected_capability
   1003             );
   1004             if let Some(operation) = work.provider_operation() {
   1005                 assert_eq!(operation.role(), MycProviderRole::User);
   1006                 assert_eq!(
   1007                     operation.operation_id().as_bytes(),
   1008                     work.request_record().operation_id().as_bytes()
   1009                 );
   1010             }
   1011         }
   1012     }
   1013 
   1014     #[test]
   1015     fn connect_and_nonconnect_authorization_fail_closed() {
   1016         let connect = protocol_request(
   1017             Method::Connect,
   1018             vec![
   1019                 keys(2).public_key().to_hex(),
   1020                 String::new(),
   1021                 "nip44_encrypt,sign_event:1".into(),
   1022             ],
   1023         );
   1024         let prepared = prepared_request(connect, 20);
   1025         let record = prepared.signer_request.admitted_record_for_test();
   1026         let work = prepare_myc_nip46_work(
   1027             prepared,
   1028             record,
   1029             None,
   1030             configuration().provider_contract(),
   1031             MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1032             None,
   1033         )
   1034         .expect("connect work");
   1035         assert_eq!(work.kind(), MycNip46WorkKind::Connect);
   1036         work.connection_admission_request(
   1037             MycConnectionPolicyGeneration::new(1).expect("generation"),
   1038             MycConnectionNonce::from_injected_entropy([0x44; 32]),
   1039             MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1040             None,
   1041             MycConnectionAdmissionPolicy::ExplicitApproval,
   1042             MycRateRelayId::new("primary").expect("relay"),
   1043         )
   1044         .expect("admission request");
   1045 
   1046         for (request_seed, remote_signer_seed) in [(21, 3), (22, 4)] {
   1047             let wrong_identity_connect = protocol_request(
   1048                 Method::Connect,
   1049                 vec![
   1050                     keys(remote_signer_seed).public_key().to_hex(),
   1051                     String::new(),
   1052                 ],
   1053             );
   1054             let prepared = prepared_request(wrong_identity_connect, request_seed);
   1055             let record = prepared.signer_request.admitted_record_for_test();
   1056             assert_eq!(
   1057                 prepare_myc_nip46_work(
   1058                     prepared,
   1059                     record,
   1060                     None,
   1061                     configuration().provider_contract(),
   1062                     MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1063                     None,
   1064                 )
   1065                 .expect_err("connect remote signer identity mismatch"),
   1066                 work_error(MycNip46WorkErrorKind::InvalidBinding)
   1067             );
   1068         }
   1069 
   1070         let secret_connect = protocol_request(
   1071             Method::Connect,
   1072             vec![keys(3).public_key().to_hex(), "forbidden-secret".into()],
   1073         );
   1074         let prepared = prepared_request(secret_connect, 21);
   1075         let record = prepared.signer_request.admitted_record_for_test();
   1076         assert_eq!(
   1077             prepare_myc_nip46_work(
   1078                 prepared,
   1079                 record,
   1080                 None,
   1081                 configuration().provider_contract(),
   1082                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1083                 None,
   1084             )
   1085             .expect_err("connect secret"),
   1086             work_error(MycNip46WorkErrorKind::InvalidBinding)
   1087         );
   1088 
   1089         let prepared = prepared_request(
   1090             protocol_request(
   1091                 Method::Nip44Encrypt,
   1092                 vec![keys(4).public_key().to_hex(), "protected-marker".into()],
   1093             ),
   1094             22,
   1095         );
   1096         let record = prepared.signer_request.admitted_record_for_test();
   1097         let denied = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 100_000));
   1098         assert_eq!(
   1099             prepare_myc_nip46_work(
   1100                 prepared,
   1101                 record,
   1102                 Some(denied),
   1103                 configuration().provider_contract(),
   1104                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1105                 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")),
   1106             )
   1107             .expect_err("missing permission"),
   1108             work_error(MycNip46WorkErrorKind::PermissionDenied)
   1109         );
   1110 
   1111         let prepared = prepared_request(Request::Ping, 24);
   1112         let record = prepared.signer_request.admitted_record_for_test();
   1113         let expired = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 500));
   1114         assert_eq!(
   1115             prepare_myc_nip46_work(
   1116                 prepared,
   1117                 record,
   1118                 Some(expired),
   1119                 configuration().provider_contract(),
   1120                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1121                 None,
   1122             )
   1123             .expect_err("expired connection"),
   1124             work_error(MycNip46WorkErrorKind::ConnectionExpired)
   1125         );
   1126 
   1127         let prepared = prepared_request(
   1128             protocol_request(
   1129                 Method::Nip04Encrypt,
   1130                 vec![keys(4).public_key().to_hex(), "bounded".into()],
   1131             ),
   1132             25,
   1133         );
   1134         let record = prepared.signer_request.admitted_record_for_test();
   1135         let connection = active_connection(
   1136             &prepared,
   1137             &[MycConnectionPermission::Nip04Encrypt],
   1138             Some(RECEIVED_AT_MS + 100_000),
   1139         );
   1140         assert_eq!(
   1141             prepare_myc_nip46_work(
   1142                 prepared,
   1143                 record,
   1144                 Some(connection),
   1145                 configuration().provider_contract(),
   1146                 MycConnectionTimeUnixMs::new(PROVIDER_DEADLINE_MS).expect("observation"),
   1147                 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")),
   1148             )
   1149             .expect_err("nonfuture provider deadline"),
   1150             work_error(MycNip46WorkErrorKind::ProviderWorkRejected)
   1151         );
   1152 
   1153         let prepared = prepared_request(Request::SignEvent(unsigned_sign_event_for(4)), 28);
   1154         let record = prepared.signer_request.admitted_record_for_test();
   1155         let connection = active_connection(
   1156             &prepared,
   1157             &[MycConnectionPermission::SignEvent(1)],
   1158             Some(RECEIVED_AT_MS + 100_000),
   1159         );
   1160         assert_eq!(
   1161             prepare_myc_nip46_work(
   1162                 prepared,
   1163                 record,
   1164                 Some(connection),
   1165                 configuration().provider_contract(),
   1166                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1167                 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")),
   1168             )
   1169             .expect_err("wrong signing author"),
   1170             work_error(MycNip46WorkErrorKind::ProviderWorkRejected)
   1171         );
   1172 
   1173         let prepared = prepared_request(Request::Ping, 26);
   1174         let mismatched = prepared_request(Request::Ping, 27)
   1175             .signer_request
   1176             .admitted_record_for_test();
   1177         let connection = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 100_000));
   1178         assert_eq!(
   1179             prepare_myc_nip46_work(
   1180                 prepared,
   1181                 mismatched,
   1182                 Some(connection),
   1183                 configuration().provider_contract(),
   1184                 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"),
   1185                 None,
   1186             )
   1187             .expect_err("mismatched durable request"),
   1188             work_error(MycNip46WorkErrorKind::InvalidBinding)
   1189         );
   1190 
   1191         let custom = Request::Custom {
   1192             method: Method::custom("vendor_method").expect("custom method"),
   1193             params: vec!["protected-marker".to_owned()],
   1194         };
   1195         assert_eq!(
   1196             prepare_myc_nip46_request(
   1197                 decrypted(&custom, true, OBSERVED_AT_SECONDS + 23),
   1198                 MycSignerOperationNonce::from_injected_entropy([23; 32]),
   1199                 MycRequestReceivedAtUnixMs::new(RECEIVED_AT_MS).expect("received"),
   1200             )
   1201             .expect_err("custom method"),
   1202             work_error(MycNip46WorkErrorKind::UnsupportedMethod)
   1203         );
   1204     }
   1205 
   1206     #[test]
   1207     fn errors_and_work_debug_are_source_free_and_redacted() {
   1208         for kind in [
   1209             MycNip46WorkErrorKind::InvalidBinding,
   1210             MycNip46WorkErrorKind::DecryptionRejected,
   1211             MycNip46WorkErrorKind::UnsupportedMethod,
   1212             MycNip46WorkErrorKind::PermissionDenied,
   1213             MycNip46WorkErrorKind::ConnectionExpired,
   1214             MycNip46WorkErrorKind::ProviderWorkRejected,
   1215         ] {
   1216             let error = work_error(kind);
   1217             assert_eq!(error.kind(), kind);
   1218             assert!(!error.code().is_empty());
   1219             assert!(!error.to_string().is_empty());
   1220             assert!(error.source().is_none());
   1221         }
   1222 
   1223         let prepared = prepared_request(Request::Ping, 30);
   1224         assert!(!format!("{prepared:?}").contains("request-"));
   1225         assert!(!format!("{prepared:?}").contains("protected-marker"));
   1226         assert!(MycProviderResponseObservedAtUnixMs::new(PROVIDER_DEADLINE_MS).is_ok());
   1227     }
   1228 }