mtv_crypto/

authenticator.rs

use chrono::{DateTime, Utc};
use futures::future::BoxFuture;
use thiserror::Error;
use web3::{
    signing::{hash_message, recover, RecoveryError},
    Error as Web3Error, RequestId, Transport, Web3,
};

use crate::{
    account::{Address, PersonalSignature},
    chain::{AuthChain, AuthLink},
    util::{rpc_call_is_valid_signature, RPCCallError},
    Identity,
};

#[derive(Debug, Error, PartialEq)]
pub enum AuthenticatorError {
    #[error("malformed authchain: expecting at least 2 links, but is empty")]
    EmptyChain,

    #[error("malformed authchain: expecting SIGNER at position {position}, but found {found}")]
    SignerExpected { position: usize, found: String },

    #[error("malformed authchain: expecting ECDSA_EPHEMERAL or ECDSA_EIP_1654_EPHEMERAL at position {position}, but found {found}")]
    EphemeralExpected { position: usize, found: String },

    #[error("malformed authchain: expecting ECDSA_SIGNED_ENTITY or ECDSA_EIP_1654_SIGNED_ENTITY at position {position}, but found {found}")]
    SignedEntityExpected { position: usize, found: String },

    #[error("malformed authchain: expecting ECDSA_SIGNED_ENTITY or ECDSA_EIP_1654_SIGNED_ENTITY")]
    SignedEntityMissing,

    #[error("fail to validate {kind} at position {position}: {message}")]
    ValidationError {
        position: usize,
        kind: String,
        message: String,
    },

    #[error("unexpected authority at position {position}: expected {expected}, but found {found}")]
    UnexpectedSigner {
        position: usize,
        expected: Address,
        found: Address,
    },

    #[error(
        "unexpected last authority at position {position}: expected {expected}, but found {found}"
    )]
    UnexpectedLastAuthority {
        position: usize,
        expected: String,
        found: String,
    },

    #[error("expired entity {kind} at position {position}")]
    ExpiredEntity { position: usize, kind: String },
}

#[derive(Debug, Clone)]
pub struct WithoutTransport {}
impl Transport for WithoutTransport {
    type Out = BoxFuture<'static, Result<serde_json::Value, Web3Error>>;

    fn prepare(
        &self,
        _method: &str,
        _params: Vec<serde_json::Value>,
    ) -> (usize, jsonrpc_core::types::request::Call) {
        unimplemented!()
    }

    fn send(&self, _id: RequestId, _request: jsonrpc_core::Call) -> Self::Out {
        unimplemented!()
    }
}

/// Validates a message and has correspond to an address.
///
/// ```rust
/// use mtv_crypto::authenticator::Authenticator;
/// use mtv_crypto::account::Address;
/// use mtv_crypto::chain::AuthChain;
///
/// # tokio_test::block_on(async {
///     let authenticator = Authenticator::new();
///
///     let chain = AuthChain::from_json(r#"[
///        {
///            "type": "SIGNER",
///            "payload": "0x13FE90239bfda363eC33a849b716616958c04f0F",
///            "signature": ""
///        },
///        {
///            "type": "ECDSA_EPHEMERAL",
///            "payload": "Memetaverse Login\nEphemeral address: 0x68560651BD91509EB22b90f6F748422A26CA3425\nExpiration: 8020-07-29T01:23:42.610Z",
///            "signature": "0xed50177b6d0607ef94e4dd507e99387624dfd480d781073ba7462240edfc930b64347f1e46d5db22bcd55f7e94c788415a0ac195928fb308b728d57c1c9b93b41c"
///        },
///        {
///            "type": "ECDSA_SIGNED_ENTITY",
///            "payload": "test",
///            "signature": "0xc2542c9344635322aab27d0acf94c4d27fde0ac9d8ba4e760312703d6aeb519f5ed23c3291247375d74c4a7f057b75ec76ae8bdf25a499279044cc04bda159201c"
///        }
///     ]"#).unwrap();
///
///     let address =  Address::try_from("0x13fe90239bfda363ec33a849b716616958c04f0f").unwrap();
///     let owner =  chain.owner().unwrap();
///     let result = authenticator.verify_signature(&chain, "test").await.unwrap();
///     assert_eq!(result, &address);
///     assert_eq!(result, owner);
/// # })
/// ```
pub struct Authenticator<T> {
    transport: Option<T>,
}

impl Authenticator<()> {
    pub fn new() -> Authenticator<WithoutTransport> {
        Authenticator { transport: None }
    }

    pub fn with_transport<T: Transport>(transport: T) -> Authenticator<T> {
        Authenticator {
            transport: Some(transport),
        }
    }
}

impl Authenticator<WithoutTransport> {
    pub fn add_transport<T: Transport>(&self, transport: T) -> Authenticator<T> {
        Authenticator {
            transport: Some(transport),
        }
    }
}

impl<T: Transport> Authenticator<T> {
    async fn validate_eip1654(
        &self,
        address: Address,
        message: String,
        hash: Vec<u8>,
    ) -> Result<bool, RPCCallError> {
        if let Some(transport) = &self.transport {
            rpc_call_is_valid_signature(&Web3::new(transport).eth(), address, message, hash).await
        } else {
            Err(RPCCallError::NotImplemented)
        }
    }
    /// Validates a message and has correspond to an address.
    ///
    /// ```
    /// use mtv_crypto::authenticator::Authenticator;
    /// use mtv_crypto::account::{Address, PersonalSignature};
    ///
    /// # tokio_test::block_on(async {
    ///     let address = Address::try_from("0x13FE90239bfda363eC33a849b716616958c04f0F").unwrap();
    ///     let message = "Memetaverse Login\nEphemeral address: 0x68560651BD91509EB22b90f6F748422A26CA3425\nExpiration: 8020-07-28T11:11:08.989Z";
    ///     let hash = PersonalSignature::try_from("0xaf237ccf4690d21c671c03a65aae48d1cbf94afdcfa3ed7569c20eb5769f2e273d4249c19e4a138acf063e5dff2b925e78a6c057fa864737ebaf65d9f1f464741c").unwrap().to_vec();
    ///
    ///     let result = Authenticator::new().validate_personal(&address, &message, &hash).unwrap();
    ///     assert_eq!(result, true);
    /// # })
    /// ```
    pub fn validate_personal<M: AsRef<[u8]>>(
        &self,
        address: &Address,
        message: M,
        hash: &[u8],
    ) -> Result<bool, RecoveryError> {
        if hash.len() != 65 {
            return Err(RecoveryError::InvalidSignature);
        }

        let signature = &hash[..64];
        let recovery_id = &hash[64];

        let recovery_number = (recovery_id - 27) as i32;
        let h160 = recover(hash_message(message).as_bytes(), signature, recovery_number)?;

        Ok(address == h160)
    }

    /// Verifies that and authlink is a signer and returns it as result. Otherwise, returns an error.
    async fn verify_signer<'a>(
        &self,
        link: &'a AuthLink,
        position: usize,
    ) -> Result<&'a Address, AuthenticatorError> {
        match link {
            AuthLink::Signer { payload, .. } => Ok(payload),
            _ => Err(AuthenticatorError::SignerExpected {
                position,
                found: link.kind().to_string(),
            }),
        }
    }

    /// Verifies:
    /// - the authlink is an ephemeral link (personal or eip1654)
    /// - the ephemeral link is not expired
    /// - the ephemeral payload is valid
    /// - the ephemeral signature corresponds to the authority
    ///
    /// returns the address defined in the ephemeral payload, otherwise returns an error.
    async fn verify_ephemeral<'a, 'l, 'd>(
        &self,
        authority: &'a Address,
        link: &'l AuthLink,
        expiration: &'d DateTime<Utc>,
        position: usize,
    ) -> Result<&'l Address, AuthenticatorError> {
        match link {
            AuthLink::EcdsaPersonalEphemeral { payload, signature } => {
                if payload.is_expired_at(expiration) {
                    return Err(AuthenticatorError::ExpiredEntity {
                        position,
                        kind: link.kind().to_string(),
                    });
                }

                let result = self
                    .validate_personal(authority, payload.to_string(), signature.as_ref())
                    .map_err(|err| AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: err.to_string(),
                    })?;

                if !result {
                    return Err(AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: format!(
                            "Signature {} couldn't be validated against address {}",
                            signature, authority
                        ),
                    });
                }

                Ok(&payload.address)
            }
            AuthLink::EcdsaEip1654Ephemeral { payload, signature } => {
                if payload.is_expired_at(expiration) {
                    return Err(AuthenticatorError::ExpiredEntity {
                        position,
                        kind: link.kind().to_string(),
                    });
                }

                let result = self
                    .validate_eip1654(*authority, payload.to_string(), signature.to_vec())
                    .await
                    .map_err(|err| AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: err.to_string(),
                    })?;

                if !result {
                    return Err(AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: format!(
                            "Signature {} couldn't be validated against address {}",
                            signature, authority
                        ),
                    });
                }

                Ok(&payload.address)
            }
            _ => Err(AuthenticatorError::EphemeralExpected {
                position,
                found: link.kind().to_string(),
            }),
        }
    }

    /// Verifies:
    /// - the authlink is an ephemeral link (personal or eip1654)
    /// - the ephemeral link is not expired
    /// - the ephemeral signature corresponds to the authority
    ///
    /// returns the signed payload, otherwise returns an error.
    async fn verify_signed_entity<'a>(
        &self,
        authority: &'a Address,
        link: &'a AuthLink,
        position: usize,
    ) -> Result<&'a str, AuthenticatorError> {
        match link {
            AuthLink::EcdsaPersonalSignedEntity { payload, signature } => {
                let result = self
                    .validate_personal(authority, payload, signature.as_ref())
                    .map_err(|err| AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: err.to_string(),
                    })?;

                if !result {
                    return Err(AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: format!(
                            "Signature {} couldn't be validated against address {}",
                            signature, authority
                        ),
                    });
                }

                Ok(payload)
            }
            AuthLink::EcdsaEip1654SignedEntity { payload, signature } => {
                let result = self
                    .validate_eip1654(*authority, payload.to_string(), signature.to_vec())
                    .await
                    .map_err(|err| AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: err.to_string(),
                    })?;

                if !result {
                    return Err(AuthenticatorError::ValidationError {
                        position,
                        kind: link.kind().to_string(),
                        message: format!(
                            "Signature {} couldn't be validated against address {}",
                            signature, authority
                        ),
                    });
                }

                Ok(payload)
            }
            _ => Err(AuthenticatorError::SignedEntityExpected {
                position,
                found: link.kind().to_string(),
            }),
        }
    }

    /// Verifies and authchain is valid, not expired at a given date and corresponds to the last_authority, otherwise, returns an error.
    pub async fn verify_signature_at<'a>(
        &self,
        chain: &'a AuthChain,
        last_authority: &str,
        expiration: &DateTime<Utc>,
    ) -> Result<&'a Address, AuthenticatorError> {
        let owner = match chain.first() {
            Some(link) => self.verify_signer(link, 0).await?,
            None => return Err(AuthenticatorError::EmptyChain),
        };

        let len = chain.len();
        let mut latest_authority = owner;
        for (position, link) in chain.iter().enumerate().skip(1) {
            // is not the last link
            if position != len - 1 {
                latest_authority = self
                    .verify_ephemeral(latest_authority, link, expiration, position)
                    .await?;

                // is the last link
            } else {
                let signed_message = self
                    .verify_signed_entity(latest_authority, link, position)
                    .await?;

                if signed_message == last_authority {
                    return Ok(owner);
                } else {
                    return Err(AuthenticatorError::UnexpectedLastAuthority {
                        position,
                        found: signed_message.to_string(),
                        expected: last_authority.to_string(),
                    });
                }
            }
        }

        Err(AuthenticatorError::SignedEntityMissing)
    }

    /// Verifies and authchain is valid, not expired and corresponds to the last_authority, otherwise, returns an error.
    pub async fn verify_signature<'a>(
        &self,
        chain: &'a AuthChain,
        last_authority: &str,
    ) -> Result<&'a Address, AuthenticatorError> {
        let now = &Utc::now();
        self.verify_signature_at(chain, last_authority, now).await
    }

    /// Creates a personal signature from a given identity and payload.
    /// This method is intended to maintain parity with the [JS implementation](https://github.com/memetaverseproject/memetaverse-crypto/blob/680d7cceb52a75bfae38269005614e577f48561a/src/Authenticator.ts#L185).
    pub fn create_signature<M: AsRef<str>>(
        &self,
        identity: &Identity,
        payload: M,
    ) -> PersonalSignature {
        identity.create_signature(payload)
    }

    /// Creates an authchain from a given identity and payload.
    /// This method is intended to maintain parity with the [JS implementation](https://github.com/memetaverseproject/memetaverse-crypto/blob/680d7cceb52a75bfae38269005614e577f48561a/src/Authenticator.ts#L171).
    pub fn sign_payload<M: AsRef<str>>(&self, identity: &Identity, payload: M) -> AuthChain {
        identity.sign_payload(payload)
    }
}

#[cfg(test)]
mod test {
    use crate::account::{Account, Signer};

    use super::*;

    #[tokio::test]
    async fn test_should_validate_personal_signature() {
        let authenticator = Authenticator::new();
        let chain = AuthChain::from_json(r#"[
                {
                    "type": "SIGNER",
                    "payload": "0x13FE90239bfda363eC33a849b716616958c04f0F",
                    "signature": ""
                },
                {
                    "type": "ECDSA_EPHEMERAL",
                    "payload": "Memetaverse Login\nEphemeral address: 0x68560651BD91509EB22b90f6F748422A26CA3425\nExpiration: 8020-07-28T07:42:51.682Z",
                    "signature": "0xea55d3fcf473eec78b240609e0f091f8c4f888fa03a4f4f42a1f27539dd355763677c56cbfb5f4cf77c9286d7782d39fbbf7eb4b9af9dab2f4d153707d497f591b"
                },
                {
                    "type": "ECDSA_SIGNED_ENTITY",
                    "payload": "test",
                    "signature": "0xc2542c9344635322aab27d0acf94c4d27fde0ac9d8ba4e760312703d6aeb519f5ed23c3291247375d74c4a7f057b75ec76ae8bdf25a499279044cc04bda159201c"
                }
        ]"#).unwrap();

        let owner = authenticator
            .verify_signature(&chain, "test")
            .await
            .unwrap();
        let expected = &Address::try_from("0x13fe90239bfda363ec33a849b716616958c04f0f").unwrap();
        assert_eq!(owner, expected);
    }

    // #[tokio::test]
    // async fn test_should_validate_eip_1654_signatures() {
    //     let endpoint = env::var("ETHEREUM_MAINNET_RPC").unwrap();
    //     let transport = web3::transports::Http::new(&endpoint).unwrap();
    //     let authenticator = Authenticator::with_transport(&transport);
    //     let chain = AuthChain::from_json(r#"[
    //         {
    //           "type": "SIGNER",
    //           "payload": "0x8C889222833F961FC991B31d15e25738c6732930",
    //           "signature": ""
    //         },
    //         {
    //           "type": "ECDSA_EIP_1654_EPHEMERAL",
    //           "payload": "Memetaverse Login\nEphemeral address: 0x4A1b9FD363dE915145008C41FA217377B2C223F2\nExpiration: 2123-03-18T16:59:36.515Z",
    //           "signature": "0x00050203596af90cecdbf9a768886e771178fd5561dd27ab005d000100019dde76f11e2c6aff01f6548f3046a9d0c569e13e79dec4218322068d3123e1162167fabd84dccfaabd350b93d2405f7b8a9cef4846b4d9a55d17838809a0e2591b020101c50adeadb7fe15bee45dcb820610cdedcd314eb0030102640dccefda3685e6c0dbeb70c1cf8018c27077eb00021cfbe892a1b29ac5e2fda1038c7965656be94aec57b658582f16447089bcf50b09df216a7e21d861cd7474723a7bfc70bf1caa55a962476cf78eb4b54471018b1b020103d9e87370ededc599df3bf9dd0e48586005f1a1bb"
    //         },
    //         {
    //           "type": "ECDSA_SIGNED_ENTITY",
    //           "payload": "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo",
    //           "signature": "0xb962b57accc8e12083769339888f82752d13f280012b2c7b2aa2722eae103aea7a623dc88605bf7036ec8c23b0bb8f036b52f5e4e30ee913f6f2a077d5e5e3e01b"
    //         }
    //       ]"#).unwrap();

    //     let owner = authenticator
    //         .verify_signature(&chain, "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo")
    //         .await
    //         .unwrap();
    //     let expected = &Address::try_from("0x8C889222833F961FC991B31d15e25738c6732930").unwrap();
    //     assert_eq!(owner, expected);
    // }

    #[tokio::test]
    async fn test_should_validate_simple_personal_signatures() {
        let authenticator = Authenticator::new();
        let signer = Address::try_from("0x68560651BD91509EB22b90f6F748422A26CA3425").unwrap();
        let payload = "test";
        let signature = "0xc2542c9344635322aab27d0acf94c4d27fde0ac9d8ba4e760312703d6aeb519f5ed23c3291247375d74c4a7f057b75ec76ae8bdf25a499279044cc04bda159201c";
        let chain = AuthChain::simple(signer, payload, signature).unwrap();

        let owner = authenticator
            .verify_signature(&chain, "test")
            .await
            .unwrap();
        let expected = &Address::try_from("0x68560651BD91509EB22b90f6F748422A26CA3425").unwrap();
        assert_eq!(owner, expected);
    }

    // #[tokio::test]
    // async fn test_should_validate_simple_eip_1654_signatures() {
    //     let endpoint = env::var("ETHEREUM_MAINNET_RPC").unwrap();
    //     let transport = web3::transports::Http::new(&endpoint).unwrap();
    //     let authenticator = Authenticator::with_transport(&transport);

    //     let signer = Address::try_from("0x68560651BD91509EB22b90f6F748422A26CA3425").unwrap();
    //     let payload = "test";
    //     let signature = "0xed50177b6d0607ef94e4dd507e99387624dfd480d781073ba7462240edfc930b64347f1e46d5db22bcd55f7e94c788415a0ac195928fb308b728d57c1c9b93b41c";
    //     let chain = AuthChain::simple(signer, payload, signature).unwrap();

    //     let owner = authenticator
    //         .verify_signature(&chain, "test")
    //         .await
    //         .unwrap();
    //     let expected = &Address::try_from("0x68560651BD91509EB22b90f6F748422A26CA3425").unwrap();
    //     assert_eq!(owner, expected);
    // }

    #[tokio::test]
    async fn test_should_support_r_on_personal_signatures() {
        let authenticator = Authenticator::new();
        let chain = AuthChain::from_json(r#"[
            {
                "type": "SIGNER",
                "payload": "0x13FE90239bfda363eC33a849b716616958c04f0F",
                "signature": ""
            },
            {
                "type": "ECDSA_EPHEMERAL",
                "payload": "Memetaverse Login\nEphemeral address: 0x68560651BD91509EB22b90f6F748422A26CA3425\nExpiration: 8020-07-29T01:23:42.610Z",
                "signature": "0xed50177b6d0607ef94e4dd507e99387624dfd480d781073ba7462240edfc930b64347f1e46d5db22bcd55f7e94c788415a0ac195928fb308b728d57c1c9b93b41c"
            },
            {
                "type": "ECDSA_SIGNED_ENTITY",
                "payload": "test",
                "signature": "0xc2542c9344635322aab27d0acf94c4d27fde0ac9d8ba4e760312703d6aeb519f5ed23c3291247375d74c4a7f057b75ec76ae8bdf25a499279044cc04bda159201c"
            }
            ]"#).unwrap();

        let owner = authenticator
            .verify_signature(&chain, "test")
            .await
            .unwrap();
        let expected = &Address::try_from("0x13FE90239bfda363eC33a849b716616958c04f0F").unwrap();
        assert_eq!(owner, expected);
    }

    // #[tokio::test]
    // async fn test_should_support_r_on_eip_1654_signatures() {
    //     let endpoint = env::var("ETHEREUM_MAINNET_RPC").unwrap();
    //     let transport = web3::transports::Http::new(&endpoint).unwrap();
    //     let authenticator = Authenticator::with_transport(&transport);
    //     let chain = AuthChain::from_json(r#"[
    //         {"type":"SIGNER","payload":"0x13FE90239bfda363eC33a849b716616958c04f0F","signature":""},
    //         {
    //           "type": "ECDSA_EIP_1654_EPHEMERAL",
    //           "payload": "Memetaverse Login\r\nEphemeral address: 0x4A1b9FD363dE915145008C41FA217377B2C223F2\r\nExpiration: 2123-03-18T16:59:36.515Z",
    //           "signature": "0x00050203596af90cecdbf9a768886e771178fd5561dd27ab005d000100019dde76f11e2c6aff01f6548f3046a9d0c569e13e79dec4218322068d3123e1162167fabd84dccfaabd350b93d2405f7b8a9cef4846b4d9a55d17838809a0e2591b020101c50adeadb7fe15bee45dcb820610cdedcd314eb0030102640dccefda3685e6c0dbeb70c1cf8018c27077eb00021cfbe892a1b29ac5e2fda1038c7965656be94aec57b658582f16447089bcf50b09df216a7e21d861cd7474723a7bfc70bf1caa55a962476cf78eb4b54471018b1b020103d9e87370ededc599df3bf9dd0e48586005f1a1bb"
    //         },
    //         {
    //           "type": "ECDSA_SIGNED_ENTITY",
    //           "payload": "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo",
    //           "signature": "0xb962b57accc8e12083769339888f82752d13f280012b2c7b2aa2722eae103aea7a623dc88605bf7036ec8c23b0bb8f036b52f5e4e30ee913f6f2a077d5e5e3e01b"
    //         }
    //       ]"#).unwrap();

    //     let owner = authenticator
    //         .verify_signature(&chain, "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo")
    //         .await
    //         .unwrap();
    //     let expected = &Address::try_from("0x8C889222833F961FC991B31d15e25738c6732930").unwrap();
    //     assert_eq!(owner, expected);
    // }

    // #[tokio::test]
    // async fn test_should_fail_it_tries_to_verify_a_eip_1654_signatures_without_a_transport() {
    //     let chain = AuthChain::from_json(r#"[
    //         {
    //           "type": "SIGNER",
    //           "payload": "0x8C889222833F961FC991B31d15e25738c6732930",
    //           "signature": ""
    //         },
    //         {
    //           "type": "ECDSA_EIP_1654_EPHEMERAL",
    //           "payload": "Memetaverse Login\r\nEphemeral address: 0x4A1b9FD363dE915145008C41FA217377B2C223F2\r\nExpiration: 2123-03-18T16:59:36.515Z",
    //           "signature": "0x00050203596af90cecdbf9a768886e771178fd5561dd27ab005d000100019dde76f11e2c6aff01f6548f3046a9d0c569e13e79dec4218322068d3123e1162167fabd84dccfaabd350b93d2405f7b8a9cef4846b4d9a55d17838809a0e2591b020101c50adeadb7fe15bee45dcb820610cdedcd314eb0030102640dccefda3685e6c0dbeb70c1cf8018c27077eb00021cfbe892a1b29ac5e2fda1038c7965656be94aec57b658582f16447089bcf50b09df216a7e21d861cd7474723a7bfc70bf1caa55a962476cf78eb4b54471018b1b020103d9e87370ededc599df3bf9dd0e48586005f1a1bb"
    //         },
    //         {
    //           "type": "ECDSA_SIGNED_ENTITY",
    //           "payload": "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo",
    //           "signature": "0xb962b57accc8e12083769339888f82752d13f280012b2c7b2aa2722eae103aea7a623dc88605bf7036ec8c23b0bb8f036b52f5e4e30ee913f6f2a077d5e5e3e01b"
    //         }
    //       ]"#).unwrap();

    //     let authenticator = Authenticator::new();
    //     let result = authenticator
    //         .verify_signature(&chain, "QmUsqJaHc5HQaBrojhBdjF4fr5MQc6CqhwZjqwhVRftNAo")
    //         .await;

    //     assert_eq!(result, Err(AuthenticatorError::ValidationError {
    //         position: 1,
    //         kind: "ECDSA_EIP_1654_EPHEMERAL".to_string(),
    //         message: "rpc resolver not implemented".to_string()
    //     }));
    // }

    #[tokio::test]
    async fn test_should_fail_if_ephemeral_is_expired() {
        let authenticator = Authenticator::new();
        let chain = AuthChain::from_json(r#"[
            {
              "type": "SIGNER",
              "payload": "0x13FE90239bfda363eC33a849b716616958c04f0F",
              "signature": ""
            },
            {
              "type": "ECDSA_EPHEMERAL",
              "payload": "Memetaverse Login\nEphemeral address: 0x68560651BD91509EB22b90f6F748422A26CA3425\nExpiration: 2024-07-23T02:25:06.771Z",
              "signature": "0xbde2dc9764a0f2aec6e320e0ad28c35c2582e88d31b66a0497cde58ac6d7ceb328f6123b2affeb1e4079f1fd178df711a41088054da174b5ccc80141c90db1c51b"
            },
            {
              "type": "ECDSA_SIGNED_ENTITY",
              "payload": "test",
              "signature": "0xc2542c9344635322aab27d0acf94c4d27fde0ac9d8ba4e760312703d6aeb519f5ed23c3291247375d74c4a7f057b75ec76ae8bdf25a499279044cc04bda159201c"
            }
          ]"#).unwrap();

        let result = authenticator
            .verify_signature(&chain, "test")
            .await;

        assert_eq!(
            result,
            Err(AuthenticatorError::ExpiredEntity {
                position: 1,
                kind: String::from("ECDSA_EPHEMERAL")
            })
        );

        let time = DateTime::parse_from_rfc3339("2020-01-01T00:00:00.000Z")
            .unwrap()
            .with_timezone(&Utc);
        let owner = authenticator
            .verify_signature_at(
                &chain,
                "test",
                &time,
            )
            .await
            .unwrap();

        let expected = &Address::try_from("0x13FE90239bfda363eC33a849b716616958c04f0F").unwrap();
        assert_eq!(owner, expected);
    }

    #[tokio::test]
    async fn test_should_recover_address_from_signature() {
        let account = Account::random();
        let payload = "QmWyFNeHbxXaPtUnzKvDZPpKSa4d5anZEZEFJ8TC1WgcfU";
        let signature = account.sign(payload);
        let authenticator = Authenticator::new();
        let result =
            authenticator.validate_personal(&account.address(), payload, &signature.to_vec());

        assert!(result.is_ok());
        assert!(result.unwrap());

        let chain = AuthChain::simple(account.address(), payload, signature.to_string()).unwrap();
        let owner = authenticator
            .verify_signature(&chain, payload)
            .await
            .unwrap();

        assert_eq!(owner, &account.address());
    }
}