defuse_core/payload/
nep413.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
use defuse_nep413::{Nep413Payload, SignedNep413Payload};
use impl_tools::autoimpl;
use near_sdk::{
    AccountId, near,
    serde::de::{self, DeserializeOwned},
    serde_json,
};

use crate::Deadline;

use super::{DefusePayload, ExtractDefusePayload};

#[near(serializers = [json])]
#[autoimpl(Deref using self.message)]
#[autoimpl(DerefMut using self.message)]
#[derive(Debug, Clone)]
pub struct Nep413DefuseMessage<T> {
    pub signer_id: AccountId,

    pub deadline: Deadline,

    #[serde(flatten)]
    pub message: T,
}

impl<T> ExtractDefusePayload<T> for Nep413Payload
where
    T: DeserializeOwned,
{
    type Error = serde_json::Error;

    fn extract_defuse_payload(self) -> Result<DefusePayload<T>, Self::Error> {
        let Nep413DefuseMessage {
            signer_id,
            deadline,
            message,
        } = serde_json::from_str(&self.message)?;

        Ok(DefusePayload {
            signer_id,
            verifying_contract: self.recipient.parse().map_err(|_| {
                de::Error::invalid_value(de::Unexpected::Str(&self.recipient), &"AccountId")
            })?,
            deadline,
            nonce: self.nonce,
            message,
        })
    }
}

impl<T> ExtractDefusePayload<T> for SignedNep413Payload
where
    T: DeserializeOwned,
{
    type Error = serde_json::Error;

    #[inline]
    fn extract_defuse_payload(self) -> Result<DefusePayload<T>, Self::Error> {
        self.payload.extract_defuse_payload()
    }
}