Skip to main content

ton_connect_core/
wallet_state.rs

1//! Address and public-key binding for TON Connect wallet state initialization.
2
3use 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/// Canonical standard-base64 encoding of a valid, single-root TON `StateInit` `BoC`.
13///
14/// TON Connect requires standard base64 here, not base64url. Validation happens
15/// at the wire boundary so later account checks cannot accidentally operate on
16/// arbitrary bytes or a multi-root `BoC`.
17#[derive(Clone, Eq, PartialEq)]
18pub struct WalletStateInit {
19    encoded: String,
20    boc: Vec<u8>,
21}
22
23impl WalletStateInit {
24    /// Creates a validated value from serialized `BoC` bytes.
25    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    /// Returns the canonical standard-base64 wire value.
35    #[must_use]
36    pub fn as_str(&self) -> &str {
37        &self.encoded
38    }
39
40    /// Returns the validated serialized `BoC` bytes.
41    #[must_use]
42    pub fn as_boc(&self) -> &[u8] {
43        &self.boc
44    }
45
46    /// Derives the raw account address for the supplied workchain.
47    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    /// Extracts a public key from a recognized standard wallet contract.
56    ///
57    /// `Ok(None)` means that the state is valid but its code is not one of the
58    /// standard wallet versions. A verifier can then use the protocol-defined
59    /// on-chain `get_public_key` fallback without conflating it with malformed
60    /// untrusted input.
61    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    /// Verifies address and advertised-key binding for a standard wallet.
80    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/// Standard wallet contract recognized by local `StateInit` inspection.
157#[derive(Clone, Copy, Debug, Eq, PartialEq)]
158pub enum StandardWalletVersion {
159    /// Wallet V1 revision 1.
160    V1R1,
161    /// Wallet V1 revision 2.
162    V1R2,
163    /// Wallet V1 revision 3.
164    V1R3,
165    /// Wallet V2 revision 1.
166    V2R1,
167    /// Wallet V2 revision 2.
168    V2R2,
169    /// Wallet V3 revision 1.
170    V3R1,
171    /// Wallet V3 revision 2.
172    V3R2,
173    /// Wallet V4 revision 1.
174    V4R1,
175    /// Wallet V4 revision 2.
176    V4R2,
177    /// Wallet V5 revision 1.
178    V5R1,
179    /// The wallet-engine contract with one-time public-key rotation.
180    Wallet,
181}
182
183/// Public state extracted from a recognized standard wallet `StateInit`.
184#[derive(Clone, Copy, Debug, Eq, PartialEq)]
185pub struct StandardWalletState {
186    version: StandardWalletVersion,
187    public_key: Ed25519PublicKey,
188}
189
190impl StandardWalletState {
191    /// Returns the recognized contract version.
192    #[must_use]
193    pub const fn version(&self) -> StandardWalletVersion {
194        self.version
195    }
196
197    /// Returns the public key parsed from the address-bound data cell.
198    #[must_use]
199    pub const fn public_key(&self) -> &Ed25519PublicKey {
200        &self.public_key
201    }
202}
203
204/// Failure to parse or authenticate a TON Connect wallet `StateInit`.
205#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
206pub enum WalletStateError {
207    /// The value is not canonical padded standard base64.
208    #[error("walletStateInit must be canonical padded standard base64")]
209    InvalidBase64,
210    /// The decoded value is not a valid single-root `BoC`.
211    #[error("walletStateInit must be a valid single-root BoC")]
212    InvalidBoc,
213    /// The root cell does not encode a complete `StateInit` value.
214    #[error("walletStateInit root has an invalid StateInit layout")]
215    InvalidStateInit,
216    /// The `StateInit` has no contract code.
217    #[error("walletStateInit has no code cell")]
218    MissingCode,
219    /// The `StateInit` has no contract data.
220    #[error("walletStateInit has no data cell")]
221    MissingData,
222    /// The contract code is not a locally recognized standard wallet.
223    #[error("walletStateInit uses an unsupported wallet contract")]
224    UnsupportedWalletCode,
225    /// The recognized wallet data cell does not match its version layout.
226    #[error("walletStateInit data does not match the recognized wallet version")]
227    InvalidWalletData,
228    /// The state hash does not equal the reported raw account hash.
229    #[error("walletStateInit does not derive the reported account address")]
230    AddressMismatch,
231    /// The wallet-advertised key differs from the key stored in `StateInit`.
232    #[error("wallet public key does not match walletStateInit")]
233    PublicKeyMismatch,
234}
235
236/// Failure while verifying a signed response against its connected account.
237#[derive(Clone, Debug, Eq, Error, PartialEq)]
238pub enum AccountVerificationError {
239    /// The account's `StateInit` did not establish a trusted address and key.
240    #[error(transparent)]
241    WalletState(#[from] WalletStateError),
242    /// The signed payload or Ed25519 key was invalid.
243    #[error(transparent)]
244    Signing(#[from] SigningError),
245    /// A `signData` result was produced for a different connected address.
246    #[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    // `library` is HashmapE: one presence bit and, when non-empty, one root
286    // reference. Its contents do not affect where standard wallet data stores
287    // the public key, but consuming it proves that the root is a full StateInit.
288    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    /// Ported from `tonkeeper/tongo/tonconnect/proof_test.go` at
654    /// `835e443188a680a08100c3a324f68369c1c4f400`.
655    #[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}