Skip to main content

hns_wallet_chain_api/
lib.rs

1#![doc = "Capability-separated wallet chain interfaces."]
2#![forbid(unsafe_code)]
3
4mod recovery_publication;
5pub use recovery_publication::{
6    MAX_SWAP_RECOVERY_FRAMES, SWAP_RECOVERY_MARKER_BYTES, SwapRecoveryHtlcParameters,
7    SwapRecoveryPublication, SwapRecoveryPublicationError, SwapRecoveryTerms,
8};
9
10use std::collections::BTreeMap;
11
12use hns_wallet_types::{
13    AccountId, Amount, ApprovalId, BaseUnits, ChainCapabilities, ModuleId, ObjectHash,
14    ReceiveTarget, SessionId, SyncStatus, TransactionHash, TransactionSummary,
15};
16use serde::{Deserialize, Serialize};
17use thiserror::Error;
18use zeroize::{Zeroize, ZeroizeOnDrop};
19
20pub const MAX_OPAQUE_TRANSACTION_BYTES: usize = 1_048_576;
21pub const MAX_DESTINATION_BYTES: usize = 512;
22pub const MAX_HISTORY_RESULTS: usize = 10_000;
23
24pub trait ChainModule {
25    fn module_id(&self) -> ModuleId;
26    fn capabilities(&self) -> ChainCapabilities;
27    fn sync_status(&self) -> SyncStatus;
28    fn balance(&self) -> Result<Amount, ChainError>;
29    fn transaction_history(&self) -> Result<Vec<TransactionSummary>, ChainError>;
30    fn receive_target(&self) -> Result<ReceiveTarget, ChainError>;
31    fn prepare_send(&self, request: SendRequest) -> Result<PreparedSend, ChainError>;
32    fn authorize_send(&self, request: AuthorizeSend) -> Result<AuthorizedSend, ChainError>;
33    fn broadcast_send(&self, request: BroadcastSend) -> Result<BroadcastReceipt, ChainError>;
34}
35
36pub trait UtxoChainModule: ChainModule {
37    fn list_utxos(&self) -> Result<Vec<Utxo>, ChainError>;
38    fn fee_policy(&self) -> Result<UtxoFeePolicy, ChainError>;
39    fn prepare_htlc_lock(&self, request: HtlcLockRequest) -> Result<PreparedHtlcLock, ChainError>;
40    fn verify_htlc_lock(
41        &self,
42        request: VerifyHtlcLockRequest,
43    ) -> Result<VerifiedHtlcLock, ChainError>;
44    fn prepare_htlc_redeem(
45        &self,
46        request: HtlcRedeemRequest,
47    ) -> Result<PreparedHtlcRedeem, ChainError>;
48    fn prepare_htlc_refund(
49        &self,
50        request: HtlcRefundRequest,
51    ) -> Result<PreparedHtlcRefund, ChainError>;
52    fn observe_preimage(
53        &self,
54        request: ObservePreimageRequest,
55    ) -> Result<Option<Preimage>, ChainError>;
56}
57
58pub trait AccountChainModule: ChainModule {
59    fn account_nonce(&self) -> Result<u64, ChainError>;
60    fn fee_policy(&self) -> Result<AccountFeePolicy, ChainError>;
61    fn prepare_market_lock(
62        &self,
63        request: MarketLockRequest,
64    ) -> Result<PreparedMarketLock, ChainError>;
65    fn verify_market_lock(
66        &self,
67        request: VerifyMarketLockRequest,
68    ) -> Result<VerifiedMarketLock, ChainError>;
69    fn prepare_market_redeem(
70        &self,
71        request: MarketRedeemRequest,
72    ) -> Result<PreparedMarketRedeem, ChainError>;
73    fn prepare_market_refund(
74        &self,
75        request: MarketRefundRequest,
76    ) -> Result<PreparedMarketRefund, ChainError>;
77    fn observe_market_preimage(
78        &self,
79        request: ObservePreimageRequest,
80    ) -> Result<Option<Preimage>, ChainError>;
81}
82
83pub trait AtomicSettlement {
84    fn settlement_capabilities(&self) -> SettlementCapabilities;
85    fn prepare_lock(
86        &self,
87        request: SettlementLockRequest,
88    ) -> Result<PreparedSettlementLock, ChainError>;
89    fn verify_lock(
90        &self,
91        request: VerifySettlementLockRequest,
92    ) -> Result<VerifiedSettlementLock, ChainError>;
93    fn prepare_redeem(
94        &self,
95        request: SettlementRedeemRequest,
96    ) -> Result<PreparedSettlementRedeem, ChainError>;
97    fn prepare_refund(
98        &self,
99        request: SettlementRefundRequest,
100    ) -> Result<PreparedSettlementRefund, ChainError>;
101    fn observe_secret(&self, request: ObserveSecretRequest)
102    -> Result<Option<Preimage>, ChainError>;
103}
104
105/// Runtime-owned capability registry. Registration is explicit and rejects a
106/// second implementation for the same module instead of silently replacing a
107/// funds-bearing backend.
108#[derive(Default)]
109pub struct ModuleRegistry<'a> {
110    chains: BTreeMap<ModuleId, &'a dyn ChainModule>,
111    utxo_chains: BTreeMap<ModuleId, &'a dyn UtxoChainModule>,
112    account_chains: BTreeMap<ModuleId, &'a dyn AccountChainModule>,
113    settlements: BTreeMap<ModuleId, &'a dyn AtomicSettlement>,
114}
115
116impl<'a> ModuleRegistry<'a> {
117    pub fn new() -> Self {
118        Self::default()
119    }
120
121    pub fn register_chain<T: ChainModule + 'a>(
122        &mut self,
123        module: &'a T,
124    ) -> Result<(), RegistryError> {
125        let id = module.module_id();
126        insert_unique(&mut self.chains, id, module)
127    }
128
129    pub fn register_utxo<T: UtxoChainModule + 'a>(
130        &mut self,
131        module: &'a T,
132    ) -> Result<(), RegistryError> {
133        let id = module.module_id();
134        if self.chains.contains_key(&id) || self.utxo_chains.contains_key(&id) {
135            return Err(RegistryError::DuplicateModule(id));
136        }
137        self.chains.insert(id, module);
138        self.utxo_chains.insert(id, module);
139        Ok(())
140    }
141
142    pub fn register_account<T: AccountChainModule + 'a>(
143        &mut self,
144        module: &'a T,
145    ) -> Result<(), RegistryError> {
146        let id = module.module_id();
147        if self.chains.contains_key(&id) || self.account_chains.contains_key(&id) {
148            return Err(RegistryError::DuplicateModule(id));
149        }
150        self.chains.insert(id, module);
151        self.account_chains.insert(id, module);
152        Ok(())
153    }
154
155    pub fn register_settlement<T: AtomicSettlement + 'a>(
156        &mut self,
157        module_id: ModuleId,
158        settlement: &'a T,
159    ) -> Result<(), RegistryError> {
160        insert_unique(&mut self.settlements, module_id, settlement)
161    }
162
163    pub fn register_utxo_settlement<T: UtxoChainModule + AtomicSettlement + 'a>(
164        &mut self,
165        module: &'a T,
166    ) -> Result<(), RegistryError> {
167        let id = module.module_id();
168        if self.chains.contains_key(&id)
169            || self.utxo_chains.contains_key(&id)
170            || self.settlements.contains_key(&id)
171        {
172            return Err(RegistryError::DuplicateModule(id));
173        }
174        self.chains.insert(id, module);
175        self.utxo_chains.insert(id, module);
176        self.settlements.insert(id, module);
177        Ok(())
178    }
179
180    pub fn chain(&self, module: ModuleId) -> Option<&'a dyn ChainModule> {
181        self.chains.get(&module).copied()
182    }
183
184    pub fn utxo(&self, module: ModuleId) -> Option<&'a dyn UtxoChainModule> {
185        self.utxo_chains.get(&module).copied()
186    }
187
188    pub fn account(&self, module: ModuleId) -> Option<&'a dyn AccountChainModule> {
189        self.account_chains.get(&module).copied()
190    }
191
192    pub fn settlement(&self, module: ModuleId) -> Option<&'a dyn AtomicSettlement> {
193        self.settlements.get(&module).copied()
194    }
195}
196
197fn insert_unique<V: Copy>(
198    entries: &mut BTreeMap<ModuleId, V>,
199    key: ModuleId,
200    value: V,
201) -> Result<(), RegistryError> {
202    if entries.contains_key(&key) {
203        return Err(RegistryError::DuplicateModule(key));
204    }
205    entries.insert(key, value);
206    Ok(())
207}
208
209#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
210pub enum RegistryError {
211    #[error("module {0:?} is already registered for that capability")]
212    DuplicateModule(ModuleId),
213}
214
215#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
216pub struct SendRequest {
217    pub account: AccountId,
218    pub destination: String,
219    pub amount: Amount,
220    pub maximum_fee: BaseUnits,
221    pub request_nonce: u64,
222}
223
224impl SendRequest {
225    pub fn validate(&self) -> Result<(), ChainError> {
226        if self.destination.is_empty() || self.destination.len() > MAX_DESTINATION_BYTES {
227            return Err(ChainError::InvalidRequest("invalid destination length"));
228        }
229        if self.amount.base_units.is_zero() {
230            return Err(ChainError::InvalidRequest("amount is zero"));
231        }
232        Ok(())
233    }
234}
235
236#[derive(Clone, Eq, PartialEq)]
237pub struct PreparedSend {
238    pub module: ModuleId,
239    pub amount: Amount,
240    pub fee: BaseUnits,
241    pub destination: String,
242    pub expires_at_unix: u64,
243    payload: Vec<u8>,
244}
245
246impl core::fmt::Debug for PreparedSend {
247    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
248        formatter
249            .debug_struct("PreparedSend")
250            .field("module", &self.module)
251            .field("amount", &self.amount)
252            .field("fee", &self.fee)
253            .field("destination", &self.destination)
254            .field("expires_at_unix", &self.expires_at_unix)
255            .field("payload", &"[REDACTED]")
256            .finish()
257    }
258}
259
260impl PreparedSend {
261    pub fn new(
262        module: ModuleId,
263        amount: Amount,
264        fee: BaseUnits,
265        destination: String,
266        expires_at_unix: u64,
267        payload: Vec<u8>,
268    ) -> Result<Self, ChainError> {
269        validate_opaque(&payload)?;
270        Ok(Self {
271            module,
272            amount,
273            fee,
274            destination,
275            expires_at_unix,
276            payload,
277        })
278    }
279
280    pub fn authorization_commitment(&self) -> &[u8] {
281        &self.payload
282    }
283}
284
285#[derive(Clone, Debug, Eq, PartialEq)]
286pub struct AuthorizeSend {
287    pub prepared: PreparedSend,
288    pub approval_id: ApprovalId,
289    pub approved_at_unix: u64,
290}
291
292#[derive(Clone, Eq, PartialEq, Zeroize, ZeroizeOnDrop)]
293pub struct AuthorizedSend {
294    #[zeroize(skip)]
295    pub module: ModuleId,
296    #[zeroize(skip)]
297    pub approval_id: ApprovalId,
298    signed_transaction: Vec<u8>,
299}
300
301impl core::fmt::Debug for AuthorizedSend {
302    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
303        formatter
304            .debug_struct("AuthorizedSend")
305            .field("module", &self.module)
306            .field("approval_id", &self.approval_id)
307            .field("signed_transaction", &"[REDACTED]")
308            .finish()
309    }
310}
311
312impl AuthorizedSend {
313    pub fn new(
314        module: ModuleId,
315        approval_id: ApprovalId,
316        signed_transaction: Vec<u8>,
317    ) -> Result<Self, ChainError> {
318        validate_opaque(&signed_transaction)?;
319        Ok(Self {
320            module,
321            approval_id,
322            signed_transaction,
323        })
324    }
325
326    fn into_transaction(mut self) -> Vec<u8> {
327        core::mem::take(&mut self.signed_transaction)
328    }
329}
330
331#[derive(Clone, Debug, Eq, PartialEq)]
332pub struct BroadcastSend {
333    pub authorized: AuthorizedSend,
334}
335
336impl BroadcastSend {
337    pub fn into_transaction(self) -> Vec<u8> {
338        self.authorized.into_transaction()
339    }
340}
341
342#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
343pub struct BroadcastReceipt {
344    pub module: ModuleId,
345    pub txid: TransactionHash,
346    pub accepted_at_unix: u64,
347}
348
349#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
350pub struct Utxo {
351    pub txid: TransactionHash,
352    pub output_index: u32,
353    pub value: Amount,
354    pub confirmation_count: u32,
355    pub spendable: bool,
356}
357
358#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
359pub struct UtxoFeePolicy {
360    pub base_units_per_kweight: BaseUnits,
361    pub minimum_relay: BaseUnits,
362    pub dust_threshold: BaseUnits,
363}
364
365#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
366pub struct AccountFeePolicy {
367    pub base_fee_per_gas: BaseUnits,
368    pub priority_fee_per_gas: BaseUnits,
369    pub gas_limit: u64,
370}
371
372#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
373pub struct SettlementCapabilities {
374    pub module: ModuleId,
375    pub supported: bool,
376    pub minimum_confirmations: u32,
377    pub maximum_lock_bytes: u32,
378}
379
380/// Non-exportable per-session secp256k1 signing authority shared by the two
381/// native HTLC adapters. Implementations expose only a compressed public key
382/// and a purpose-supplied 32-byte transaction digest; the private scalar never
383/// crosses the wallet boundary.
384pub trait SettlementSigner {
385    fn compressed_public_key(&self) -> [u8; 33];
386
387    /// Return a canonical compact `(r || s)` ECDSA signature. Implementations
388    /// must normalize `s` into the lower half of the curve order.
389    fn sign_digest(&self, digest: [u8; 32]) -> Result<[u8; 64], SettlementSigningError>;
390}
391
392#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
393pub enum SettlementSigningError {
394    #[error("settlement signing key is invalid")]
395    InvalidKey,
396    #[error("settlement digest signing failed")]
397    SigningFailed,
398}
399
400#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
401pub struct HtlcLockRequest {
402    pub session_id: SessionId,
403    pub amount: Amount,
404    pub hashlock: ObjectHash,
405    pub receiver_key: Vec<u8>,
406    pub refund_key: Vec<u8>,
407    pub absolute_timelock: u64,
408    pub maximum_fee: BaseUnits,
409}
410
411#[derive(Clone, Debug, Eq, PartialEq)]
412pub struct PreparedHtlcLock(pub PreparedArtifact);
413
414#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
415pub struct VerifyHtlcLockRequest {
416    pub expected: SettlementLockExpectation,
417    pub funding_transaction: Vec<u8>,
418    pub confirmation_count: u32,
419}
420
421#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
422pub struct VerifiedHtlcLock(pub VerifiedLock);
423
424#[derive(Clone, Debug, Eq, PartialEq)]
425pub struct HtlcRedeemRequest {
426    pub session_id: SessionId,
427    pub lock: VerifiedLock,
428    pub preimage: Preimage,
429    pub maximum_fee: BaseUnits,
430}
431
432#[derive(Clone, Debug, Eq, PartialEq)]
433pub struct PreparedHtlcRedeem(pub PreparedArtifact);
434
435#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
436pub struct HtlcRefundRequest {
437    pub session_id: SessionId,
438    pub lock: VerifiedLock,
439    pub current_chain_time: u64,
440    pub maximum_fee: BaseUnits,
441}
442
443#[derive(Clone, Debug, Eq, PartialEq)]
444pub struct PreparedHtlcRefund(pub PreparedArtifact);
445
446#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
447pub struct MarketLockRequest(pub SettlementLockRequest);
448
449#[derive(Clone, Debug, Eq, PartialEq)]
450pub struct PreparedMarketLock(pub PreparedArtifact);
451
452#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
453pub struct VerifyMarketLockRequest(pub VerifySettlementLockRequest);
454
455#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
456pub struct VerifiedMarketLock(pub VerifiedLock);
457
458#[derive(Clone, Debug, Eq, PartialEq)]
459pub struct MarketRedeemRequest(pub SettlementRedeemRequest);
460
461#[derive(Clone, Debug, Eq, PartialEq)]
462pub struct PreparedMarketRedeem(pub PreparedArtifact);
463
464#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
465pub struct MarketRefundRequest(pub SettlementRefundRequest);
466
467#[derive(Clone, Debug, Eq, PartialEq)]
468pub struct PreparedMarketRefund(pub PreparedArtifact);
469
470#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
471pub struct SettlementLockRequest {
472    pub session_id: SessionId,
473    pub module: ModuleId,
474    pub amount: Amount,
475    pub hashlock: ObjectHash,
476    pub receiver: String,
477    pub refund_target: String,
478    pub absolute_timelock: u64,
479    pub maximum_fee: BaseUnits,
480}
481
482#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
483pub struct SettlementLockExpectation {
484    pub session_id: SessionId,
485    pub module: ModuleId,
486    pub amount: Amount,
487    pub hashlock: ObjectHash,
488    pub receiver: String,
489    pub refund_target: String,
490    pub absolute_timelock: u64,
491    pub minimum_confirmations: u32,
492}
493
494#[derive(Clone, Debug, Eq, PartialEq)]
495pub struct PreparedSettlementLock(pub PreparedArtifact);
496
497#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
498pub struct VerifySettlementLockRequest {
499    pub expected: SettlementLockExpectation,
500    pub transaction_or_receipt: Vec<u8>,
501    pub confirmation_count: u32,
502}
503
504#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
505pub struct VerifiedSettlementLock(pub VerifiedLock);
506
507#[derive(Clone, Debug, Eq, PartialEq)]
508pub struct SettlementRedeemRequest {
509    pub session_id: SessionId,
510    pub lock: VerifiedLock,
511    pub preimage: Preimage,
512    pub maximum_fee: BaseUnits,
513}
514
515#[derive(Clone, Debug, Eq, PartialEq)]
516pub struct PreparedSettlementRedeem(pub PreparedArtifact);
517
518#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
519pub struct SettlementRefundRequest {
520    pub session_id: SessionId,
521    pub lock: VerifiedLock,
522    pub current_chain_time: u64,
523    pub maximum_fee: BaseUnits,
524}
525
526#[derive(Clone, Debug, Eq, PartialEq)]
527pub struct PreparedSettlementRefund(pub PreparedArtifact);
528
529#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
530pub struct ObservePreimageRequest {
531    pub session_id: SessionId,
532    pub hashlock: ObjectHash,
533    pub spending_transaction: TransactionHash,
534}
535
536pub type ObserveSecretRequest = ObservePreimageRequest;
537
538#[derive(Clone, Eq, PartialEq)]
539pub struct PreparedArtifact {
540    pub module: ModuleId,
541    pub session_id: SessionId,
542    pub fee: BaseUnits,
543    pub expires_at_unix: u64,
544    payload: Vec<u8>,
545}
546
547impl core::fmt::Debug for PreparedArtifact {
548    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
549        formatter
550            .debug_struct("PreparedArtifact")
551            .field("module", &self.module)
552            .field("session_id", &self.session_id)
553            .field("fee", &self.fee)
554            .field("expires_at_unix", &self.expires_at_unix)
555            .field("payload", &"[REDACTED]")
556            .finish()
557    }
558}
559
560impl PreparedArtifact {
561    pub fn new(
562        module: ModuleId,
563        session_id: SessionId,
564        fee: BaseUnits,
565        expires_at_unix: u64,
566        payload: Vec<u8>,
567    ) -> Result<Self, ChainError> {
568        validate_opaque(&payload)?;
569        Ok(Self {
570            module,
571            session_id,
572            fee,
573            expires_at_unix,
574            payload,
575        })
576    }
577
578    pub fn commitment_bytes(&self) -> &[u8] {
579        &self.payload
580    }
581}
582
583#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
584pub struct VerifiedLock {
585    pub module: ModuleId,
586    pub session_id: SessionId,
587    pub funding_id: TransactionHash,
588    pub amount: Amount,
589    pub hashlock: ObjectHash,
590    pub absolute_timelock: u64,
591    pub confirmation_count: u32,
592    pub evidence_hash: ObjectHash,
593}
594
595#[derive(Clone, Eq, PartialEq, Zeroize, ZeroizeOnDrop)]
596pub struct Preimage([u8; 32]);
597
598impl Preimage {
599    pub const LENGTH: usize = 32;
600
601    pub const fn new(bytes: [u8; 32]) -> Self {
602        Self(bytes)
603    }
604
605    /// Exposes the secret only to a controlled settlement implementation. It
606    /// must never cross the Provider API or FFI.
607    pub fn expose_for_settlement(&self) -> &[u8; 32] {
608        &self.0
609    }
610}
611
612impl core::fmt::Debug for Preimage {
613    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
614        formatter.write_str("Preimage([REDACTED])")
615    }
616}
617
618#[derive(Clone, Debug, Eq, Error, PartialEq)]
619pub enum ChainError {
620    #[error("module is disabled")]
621    Disabled,
622    #[error("wallet is locked")]
623    Locked,
624    #[error("module is not synchronized")]
625    NotSynchronized,
626    #[error("capability is unsupported")]
627    Unsupported,
628    #[error("invalid request: {0}")]
629    InvalidRequest(&'static str),
630    #[error("approval is missing, stale, or mismatched")]
631    ApprovalRequired,
632    #[error("fee exceeds the approved maximum")]
633    FeeLimit,
634    #[error("arithmetic overflow")]
635    Overflow,
636    #[error("chain evidence is stale, missing, or contradictory")]
637    InvalidEvidence,
638    #[error("chain evidence is stale, missing, or contradictory during {0}")]
639    InvalidEvidenceContext(&'static str),
640    #[error("opaque transaction is empty or exceeds the bounded maximum")]
641    InvalidTransactionSize,
642    #[error("backend failed: {0}")]
643    Backend(String),
644}
645
646fn validate_opaque(bytes: &[u8]) -> Result<(), ChainError> {
647    if bytes.is_empty() || bytes.len() > MAX_OPAQUE_TRANSACTION_BYTES {
648        return Err(ChainError::InvalidTransactionSize);
649    }
650    Ok(())
651}
652
653#[cfg(test)]
654mod tests {
655    use super::*;
656    use hns_wallet_types::WalletAsset;
657
658    #[test]
659    fn send_requests_are_bounded() {
660        let request = SendRequest {
661            account: AccountId::default(),
662            destination: "x".repeat(MAX_DESTINATION_BYTES + 1),
663            amount: Amount::new(WalletAsset::Hns, 1),
664            maximum_fee: BaseUnits::new(1),
665            request_nonce: 1,
666        };
667        assert_eq!(
668            request.validate(),
669            Err(ChainError::InvalidRequest("invalid destination length"))
670        );
671    }
672
673    #[test]
674    fn signed_transaction_is_not_debug_exposed_and_is_bounded() {
675        let signed = AuthorizedSend::new(ModuleId::Handshake, ApprovalId::default(), vec![7; 32])
676            .expect("bounded transaction");
677        assert!(!format!("{signed:?}").contains("7, 7"));
678        assert!(
679            AuthorizedSend::new(
680                ModuleId::Handshake,
681                ApprovalId::default(),
682                vec![0; MAX_OPAQUE_TRANSACTION_BYTES + 1]
683            )
684            .is_err()
685        );
686    }
687
688    #[test]
689    fn preimage_debug_is_redacted() {
690        assert_eq!(
691            format!("{:?}", Preimage::new([9; 32])),
692            "Preimage([REDACTED])"
693        );
694    }
695}