transaction-decoder 0.1.13

use alloy::{
    primitives::{address, keccak256, Address, FixedBytes},
    providers::RootProvider,
    sol,
    transports::http::Http,
};
use reqwest::Client;
use serde::{Deserialize, Serialize};

sol!(
    /// ENS Registry interface used to get resolver.
    #[derive(Debug, Deserialize, Serialize)]
    #[allow(missing_docs)]
    #[sol(rpc)]
    interface ENSRegistry {
        function resolver(bytes32 node) external view returns(address);
    }
);

sol!(
        /// ENS Name interface used to resolve name from resolver.

    #[derive(Debug, Deserialize, Serialize)]
    #[allow(missing_docs)]
    #[sol(rpc)]
    interface ENSName {
        function name(bytes32 node) external view returns(string);
    }
);

/// Resolves the ENS name associated with an Ethereum address by reverse lookup.
///
/// # Arguments
/// * `address` - The address to resolve.
/// * `provider` - The RPC provider.
///
/// # Returns
/// The ENS name as an option if found.
pub async fn get_ens_name(
    address: Address,
    provider: &RootProvider<Http<Client>>,
) -> Option<String> {
    let addr_str = format!(
        "{}.addr.reverse",
        address.to_string().to_lowercase().trim_start_matches("0x")
    );

    let mut hash = vec![0u8; 32];
    for label in addr_str.rsplit(".") {
        hash.append(&mut keccak256(label.as_bytes()).to_vec());
        hash = keccak256(hash.as_slice()).to_vec();
    }

    let ens_registry = ENSRegistry::new(
        address!("00000000000C2E074eC69A0dFb2997BA6C7d2e1e"),
        &provider,
    );

    let resolver = ens_registry
        .resolver(FixedBytes::from_slice(&hash))
        .call()
        .await
        .unwrap()
        ._0;

    if resolver != Address::ZERO {
        let name_contract = ENSName::new(resolver, provider);

        let name = name_contract
            .name(FixedBytes::from_slice(&hash.as_slice()))
            .call()
            .await
            .unwrap()
            ._0;

        return Some(name);
    }

    None
}