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#[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
380pub trait SettlementSigner {
385 fn compressed_public_key(&self) -> [u8; 33];
386
387 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 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}