1use std::fmt;
4
5use base64::{Engine as _, engine::general_purpose::STANDARD};
6use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
7use thiserror::Error;
8use ton_core::cell::{CellType, TonCell};
9
10use crate::{Ed25519PublicKey, RawAccountAddress, SigningError};
11
12#[derive(Clone, Eq, PartialEq)]
18pub struct WalletStateInit {
19 encoded: String,
20 boc: Vec<u8>,
21}
22
23impl WalletStateInit {
24 pub fn from_boc(boc: Vec<u8>) -> Result<Self, WalletStateError> {
26 let root = parse_root(&boc)?;
27 let _ = parse_state_init(&root)?;
28 Ok(Self {
29 encoded: STANDARD.encode(&boc),
30 boc,
31 })
32 }
33
34 #[must_use]
36 pub fn as_str(&self) -> &str {
37 &self.encoded
38 }
39
40 #[must_use]
42 pub fn as_boc(&self) -> &[u8] {
43 &self.boc
44 }
45
46 pub fn derive_address(&self, workchain: i32) -> Result<RawAccountAddress, WalletStateError> {
48 let root = parse_root(&self.boc)?;
49 let hash = root.hash().map_err(|_| WalletStateError::InvalidBoc)?;
50 let hash =
51 <[u8; 32]>::try_from(hash.as_slice()).map_err(|_| WalletStateError::InvalidBoc)?;
52 Ok(RawAccountAddress::new(workchain, hash))
53 }
54
55 pub fn extract_standard_public_key(
62 &self,
63 ) -> Result<Option<StandardWalletState>, WalletStateError> {
64 let root = parse_root(&self.boc)?;
65 let state = parse_state_init(&root)?;
66 let code = state.code.ok_or(WalletStateError::MissingCode)?;
67 let data = state.data.ok_or(WalletStateError::MissingData)?;
68 let version = version_from_code(&code)?;
69 version
70 .map(|version| {
71 extract_public_key(&data, version).map(|public_key| StandardWalletState {
72 version,
73 public_key,
74 })
75 })
76 .transpose()
77 }
78
79 pub fn verify_standard_wallet(
81 &self,
82 address: &RawAccountAddress,
83 advertised_public_key: &Ed25519PublicKey,
84 ) -> Result<StandardWalletState, WalletStateError> {
85 if self.derive_address(address.workchain())? != *address {
86 return Err(WalletStateError::AddressMismatch);
87 }
88 let state = self
89 .extract_standard_public_key()?
90 .ok_or(WalletStateError::UnsupportedWalletCode)?;
91 if state.public_key != *advertised_public_key {
92 return Err(WalletStateError::PublicKeyMismatch);
93 }
94 Ok(state)
95 }
96}
97
98impl fmt::Debug for WalletStateInit {
99 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
100 formatter
101 .debug_struct("WalletStateInit")
102 .field("boc_bytes", &self.boc.len())
103 .finish_non_exhaustive()
104 }
105}
106
107impl TryFrom<String> for WalletStateInit {
108 type Error = WalletStateError;
109
110 fn try_from(encoded: String) -> Result<Self, Self::Error> {
111 let boc = STANDARD
112 .decode(&encoded)
113 .map_err(|_| WalletStateError::InvalidBase64)?;
114 if STANDARD.encode(&boc) != encoded {
115 return Err(WalletStateError::InvalidBase64);
116 }
117 let root = parse_root(&boc)?;
118 let _ = parse_state_init(&root)?;
119 Ok(Self { encoded, boc })
120 }
121}
122
123impl TryFrom<&str> for WalletStateInit {
124 type Error = WalletStateError;
125
126 fn try_from(value: &str) -> Result<Self, Self::Error> {
127 Self::try_from(value.to_owned())
128 }
129}
130
131impl From<WalletStateInit> for String {
132 fn from(value: WalletStateInit) -> Self {
133 value.encoded
134 }
135}
136
137impl Serialize for WalletStateInit {
138 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
139 where
140 S: Serializer,
141 {
142 serializer.serialize_str(self.as_str())
143 }
144}
145
146impl<'de> Deserialize<'de> for WalletStateInit {
147 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
148 where
149 D: Deserializer<'de>,
150 {
151 let encoded = String::deserialize(deserializer)?;
152 Self::try_from(encoded).map_err(de::Error::custom)
153 }
154}
155
156#[derive(Clone, Copy, Debug, Eq, PartialEq)]
158pub enum StandardWalletVersion {
159 V1R1,
161 V1R2,
163 V1R3,
165 V2R1,
167 V2R2,
169 V3R1,
171 V3R2,
173 V4R1,
175 V4R2,
177 V5R1,
179 Wallet,
181}
182
183#[derive(Clone, Copy, Debug, Eq, PartialEq)]
185pub struct StandardWalletState {
186 version: StandardWalletVersion,
187 public_key: Ed25519PublicKey,
188}
189
190impl StandardWalletState {
191 #[must_use]
193 pub const fn version(&self) -> StandardWalletVersion {
194 self.version
195 }
196
197 #[must_use]
199 pub const fn public_key(&self) -> &Ed25519PublicKey {
200 &self.public_key
201 }
202}
203
204#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
206pub enum WalletStateError {
207 #[error("walletStateInit must be canonical padded standard base64")]
209 InvalidBase64,
210 #[error("walletStateInit must be a valid single-root BoC")]
212 InvalidBoc,
213 #[error("walletStateInit root has an invalid StateInit layout")]
215 InvalidStateInit,
216 #[error("walletStateInit has no code cell")]
218 MissingCode,
219 #[error("walletStateInit has no data cell")]
221 MissingData,
222 #[error("walletStateInit uses an unsupported wallet contract")]
224 UnsupportedWalletCode,
225 #[error("walletStateInit data does not match the recognized wallet version")]
227 InvalidWalletData,
228 #[error("walletStateInit does not derive the reported account address")]
230 AddressMismatch,
231 #[error("wallet public key does not match walletStateInit")]
233 PublicKeyMismatch,
234}
235
236#[derive(Clone, Debug, Eq, Error, PartialEq)]
238pub enum AccountVerificationError {
239 #[error(transparent)]
241 WalletState(#[from] WalletStateError),
242 #[error(transparent)]
244 Signing(#[from] SigningError),
245 #[error("signed response address differs from the connected account")]
247 ResponseAddressMismatch,
248}
249
250struct ParsedStateInit {
251 code: Option<TonCell>,
252 data: Option<TonCell>,
253}
254
255fn parse_root(boc: &[u8]) -> Result<TonCell, WalletStateError> {
256 crate::cell_boc::parse_single_root(boc).map_err(|_| WalletStateError::InvalidBoc)
257}
258
259fn parse_state_init(root: &TonCell) -> Result<ParsedStateInit, WalletStateError> {
260 if root.cell_type() != CellType::Ordinary {
261 return Err(WalletStateError::InvalidStateInit);
262 }
263
264 let mut parser = root.parser();
265 if parser
266 .read_bit()
267 .map_err(|_| WalletStateError::InvalidStateInit)?
268 {
269 let _ = parser
270 .read_bits(5)
271 .map_err(|_| WalletStateError::InvalidStateInit)?;
272 }
273 if parser
274 .read_bit()
275 .map_err(|_| WalletStateError::InvalidStateInit)?
276 {
277 let _ = parser
278 .read_bits(2)
279 .map_err(|_| WalletStateError::InvalidStateInit)?;
280 }
281
282 let code = read_optional_ref(&mut parser)?;
283 let data = read_optional_ref(&mut parser)?;
284
285 if parser
289 .read_bit()
290 .map_err(|_| WalletStateError::InvalidStateInit)?
291 {
292 let _ = parser
293 .read_next_ref()
294 .map_err(|_| WalletStateError::InvalidStateInit)?;
295 }
296 parser
297 .ensure_empty()
298 .map_err(|_| WalletStateError::InvalidStateInit)?;
299 Ok(ParsedStateInit { code, data })
300}
301
302fn read_optional_ref(
303 parser: &mut ton_core::cell::CellParser<'_>,
304) -> Result<Option<TonCell>, WalletStateError> {
305 if parser
306 .read_bit()
307 .map_err(|_| WalletStateError::InvalidStateInit)?
308 {
309 parser
310 .read_next_ref()
311 .cloned()
312 .map(Some)
313 .map_err(|_| WalletStateError::InvalidStateInit)
314 } else {
315 Ok(None)
316 }
317}
318
319fn version_from_code(code: &TonCell) -> Result<Option<StandardWalletVersion>, WalletStateError> {
320 let hash = code
321 .hash()
322 .map_err(|_| WalletStateError::InvalidStateInit)?;
323 let hash = hex::encode(hash.as_slice());
324 Ok(match hash.as_str() {
325 "a0cfc2c48aee16a271f2cfc0b7382d81756cecb1017d077faaab3bb602f6868c" => {
326 Some(StandardWalletVersion::V1R1)
327 }
328 "d4902fcc9fad74698fa8e353220a68da0dcf72e32bcb2eb9ee04217c17d3062c" => {
329 Some(StandardWalletVersion::V1R2)
330 }
331 "587cc789eff1c84f46ec3797e45fc809a14ff5ae24f1e0c7a6a99cc9dc9061ff" => {
332 Some(StandardWalletVersion::V1R3)
333 }
334 "5c9a5e68c108e18721a07c42f9956bfb39ad77ec6d624b60c576ec88eee65329" => {
335 Some(StandardWalletVersion::V2R1)
336 }
337 "fe9530d3243853083ef2ef0b4c2908c0abf6fa1c31ea243aacaa5bf8c7d753f1" => {
338 Some(StandardWalletVersion::V2R2)
339 }
340 "b61041a58a7980b946e8fb9e198e3c904d24799ffa36574ea4251c41a566f581" => {
341 Some(StandardWalletVersion::V3R1)
342 }
343 "84dafa449f98a6987789ba232358072bc0f76dc4524002a5d0918b9a75d2d599" => {
344 Some(StandardWalletVersion::V3R2)
345 }
346 "64dd54805522c5be8a9db59cea0105ccf0d08786ca79beb8cb79e880a8d7322d" => {
347 Some(StandardWalletVersion::V4R1)
348 }
349 "feb5ff6820e2ff0d9483e7e0d62c817d846789fb4ae580c878866d959dabd5c0" => {
350 Some(StandardWalletVersion::V4R2)
351 }
352 "20834b7b72b112147e1b2fb457b84e74d1a30f04f737d4f62a668e9552d2b72f" => {
353 Some(StandardWalletVersion::V5R1)
354 }
355 "99cca09ed5dfc604fbfe67e1d2d69a00ba74852b2365a23b49628b5633797898" => {
356 Some(StandardWalletVersion::Wallet)
357 }
358 _ => None,
359 })
360}
361
362fn extract_public_key(
363 data: &TonCell,
364 version: StandardWalletVersion,
365) -> Result<Ed25519PublicKey, WalletStateError> {
366 if data.cell_type() != CellType::Ordinary {
367 return Err(WalletStateError::InvalidWalletData);
368 }
369
370 let mut parser = data.parser();
371 let prefix_bits = match version {
372 StandardWalletVersion::V1R1
373 | StandardWalletVersion::V1R2
374 | StandardWalletVersion::V1R3
375 | StandardWalletVersion::V2R1
376 | StandardWalletVersion::V2R2 => 32,
377 StandardWalletVersion::V3R1
378 | StandardWalletVersion::V3R2
379 | StandardWalletVersion::V4R1
380 | StandardWalletVersion::V4R2 => 64,
381 StandardWalletVersion::V5R1 | StandardWalletVersion::Wallet => 65,
382 };
383 let _ = parser
384 .read_bits(prefix_bits)
385 .map_err(|_| WalletStateError::InvalidWalletData)?;
386
387 let mut public_key = [0_u8; 32];
388 parser
389 .read_bits_to(256, &mut public_key)
390 .map_err(|_| WalletStateError::InvalidWalletData)?;
391
392 if matches!(
393 version,
394 StandardWalletVersion::V4R1
395 | StandardWalletVersion::V4R2
396 | StandardWalletVersion::V5R1
397 | StandardWalletVersion::Wallet
398 ) && parser
399 .read_bit()
400 .map_err(|_| WalletStateError::InvalidWalletData)?
401 {
402 let _ = parser
403 .read_next_ref()
404 .map_err(|_| WalletStateError::InvalidWalletData)?;
405 }
406 if matches!(version, StandardWalletVersion::Wallet)
407 && parser
408 .read_bit()
409 .map_err(|_| WalletStateError::InvalidWalletData)?
410 {
411 return Err(WalletStateError::InvalidWalletData);
412 }
413 parser
414 .ensure_empty()
415 .map_err(|_| WalletStateError::InvalidWalletData)?;
416 Ok(Ed25519PublicKey::from_bytes(public_key))
417}
418
419#[cfg(test)]
420mod tests {
421 use std::error::Error;
422
423 use base64::engine::general_purpose::URL_SAFE;
424 use ed25519_dalek::{Signer as _, SigningKey};
425 use ton_core::traits::tlb::TLB as _;
426
427 use super::*;
428 use crate::{
429 Ed25519Signature, NetworkId, SignDataResult, SignDataSigningPayload, TonAddressItemReply,
430 TonProof, TonProofDomain, Uint64String, sign_data_signing_hash, ton_proof_signing_hash,
431 };
432
433 const PUBLIC_KEY: [u8; 32] = [0x5a; 32];
434 const V1R1_CODE: &str = include_str!("testdata/wallet_v1r1.code");
435 const V1R2_CODE: &str = include_str!("testdata/wallet_v1r2.code");
436 const V1R3_CODE: &str = include_str!("testdata/wallet_v1r3.code");
437 const V2R1_CODE: &str = include_str!("testdata/wallet_v2r1.code");
438 const V2R2_CODE: &str = include_str!("testdata/wallet_v2r2.code");
439 const V3R1_CODE: &str = include_str!("testdata/wallet_v3r1.code");
440 const V3R2_CODE: &str = include_str!("testdata/wallet_v3r2.code");
441 const V4R1_CODE: &str = include_str!("testdata/wallet_v4r1.code");
442 const V4R2_CODE: &str = include_str!("testdata/wallet_v4r2.code");
443 const V5R1_CODE: &str = include_str!("testdata/wallet_v5.code");
444 const WALLET_CODE: &str = include_str!("testdata/wallet_v5_experimental.code");
445
446 type TestResult = Result<(), Box<dyn Error>>;
447
448 fn standard_wallet(
449 code_boc: &str,
450 version: StandardWalletVersion,
451 ) -> Result<(WalletStateInit, RawAccountAddress), Box<dyn Error>> {
452 standard_wallet_with_key(code_boc, version, PUBLIC_KEY)
453 }
454
455 fn standard_wallet_with_key(
456 code_boc: &str,
457 version: StandardWalletVersion,
458 public_key: [u8; 32],
459 ) -> Result<(WalletStateInit, RawAccountAddress), Box<dyn Error>> {
460 let code = TonCell::from_boc_base64(code_boc.trim())?;
461 let data = wallet_data(version, public_key)?;
462 let root = state_init(code, data)?;
463 let state = WalletStateInit::from_boc(root.to_boc()?)?;
464 let address = state.derive_address(0)?;
465 Ok((state, address))
466 }
467
468 fn wallet_data(
469 version: StandardWalletVersion,
470 public_key: [u8; 32],
471 ) -> Result<TonCell, Box<dyn Error>> {
472 let mut builder = TonCell::builder();
473 match version {
474 StandardWalletVersion::V1R1
475 | StandardWalletVersion::V1R2
476 | StandardWalletVersion::V1R3
477 | StandardWalletVersion::V2R1
478 | StandardWalletVersion::V2R2 => {
479 builder.write_num(&0_u32, 32)?;
480 }
481 StandardWalletVersion::V3R1
482 | StandardWalletVersion::V3R2
483 | StandardWalletVersion::V4R1
484 | StandardWalletVersion::V4R2 => {
485 builder.write_num(&0_u32, 32)?;
486 builder.write_num(&0x29a9_a317_u32, 32)?;
487 }
488 StandardWalletVersion::V5R1 | StandardWalletVersion::Wallet => {
489 builder.write_bit(true)?;
490 builder.write_num(&0_u32, 32)?;
491 builder.write_num(&0x7fff_ff11_u32, 32)?;
492 }
493 }
494 builder.write_bits(public_key, 256)?;
495 if matches!(
496 version,
497 StandardWalletVersion::V4R1
498 | StandardWalletVersion::V4R2
499 | StandardWalletVersion::V5R1
500 | StandardWalletVersion::Wallet
501 ) {
502 builder.write_bit(false)?;
503 }
504 if matches!(version, StandardWalletVersion::Wallet) {
505 builder.write_bit(false)?;
506 }
507 Ok(builder.build()?)
508 }
509
510 fn state_init(code: TonCell, data: TonCell) -> Result<TonCell, Box<dyn Error>> {
511 let mut builder = TonCell::builder();
512 builder.write_bit(false)?;
513 builder.write_bit(false)?;
514 builder.write_bit(true)?;
515 builder.write_ref(code)?;
516 builder.write_bit(true)?;
517 builder.write_ref(data)?;
518 builder.write_bit(false)?;
519 Ok(builder.build()?)
520 }
521
522 #[test]
523 fn extracts_keys_from_every_standard_data_layout() -> TestResult {
524 let fixtures = [
525 (V1R1_CODE, StandardWalletVersion::V1R1),
526 (V1R2_CODE, StandardWalletVersion::V1R2),
527 (V1R3_CODE, StandardWalletVersion::V1R3),
528 (V2R1_CODE, StandardWalletVersion::V2R1),
529 (V2R2_CODE, StandardWalletVersion::V2R2),
530 (V3R1_CODE, StandardWalletVersion::V3R1),
531 (V3R2_CODE, StandardWalletVersion::V3R2),
532 (V4R1_CODE, StandardWalletVersion::V4R1),
533 (V4R2_CODE, StandardWalletVersion::V4R2),
534 (V5R1_CODE, StandardWalletVersion::V5R1),
535 (WALLET_CODE, StandardWalletVersion::Wallet),
536 ];
537
538 for (code, version) in fixtures {
539 let (state_init, address) = standard_wallet(code, version)?;
540 let advertised = Ed25519PublicKey::from_bytes(PUBLIC_KEY);
541 let verified = state_init.verify_standard_wallet(&address, &advertised)?;
542 assert_eq!(verified.version(), version);
543 assert_eq!(verified.public_key(), &advertised);
544
545 let json = serde_json::to_string(&state_init)?;
546 assert_eq!(serde_json::from_str::<WalletStateInit>(&json)?, state_init);
547 }
548 Ok(())
549 }
550
551 #[test]
552 fn address_and_advertised_key_are_independent_required_checks() -> TestResult {
553 let (state_init, address) = standard_wallet(V5R1_CODE, StandardWalletVersion::V5R1)?;
554 let wrong_address = RawAccountAddress::new(address.workchain(), [0x22; 32]);
555 assert_eq!(
556 state_init
557 .verify_standard_wallet(&wrong_address, &Ed25519PublicKey::from_bytes(PUBLIC_KEY)),
558 Err(WalletStateError::AddressMismatch)
559 );
560 assert_eq!(
561 state_init.verify_standard_wallet(&address, &Ed25519PublicKey::from_bytes([0x33; 32])),
562 Err(WalletStateError::PublicKeyMismatch)
563 );
564 Ok(())
565 }
566
567 #[test]
568 fn unknown_wallet_is_distinct_from_malformed_state() -> TestResult {
569 let mut code_builder = TonCell::builder();
570 code_builder.write_num(&7_u8, 8)?;
571 let code = code_builder.build()?;
572 let data = TonCell::builder().build()?;
573 let root = state_init(code, data)?;
574 let state_init = WalletStateInit::from_boc(root.to_boc()?)?;
575 let address = state_init.derive_address(0)?;
576
577 assert_eq!(state_init.extract_standard_public_key()?, None);
578 assert_eq!(
579 state_init.verify_standard_wallet(&address, &Ed25519PublicKey::from_bytes(PUBLIC_KEY)),
580 Err(WalletStateError::UnsupportedWalletCode)
581 );
582
583 let empty_cell = TonCell::builder().build()?;
584 assert_eq!(
585 WalletStateInit::from_boc(empty_cell.to_boc()?),
586 Err(WalletStateError::InvalidStateInit)
587 );
588 Ok(())
589 }
590
591 #[test]
592 fn wire_value_requires_canonical_standard_base64() -> TestResult {
593 let (state_init, _) = standard_wallet(V4R2_CODE, StandardWalletVersion::V4R2)?;
594 let encoded = state_init.as_str().to_owned();
595 assert_eq!(WalletStateInit::try_from(encoded.as_str())?, state_init);
596 assert_eq!(String::from(state_init.clone()), encoded);
597 assert!(format!("{state_init:?}").contains("boc_bytes"));
598 let url_safe = URL_SAFE.encode(state_init.as_boc());
599 assert_ne!(url_safe, state_init.as_str());
600 assert_eq!(
601 WalletStateInit::try_from(url_safe),
602 Err(WalletStateError::InvalidBase64)
603 );
604
605 let excessive_padding = format!("{}=", state_init.as_str());
606 assert_eq!(
607 WalletStateInit::try_from(excessive_padding),
608 Err(WalletStateError::InvalidBase64)
609 );
610 Ok(())
611 }
612
613 #[test]
614 fn ton_proof_verification_uses_the_state_bound_key() -> TestResult {
615 let signing_key = SigningKey::from_bytes(&[0x44; 32]);
616 let public_key = signing_key.verifying_key().to_bytes();
617 let (state_init, address) =
618 standard_wallet_with_key(V5R1_CODE, StandardWalletVersion::V5R1, public_key)?;
619 let account = TonAddressItemReply::new(
620 address,
621 NetworkId::try_from("-239")?,
622 state_init,
623 Ed25519PublicKey::from_bytes(public_key),
624 );
625 let timestamp = 1_800_000_000_u64;
626 let domain = "wallet.example";
627 let payload = "single-use challenge";
628 let hash = ton_proof_signing_hash(&address, domain, timestamp, payload)?;
629 let proof = TonProof {
630 timestamp: Uint64String::from(timestamp),
631 domain: TonProofDomain::new(domain.to_owned())?,
632 payload: payload.to_owned(),
633 signature: Ed25519Signature::from_bytes(signing_key.sign(&hash).to_bytes()),
634 };
635
636 assert!(proof.verify_with_account(&account)?);
637
638 let account_with_untrusted_key = TonAddressItemReply::new(
639 address,
640 NetworkId::try_from("-239")?,
641 account.wallet_state_init.clone(),
642 Ed25519PublicKey::from_bytes([0x77; 32]),
643 );
644 assert_eq!(
645 proof.verify_with_account(&account_with_untrusted_key),
646 Err(AccountVerificationError::WalletState(
647 WalletStateError::PublicKeyMismatch
648 ))
649 );
650 Ok(())
651 }
652
653 #[test]
656 fn tongo_v4_proofs_verify_against_the_state_bound_key() -> TestResult {
657 for (code, version, secret) in [
658 (V4R1_CODE, StandardWalletVersion::V4R1, [0x41_u8; 32]),
659 (V4R2_CODE, StandardWalletVersion::V4R2, [0x42_u8; 32]),
660 ] {
661 let signing_key = SigningKey::from_bytes(&secret);
662 let public_key = signing_key.verifying_key().to_bytes();
663 let (state_init, address) = standard_wallet_with_key(code, version, public_key)?;
664 let account = TonAddressItemReply::new(
665 address,
666 NetworkId::try_from("-3")?,
667 state_init,
668 Ed25519PublicKey::from_bytes(public_key),
669 );
670 let timestamp = 1_800_000_000_u64;
671 let payload = "some-random-secret";
672 let hash = ton_proof_signing_hash(&address, "web", timestamp, payload)?;
673 let mut proof = TonProof {
674 timestamp: Uint64String::from(timestamp),
675 domain: TonProofDomain::new("web".to_owned())?,
676 payload: payload.to_owned(),
677 signature: Ed25519Signature::from_bytes(signing_key.sign(&hash).to_bytes()),
678 };
679 assert!(proof.verify_with_account(&account)?);
680 proof.payload.push('x');
681 assert!(!proof.verify_with_account(&account)?);
682 }
683 Ok(())
684 }
685
686 #[test]
687 fn sign_data_verification_is_bound_to_the_connected_address() -> TestResult {
688 let signing_key = SigningKey::from_bytes(&[0x55; 32]);
689 let public_key = signing_key.verifying_key().to_bytes();
690 let (state_init, address) =
691 standard_wallet_with_key(V4R2_CODE, StandardWalletVersion::V4R2, public_key)?;
692 let account = TonAddressItemReply::new(
693 address,
694 NetworkId::try_from("-239")?,
695 state_init,
696 Ed25519PublicKey::from_bytes(public_key),
697 );
698 let timestamp = 1_800_000_001_u64;
699 let domain = "wallet.example";
700 let text = "Authorize this operation";
701 let hash = sign_data_signing_hash(
702 &address,
703 domain,
704 timestamp,
705 SignDataSigningPayload::Text(text),
706 )?;
707 let signature = signing_key.sign(&hash).to_bytes();
708 let result = serde_json::from_value::<SignDataResult>(serde_json::json!({
709 "signature": STANDARD.encode(signature),
710 "address": address.to_string(),
711 "timestamp": timestamp,
712 "domain": domain,
713 "payload": {
714 "type": "text",
715 "text": text,
716 "network": "-239",
717 "from": address.to_string()
718 }
719 }))?;
720
721 assert!(result.verify_with_account(&account)?);
722
723 let mut wrong_result = result;
724 wrong_result.address = RawAccountAddress::new(0, [0x66; 32]);
725 assert_eq!(
726 wrong_result.verify_with_account(&account),
727 Err(AccountVerificationError::ResponseAddressMismatch)
728 );
729 Ok(())
730 }
731}