siwe 0.6.1

Rust implementation of EIP-4361: Sign In With Ethereum
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

use std::collections::BTreeMap;

use ethers::{
    abi::{Abi, Function, Param, ParamType, StateMutability},
    contract::{AbiError, ContractInstance},
    prelude::*,
};

use crate::VerificationError;

const METHOD_NAME: &str = "isValidSignature";

pub async fn verify_eip1271(
    address: [u8; 20],
    message_hash: &[u8; 32],
    signature: &[u8],
    provider: &Provider<Http>,
) -> Result<bool, VerificationError> {
    #[allow(deprecated)]
    let abi = Abi {
        constructor: None,
        functions: BTreeMap::from([(
            METHOD_NAME.to_string(),
            vec![Function {
                name: METHOD_NAME.to_string(),
                inputs: vec![
                    Param {
                        name: " _message".to_string(),
                        kind: ParamType::FixedBytes(32),
                        internal_type: Some("bytes32".to_string()),
                    },
                    Param {
                        name: " _signature".to_string(),
                        kind: ParamType::Bytes,
                        internal_type: Some("bytes".to_string()),
                    },
                ],
                outputs: vec![Param {
                    name: "".to_string(),
                    kind: ParamType::FixedBytes(4),
                    internal_type: Some("bytes4".to_string()),
                }],
                constant: None,
                state_mutability: StateMutability::View,
            }],
        )]),
        events: BTreeMap::new(),
        errors: BTreeMap::new(),
        receive: false,
        fallback: false,
    };

    let contract = ContractInstance::<&Provider<Http>, Provider<Http>>::new(address, abi, provider);

    match contract
        .method::<_, [u8; 4]>(
            METHOD_NAME,
            (*message_hash, Bytes::from(signature.to_owned())),
        )
        .unwrap()
        .call()
        .await
    {
        Ok(r) => Ok(r == [22, 38, 186, 126]),
        Err(ContractError::AbiError(AbiError::DecodingError(_))) => Ok(false),
        Err(e) => Err(VerificationError::ContractCall(e.to_string())),
    }
}