trident-sdk 0.1.0

SDK for Trident protocol
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

use alloy_contract::private::{Network, Provider};
use alloy_dyn_abi::TypedData;
use alloy_signer::{Signature, Signer};
use alloy_sol_types::private::Address;
use alloy_sol_types::{Eip712Domain, sol};

sol!(
    #[sol(rpc)]
    interface EIP712Contract {
        function eip712Domain()
            public
            view
            virtual
            returns (
                bytes1 fields,
                string memory name,
                string memory version,
                uint256 chainId,
                address verifyingContract,
                bytes32 salt,
                uint256[] memory extensions
            );
    }
);

#[derive(thiserror::Error, Debug)]
pub enum EIP712Error {
    #[allow(clippy::upper_case_acronyms)]
    #[error("ABI encode error: {0}")]
    ABI(#[from] alloy_dyn_abi::Error),
    #[error("Signer error: {0}")]
    Signer(#[from] alloy_signer::Error),
}

pub struct EIP712;

impl EIP712 {
    pub async fn query_domain<N: Network, P: Provider<N>>(
        provider: P,
        token: Address,
    ) -> alloy_contract::Result<Eip712Domain> {
        let eip712 = EIP712Contract::new(token, provider);
        let domain = eip712.eip712Domain().call().await?;
        Ok(Eip712Domain {
            chain_id: Some(domain.chainId),
            name: Some(domain.name.into()),
            verifying_contract: Some(domain.verifyingContract),
            version: Some(domain.version.into()),
            // salt is not present is Domain type_hash for EIP712 signature
            // salt: Some(domain.salt.into()),
            salt: None,
        })
    }

    pub async fn sign<S: Signer>(data: TypedData, signer: S) -> Result<Signature, EIP712Error> {
        let hash = data.eip712_signing_hash()?;
        let sig = signer.sign_hash(&hash).await?;
        Ok(sig)
    }
}