commit a7d49cd79561188b138a0353abdd317802ae6135 parent 74b0163bc79d86b935755fdaa4b47d761f7dfa93 Author: triesap <tyson@radroots.org> Date: Mon, 26 Oct 2026 05:13:53 +0000 signing: bind exact recovery to the attached signer scope - Reobserve original identity and qualified recovery capability. - Retain active callbacks through settlement and enforce intent binding. - Preserve obtained bytes and refuse renewal of expired originals. - Verify actual native recovery, scoped lifecycle, APIs and Linux behavior. Diffstat:
14 files changed, 434 insertions(+), 1 deletion(-)
diff --git a/contracts/api_baselines/radroots.txt b/contracts/api_baselines/radroots.txt @@ -157,6 +157,10 @@ pub use radroots::signing::ArtifactRole pub use radroots::signing::AuthorizationHeader pub use radroots::signing::BlossomAuthorizationPlan pub use radroots::signing::BlossomSigningError +pub use radroots::signing::ExactRecoveryCapability +pub use radroots::signing::ExactRecoveryKind +pub use radroots::signing::ExactRecoveryOutcome +pub use radroots::signing::ExactRecoveryRequest pub use radroots::signing::IntentBinding pub use radroots::signing::Mode pub use radroots::signing::Operations diff --git a/contracts/api_baselines/radroots_execution.txt b/contracts/api_baselines/radroots_execution.txt @@ -82,6 +82,7 @@ pub fn radroots_execution::session::SignerSession::new(radroots_signing::provide pub async fn radroots_execution::session::SignerSession::observe(&self) -> core::result::Result<radroots_signing::provider::ProviderState, radroots_signing::provider::ProviderError> pub fn radroots_execution::session::SignerSession::observed(&self) -> core::option::Option<radroots_signing::provider::ProviderState> pub async fn radroots_execution::session::SignerSession::quiesce(&self) -> radroots_execution::Result<()> +pub async fn radroots_execution::session::SignerSession::recover_exact(&self, radroots_signing::issuance::exact_recovery::ExactRecoveryRequest) -> radroots_signing::issuance::exact_recovery::ExactRecoveryOutcome pub async fn radroots_execution::session::SignerSession::sign_exact(&self, radroots_signing::issuance::SigningIntent) -> radroots_signing::issuance::SigningOutcome pub fn radroots_execution::session::SignerSession::state(&self) -> radroots_execution::session::SessionState impl core::clone::Clone for radroots_execution::session::SignerSession diff --git a/contracts/api_baselines/radroots_signing.txt b/contracts/api_baselines/radroots_signing.txt @@ -173,6 +173,7 @@ pub const fn radroots_signing::issuance::ArtifactFingerprint::total_bytes(self) pub struct radroots_signing::issuance::ExactRecoveryOutcome impl radroots_signing::issuance::ExactRecoveryOutcome pub const fn radroots_signing::issuance::ExactRecoveryOutcome::binding(&self) -> radroots_protocol::intent::IntentBinding +pub fn radroots_signing::issuance::ExactRecoveryOutcome::enforce_binding(self, radroots_protocol::intent::IntentBinding) -> Self pub fn radroots_signing::issuance::ExactRecoveryOutcome::from_recovery_verification(radroots_signing::issuance::SigningOutcome) -> Self pub const fn radroots_signing::issuance::ExactRecoveryOutcome::indeterminate(radroots_protocol::intent::IntentBinding, radroots_signing::provider::ProviderError) -> Self pub fn radroots_signing::issuance::ExactRecoveryOutcome::into_parts(self) -> (radroots_protocol::intent::IntentBinding, radroots_signing::issuance::ExactRecoveryKind) diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -73,6 +73,11 @@ }, "native_seller_stock_authority": { "qualified_local_recovery": { + "scoped_method": "SignerSession.recover_exact", + "scoped_identity_and_capability_rechecked": true, + "scoped_callback_binding_enforced": true, + "scoped_close_waits_for_active_call": true, + "scoped_method_grants_store_authority": false, "provider_method": "radroots_signing.provider.ParticipantProvider.recover_exact", "adapter": "radroots_nostr.signing.LocalSigner", "native_authorizer": "NativeWorkspace.authorize_stock_exact_replay", diff --git a/crates/execution/README.md b/crates/execution/README.md @@ -164,3 +164,14 @@ execute no fallback. Loss of an accepted admission task preserves the original ID with unknown T0 and manual reconciliation. The result is preparation only; the concrete store still authenticates consent and actual atomic holds. This low-level method does not supply complete ordinary commerce orchestration. + +`SignerSession::recover_exact` uses the already attached frozen identity and +rechecks the actual recovery capability before calling the qualified method. +Unobserved, unavailable, closed or changed scopes return original-bound +indeterminate state without legacy or first-signing fallback. Active calls retain +the provider and callback scope until settlement; close waits for those calls. +Foreign callback bindings are rejected with bounded forensic identity. Correctly +bound obtained bytes and nullable observation survive unchanged. The composing +executor must still own the complete task and durable capture, authenticate the +original store claim and enforce retained replay policy. This scope grants no +stock authority, renewed deadline or proof of original nonissuance. diff --git a/crates/execution/src/session/signer.rs b/crates/execution/src/session/signer.rs @@ -123,6 +123,55 @@ impl Clone for SignerSession { } impl SignerSession { + /// Recovers an original intent only through the current qualified method. + /// This scope supplies no store authority or captured replay policy. Its + /// caller must own the complete task and durable capture after observer loss. + /// Refusal leaves original issuance indeterminate and renews no deadline. + pub async fn recover_exact( + &self, + request: radroots_signing::issuance::ExactRecoveryRequest, + ) -> radroots_signing::issuance::ExactRecoveryOutcome { + use radroots_signing::issuance::{ExactRecoveryCapability, ExactRecoveryOutcome}; + let binding = request.binding(); + let refuse = |reason| ExactRecoveryOutcome::indeterminate(binding, reason); + if self.state() != SessionState::Running { + return refuse(ProviderError::CapabilityUnavailable); + } + if self.identity_changed() { + return refuse(ProviderError::IdentityChanged); + } + let Some(observed) = self.observed() else { + return refuse(ProviderError::CapabilityUnavailable); + }; + if observed.identity() != request.original().author() { + return refuse(ProviderError::IdentityChanged); + } + if observed.exact_recovery() != ExactRecoveryCapability::LocalExactReplay { + return refuse(ProviderError::CapabilityUnavailable); + } + let observed = match self.observe().await { + Ok(observed) => observed, + Err(error) => return refuse(error), + }; + if observed.identity() != request.original().author() { + return refuse(ProviderError::IdentityChanged); + } + if observed.exact_recovery() != ExactRecoveryCapability::LocalExactReplay { + return refuse(ProviderError::CapabilityUnavailable); + } + let Ok(_permit) = self.session.admit() else { + return refuse(ProviderError::CapabilityUnavailable); + }; + let Some(provider) = self.resources.retain_binding() else { + return refuse(ProviderError::CapabilityUnavailable); + }; + provider + .provider + .recover_exact(request) + .await + .enforce_binding(binding) + } + async fn private_provider( &self, call: &ProviderCall, diff --git a/crates/execution/tests/signer_session.rs b/crates/execution/tests/signer_session.rs @@ -22,6 +22,9 @@ use std::sync::{ Mutex, atomic::{AtomicBool, AtomicUsize, Ordering}, }; +#[cfg(not(target_arch = "wasm32"))] +#[path = "support/signer_recovery.rs"] +mod recovery; fn key(second: bool) -> PublicKey { PublicKey::from_hex(if second { @@ -46,6 +49,10 @@ fn state(second: bool, encrypt: bool) -> ProviderState { } struct Control { + recovery_calls: AtomicUsize, + recovery_response: + Mutex<Option<oneshot::Receiver<radroots_signing::issuance::ExactRecoveryOutcome>>>, + recovery_binding: Mutex<Option<radroots_signing::issuance::IntentBinding>>, current: Mutex<ProviderState>, calls: AtomicUsize, sign_calls: AtomicUsize, @@ -82,6 +89,29 @@ impl Signer for Provider { } impl ParticipantProvider for Provider { + fn recover_exact( + &self, + request: radroots_signing::issuance::ExactRecoveryRequest, + ) -> BoxFuture<'_, radroots_signing::issuance::ExactRecoveryOutcome> { + use radroots_signing::issuance::ExactRecoveryOutcome; + Box::pin(async move { + self.0.recovery_calls.fetch_add(1, Ordering::SeqCst); + let binding = self + .0 + .recovery_binding + .lock() + .unwrap() + .unwrap_or(request.binding()); + let response = self.0.recovery_response.lock().unwrap().take(); + if let Some(response) = response { + response.await.unwrap_or_else(|_| { + ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure) + }) + } else { + ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure) + } + }) + } fn sign_exact( &self, intent: radroots_signing::issuance::SigningIntent, @@ -202,6 +232,9 @@ fn scope() -> Fixture { fn control() -> Shared<Control> { Shared::new(Control { + recovery_calls: AtomicUsize::new(0), + recovery_response: Mutex::new(None), + recovery_binding: Mutex::new(None), current: Mutex::new(state(false, false)), calls: AtomicUsize::new(0), sign_calls: AtomicUsize::new(0), diff --git a/crates/execution/tests/support/signer_recovery.rs b/crates/execution/tests/support/signer_recovery.rs @@ -0,0 +1,142 @@ +//! Scope mechanics; concrete local cryptography is exercised by the facade. +use super::*; +use radroots_signing::{ + issuance::{ + ExactRecoveryCapability, ExactRecoveryKind, ExactRecoveryOutcome, ExactRecoveryRequest, + RejectionReason, + }, + request::CancellationSignal, +}; +fn supported(second: bool) -> ProviderState { + state(second, false).with_exact_recovery(ExactRecoveryCapability::LocalExactReplay) +} +fn request(second: bool, operation: u8) -> ExactRecoveryRequest { + ExactRecoveryRequest::new( + exact_intent(second, operation), + ProviderCall::new( + key(second), + core::num::NonZeroU64::new(1_700_000_020_000).unwrap(), + CancellationSignal::new(), + ), + ) + .unwrap() +} +#[test] +fn recovery_refuses_unobserved_unsupported_changed_identity_and_changed_capability_without_fallback() + { + let Fixture { + session, control, .. + } = scope(); + *control.current.lock().unwrap() = ProviderState::new( + key(false), + PrivateCryptoCapability::Unavailable, + PrivateCryptoCapability::Nip44V2, + ReplayCapability::LocalReplaySafe, + ); + for observed in [false, true] { + if observed { + block_on(session.observe()).unwrap(); + } + let request = request(false, 1); + let expected = request.binding(); + let result = block_on(session.recover_exact(request)); + assert_eq!(result.binding(), expected); + assert!(matches!( + result.kind(), + ExactRecoveryKind::Indeterminate(ProviderError::CapabilityUnavailable) + )); + } + *control.current.lock().unwrap() = supported(false); + block_on(session.observe()).unwrap(); + assert!(matches!( + block_on(session.recover_exact(request(true, 1))).kind(), + ExactRecoveryKind::Indeterminate(ProviderError::IdentityChanged) + )); + assert!(!session.identity_changed()); + let result = block_on(session.recover_exact(request(false, 1))); + assert!(matches!( + result.kind(), + ExactRecoveryKind::Indeterminate(ProviderError::ProviderFailure) + )); + assert_eq!(control.recovery_calls.load(Ordering::SeqCst), 1); + *control.current.lock().unwrap() = state(false, false); + assert!(matches!( + block_on(session.recover_exact(request(false, 1))).kind(), + ExactRecoveryKind::Indeterminate(ProviderError::CapabilityUnavailable) + )); + assert_eq!(control.recovery_calls.load(Ordering::SeqCst), 1); + *control.current.lock().unwrap() = supported(false); + block_on(session.observe()).unwrap(); + *control.current.lock().unwrap() = supported(true); + assert!(matches!( + block_on(session.recover_exact(request(false, 1))).kind(), + ExactRecoveryKind::Indeterminate(ProviderError::IdentityChanged) + )); + assert!(session.identity_changed()); + assert_eq!(control.recovery_calls.load(Ordering::SeqCst), 1); + assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0); + assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 0); + block_on(session.close()).unwrap(); + assert!(matches!( + block_on(session.recover_exact(request(false, 1))).kind(), + ExactRecoveryKind::Indeterminate(ProviderError::CapabilityUnavailable) + )); +} + +#[test] +fn pending_recovery_keeps_callbacks_until_settlement_and_rejects_a_foreign_callback() { + let Fixture { + session, + control, + provider, + callbacks, + } = scope(); + *control.current.lock().unwrap() = supported(false); + block_on(session.observe()).unwrap(); + let input = request(false, 1); + let expected = input.binding(); + let (send, receive) = oneshot::channel(); + *control.recovery_response.lock().unwrap() = Some(receive); + let mut recover = Box::pin(session.recover_exact(input)); + let mut cx = Context::from_waker(noop_waker_ref()); + assert!(recover.as_mut().poll(&mut cx).is_pending()); + let mut close = Box::pin(session.close()); + assert!(close.as_mut().poll(&mut cx).is_pending()); + assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0); + assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some()); + send.send(ExactRecoveryOutcome::indeterminate( + request(false, 2).binding(), + ProviderError::ProviderFailure, + )) + .unwrap(); + let Poll::Ready(result) = recover.as_mut().poll(&mut cx) else { + panic!("recovery did not settle") + }; + assert_eq!(result.binding(), expected); + let ExactRecoveryKind::Rejected(rejected) = result.kind() else { + panic!("foreign callback promoted") + }; + assert_eq!(rejected.reason(), RejectionReason::BindingMismatch); + assert!(rejected.fingerprint().is_none()); + assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); + assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); + assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0); +} + +#[test] +fn failed_initial_observation_cannot_authorize_recovery() { + let Fixture { + session, control, .. + } = scope(); + *control.current.lock().unwrap() = supported(false); + let (send, receive) = oneshot::channel(); + drop(send); + *control.response.lock().unwrap() = Some(receive); + assert!(block_on(session.observe()).is_err()); + assert!(matches!( + block_on(session.recover_exact(request(false, 1))).kind(), + ExactRecoveryKind::Indeterminate(ProviderError::CapabilityUnavailable) + )); + assert_eq!(control.recovery_calls.load(Ordering::SeqCst), 0); + block_on(session.close()).unwrap(); +} diff --git a/crates/radroots/src/signing.rs b/crates/radroots/src/signing.rs @@ -4,7 +4,9 @@ pub use radroots_sdk::signing::{ BlossomAuthorizationPlan, Mode, Operations, Provider, blossom_upload_request, }; pub use radroots_signing::issuance::{ - ArtifactRole, IntentBinding, OutcomeKind, SignedArtifact, SigningIntent, SigningOutcome, + ArtifactRole, ExactRecoveryCapability, ExactRecoveryKind, ExactRecoveryOutcome, + ExactRecoveryRequest, IntentBinding, OutcomeKind, SignedArtifact, SigningIntent, + SigningOutcome, }; #[cfg(any(feature = "blossom", feature = "nostr", feature = "full"))] diff --git a/crates/radroots/tests/native_client.rs b/crates/radroots/tests/native_client.rs @@ -115,6 +115,121 @@ fn local() -> Arc<LocalSigner> { } #[tokio::test] +async fn ordinary_native_scoped_recovery_keeps_original_fields_and_refuses_expired_original() { + use radroots::signing::{ + ArtifactRole, ExactRecoveryKind, ExactRecoveryRequest, OutcomeKind, SigningIntent, + }; + use radroots_event_codec::authoring::AuthoredEventPlan; + use radroots_signing::{provider::ProviderCall, request::CancellationSignal}; + const CREATED: u64 = 1_700_000_000; + const NOW: u64 = CREATED * 1000 + 1; + static OBSERVATIONS: AtomicUsize = AtomicUsize::new(0); + fn clock() -> Result<u64, radroots_signing::Error> { + if OBSERVATIONS + .fetch_add(1, Ordering::SeqCst) + .is_multiple_of(2) + { + Ok(NOW) + } else { + Err(radroots_signing::Error::new( + radroots_signing::error::Kind::InternalError, + )) + } + } + let root = tempfile::tempdir().unwrap(); + let selected = options(root.path()); + let client = Client::open(NativeConfig::public_read(selected.clone())) + .await + .unwrap(); + let provider = Arc::new( + LocalSigner::with_clock( + parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001") + .unwrap(), + clock, + ) + .unwrap(), + ); + let author = provider.public_key(); + let weak = Arc::downgrade(&provider); + let scope = client + .attach_signer(SignerHandle::new(provider, callbacks(selected, true))) + .await + .unwrap(); + let call = |deadline| { + ProviderCall::new( + author, + std::num::NonZeroU64::new(deadline).unwrap(), + CancellationSignal::new(), + ) + }; + let original = |deadline| { + SigningIntent::new( + radroots::OperationId::from_bytes([41; 32]), + [42; 32], + AuthoredEventPlan::from_generic( + radroots::event::GenericEventDraft::new( + "radroots.social.geochat.v1", + 20_000, + CREATED, + vec![], + "synthetic scoped original recovery", + author.to_hex(), + ) + .unwrap(), + ) + .unwrap(), + ArtifactRole::PublicEvent, + None, + call(deadline), + ) + .unwrap() + }; + let first = original(CREATED * 1000 + 10_000); + let expected = first.binding(); + let expected_event = first.with_event(|_, id| id); + let issued = scope.sign_exact(first).await; + assert!(matches!(issued.kind(), OutcomeKind::Obtained(_))); + drop(issued); // Primitive lost observation only; no durable stock claim. + let recovered = scope + .recover_exact( + ExactRecoveryRequest::new( + original(CREATED * 1000 + 10_000), + call(CREATED * 1000 + 20_000), + ) + .unwrap(), + ) + .await; + assert_eq!(recovered.binding(), expected); + let (_, ExactRecoveryKind::Obtained(bytes)) = recovered.into_parts() else { + panic!("real scoped recovery unavailable") + }; + assert_eq!(bytes.event_id(), expected_event); + assert!(bytes.observed_at_unix_ms().is_none()); + bytes.with_json(|raw| { + let wire = radroots_event::wire::Nip01EventWire::parse_json(raw).unwrap(); + assert_eq!(wire.pubkey, author.to_hex()); + assert_eq!(wire.content, "synthetic scoped original recovery"); + assert_eq!(wire.created_at, CREATED); + }); + let expired = original(NOW); + let expired_binding = expired.binding(); + let refused = scope + .recover_exact(ExactRecoveryRequest::new(expired, call(CREATED * 1000 + 30_000)).unwrap()) + .await; + assert_eq!(refused.binding(), expired_binding); + assert!(matches!( + refused.kind(), + ExactRecoveryKind::Indeterminate(ProviderError::DeadlineExceeded) + )); + assert_eq!(OBSERVATIONS.load(Ordering::SeqCst), 5); + client.close().await.unwrap(); + assert!(weak.upgrade().is_none()); + // Obtained authenticated bytes outlive key/callback cleanup. This proves + // neither a protected stock authorization nor durable command capture. + assert!(bytes.with_json(|raw| raw.contains("synthetic scoped original recovery"))); +} + +#[tokio::test] async fn actual_native_signer_attaches_before_start_and_callbacks_close_before_the_store() { let root = tempfile::tempdir().unwrap(); let options = options(root.path()); diff --git a/crates/signing/README.md b/crates/signing/README.md @@ -281,3 +281,7 @@ that source observation; it establishes no global freshness, configured or available transport, workspace grant, consent or signing permission. Missing DM information supplies no fallback target. Exact seal conversion also compares the originating captured operation and command commitment before creating an intent. +Recovery outcomes enforce the original callback binding with the same bounded +rejection/fingerprint policy as issuance outcomes. A mismatched callback cannot +be promoted to the expected operation; a correctly bound obtained artifact is +retained unchanged. Callback rejection remains distinct from nonissuance. diff --git a/crates/signing/src/issuance/exact_recovery.rs b/crates/signing/src/issuance/exact_recovery.rs @@ -94,6 +94,22 @@ impl ExactRecoveryOutcome { }; Self { binding, kind } } + /// Enforces the original callback identity using the issuance verifier's + /// bounded forensic policy. A foreign result grants no success or release. + pub fn enforce_binding(self, expected: IntentBinding) -> Self { + let kind = match self.kind { + ExactRecoveryKind::Obtained(value) => OutcomeKind::Obtained(value), + ExactRecoveryKind::Rejected(value) => OutcomeKind::Rejected(value), + ExactRecoveryKind::Indeterminate(reason) => OutcomeKind::Unknown(reason), + }; + Self::from_recovery_verification( + SigningOutcome { + binding: self.binding, + kind, + } + .enforce_binding(expected), + ) + } /// Returns the original operation/intent binding. pub const fn binding(&self) -> IntentBinding { self.binding diff --git a/crates/signing/tests/issuance/exact_recovery.rs b/crates/signing/tests/issuance/exact_recovery.rs @@ -82,6 +82,33 @@ fn refusal_of_this_recovery_invocation_never_proves_original_nonissuance() { } #[test] +fn foreign_recovery_callback_keeps_only_bounded_forensics_and_never_becomes_expected_success() { + let expected = intent("private retained original", vec![], 7, 8).binding(); + let foreign = intent("private retained original", vec![], 9, 8); + let raw = signed(&foreign); + let result = ExactRecoveryOutcome::from_recovery_verification(SigningOutcome::capture( + &foreign, + raw.clone(), + None, + )) + .enforce_binding(expected); + assert_eq!(result.binding(), expected); + let ExactRecoveryKind::Rejected(rejected) = result.kind() else { + panic!("foreign callback promoted") + }; + assert_eq!(rejected.reason(), RejectionReason::BindingMismatch); + assert_eq!(rejected.fingerprint().unwrap().total_bytes(), raw.len()); + assert!(!format!("{result:?}").contains("private retained original")); + let result = + ExactRecoveryOutcome::indeterminate(foreign.binding(), ProviderError::ProviderFailure) + .enforce_binding(expected); + let ExactRecoveryKind::Rejected(rejected) = result.kind() else { + panic!("foreign uncertainty rebound") + }; + assert!(rejected.fingerprint().is_none()); +} + +#[test] fn verified_original_bytes_and_tampering_keep_distinct_recovery_observations() { let original = intent("private retained original", vec![], 7, 8); let raw = signed(&original); diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -223,6 +223,11 @@ struct AcceptancePreparation { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct QualifiedLocalRecovery { + scoped_method: String, + scoped_identity_and_capability_rechecked: bool, + scoped_callback_binding_enforced: bool, + scoped_close_waits_for_active_call: bool, + scoped_method_grants_store_authority: bool, provider_method: String, adapter: String, native_authorizer: String, @@ -628,6 +633,19 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && !stock.signing_issuance.agreement_installed && stock.qualified_local_recovery.provider_method == "radroots_signing.provider.ParticipantProvider.recover_exact" + && stock.qualified_local_recovery.scoped_method == "SignerSession.recover_exact" + && stock + .qualified_local_recovery + .scoped_identity_and_capability_rechecked + && stock + .qualified_local_recovery + .scoped_callback_binding_enforced + && stock + .qualified_local_recovery + .scoped_close_waits_for_active_call + && !stock + .qualified_local_recovery + .scoped_method_grants_store_authority && stock.qualified_local_recovery.adapter == "radroots_nostr.signing.LocalSigner" && stock.qualified_local_recovery.native_authorizer == "NativeWorkspace.authorize_stock_exact_replay" @@ -1476,6 +1494,11 @@ mod tests { #[test] fn qualified_local_recovery_keeps_original_policy_window_and_current_rights() { for (field, bad) in [ + ("scoped_method", json!("legacy_replay")), + ("scoped_identity_and_capability_rechecked", json!(false)), + ("scoped_callback_binding_enforced", json!(false)), + ("scoped_close_waits_for_active_call", json!(false)), + ("scoped_method_grants_store_authority", json!(true)), ("provider_method", json!("sign_exact")), ("adapter", json!("legacy_signer")), ("native_authorizer", json!("caller_assertion")),