nado-sdk 2.1.0

Official Rust SDK for the Nado Protocol API
Documentation 
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use core::fmt::Debug;
use std::str::FromStr;

use alloy::signers::local::PrivateKeySigner;
use alloy::signers::{Signer, SignerSync};
use alloy_primitives::Signature;
use alloy_primitives::{Address, B256, U256};
use eyre::Result;

use crate::eip712_alloy::NadoEip712;
use crate::tx::{domain, get_eip712_digest, EIP712Domain};

use crate::core::base::NadoBase;

pub struct NadoSigner<'a, V: NadoBase> {
    nado: &'a V,
}

impl<'a, V: NadoBase> NadoSigner<'a, V> {
    pub fn new(nado: &'a V) -> Self {
        Self { nado }
    }

    pub fn endpoint_digest<T: NadoEip712 + Send + Sync + Debug>(&self, tx: &T) -> Result<[u8; 32]> {
        let domain = self.endpoint_domain()?;
        Ok(get_eip712_digest(tx, &domain))
    }

    pub fn endpoint_signature<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        endpoint_tx: &T,
    ) -> Result<Vec<u8>> {
        let signature = if self.nado.is_rest_client() {
            self.endpoint_signature_base(endpoint_tx)?
        } else {
            self.endpoint_signature_concat(endpoint_tx)?
        };
        Ok(signature)
    }

    pub fn endpoint_signature_concat<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        endpoint_tx: &T,
    ) -> Result<Vec<u8>> {
        let mut ret = self.endpoint_signature_base(endpoint_tx)?;
        ret.extend(self.nado.address()?);
        Ok(ret)
    }

    fn endpoint_signature_base<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        endpoint_tx: &T,
    ) -> Result<Vec<u8>> {
        let domain = self.endpoint_domain()?;
        let signature = self.sign_with_domain(endpoint_tx, domain)?;
        Ok(signature.as_bytes().to_vec())
    }

    pub fn order_signature<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        product_id: u32,
        order_tx: &T,
    ) -> Result<Vec<u8>> {
        let signature = if self.nado.is_rest_client() {
            self.order_signature_base(product_id, order_tx)?
        } else {
            self.order_signature_concat(product_id, order_tx)?
        };
        Ok(signature)
    }

    pub fn order_signature_concat<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        product_id: u32,
        order_tx: &T,
    ) -> Result<Vec<u8>> {
        let mut ret = self.order_signature_base(product_id, order_tx)?;
        ret.extend(self.nado.address()?);
        Ok(ret)
    }

    fn order_signature_base<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        product_id: u32,
        order_tx: &T,
    ) -> Result<Vec<u8>> {
        let domain = self.order_domain(product_id)?;
        let signature = self.sign_with_domain(order_tx, domain)?;
        Ok(signature.as_bytes().to_vec())
    }

    fn sign_with_domain<T: NadoEip712 + Send + Sync + Debug>(
        &self,
        payload: &T,
        domain: EIP712Domain,
    ) -> Result<Signature> {
        let encoded = get_eip712_digest(payload, &domain);
        Ok(self.nado.wallet()?.sign_hash_sync(&B256::from(encoded))?)
    }

    fn endpoint_domain(&self) -> Result<EIP712Domain> {
        self.domain(self.nado.endpoint_addr())
    }

    pub fn order_domain(&self, product_id: u32) -> Result<EIP712Domain> {
        self.domain(Address::left_padding_from(
            &(product_id as u64).to_be_bytes(),
        ))
    }

    fn domain(&self, verifying_contract: Address) -> Result<EIP712Domain> {
        Ok(domain(self.nado.chain_id()?, verifying_contract))
    }
}

pub fn wallet_with_chain_id(private_key: &str, chain_id: U256) -> Result<PrivateKeySigner> {
    let wallet = PrivateKeySigner::from_str(private_key)?;
    Ok(wallet.with_chain_id(Some(chain_id.to::<u64>())))
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn wallet_with_chain_id_accepts_prefixed_and_unprefixed_keys() {
        let bare = "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
        let prefixed = format!("0x{bare}");
        let chain_id = U256::from(31_337u64);
        let expected_address =
            Address::from_str("0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266").unwrap();

        let bare_wallet = wallet_with_chain_id(bare, chain_id).unwrap();
        let prefixed_wallet = wallet_with_chain_id(&prefixed, chain_id).unwrap();

        assert_eq!(bare_wallet.address(), expected_address);
        assert_eq!(bare_wallet.address(), prefixed_wallet.address());
        assert_eq!(bare_wallet.chain_id(), Some(31_337));
        assert_eq!(prefixed_wallet.chain_id(), Some(31_337));
    }
}