name = "crunchy"

version = "0.2.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"

[[package]]

[[package]]

name = "hex"

version = "0.4.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

name = "tiny-keccak"

version = "2.0.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"

dependencies = [

 "crunchy",

]

[[package]]

[[package]]

name = "tinyvec"

version = "1.9.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"

dependencies = [

 "tinyvec_macros",

]

[[package]]

name = "tinyvec_macros"

version = "0.1.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

name = "unicode-normalization"

version = "0.1.24"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"

dependencies = [

 "tinyvec",

]

[[package]]

 "hex",

 "tiny-keccak",

 "unicode-normalization",

tiny-keccak = { version = "2.0.2", features = ["keccak"]}

unicode-normalization = "0.1.24"

hex = "0.4.3"

use tiny_keccak::{Hasher, Keccak};

use unicode_normalization::UnicodeNormalization;

use hex;

}

fn keccak256(data: &[u8]) -> [u8; 32] {

  let mut hasher = Keccak::v256();

  let mut output = [0u8; 32];

  hasher.update(data);

  hasher.finalize(&mut output);

  output

}

fn normalize_name(name: &str) -> String {

  name.nfkc().collect::<String>().to_lowercase()

}

fn namehash(name: &str) -> [u8; 32] {

  let normalized = normalize_name(name);

  let mut node = [0u8; 32];

  if normalized.is_empty(){

    return node;

  }

  let labels: Vec<&str> = normalized.split('.').collect();

  for label in labels.iter().rev() {

    let label_hash = keccak256(label.as_bytes());

    let mut combined = [0u8; 64];

    combined[0..32].copy_from_slice(&node);

    combined[32..64].copy_from_slice(&label_hash);

    node = keccak256(&combined);

  }

  node

async fn get_resolver_address(

  client: &Client,

  rpc_url: &str,

  namehash: [u8; 32]

) -> Result<String, Box<dyn Error>>{

  let registry_address = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";

  let namehash_hex = format!("0x{}", hex::encode(namehash));

  let data = format!("0x0178b8bf{}", &namehash_hex[2..]);

  let request_data = serde_json::json!({

    "jsonrpc": "2.0",

    "method": "eth_call",

    "params": [

      {

        "to": registry_address,

        "data": data

      },

      "latest"

    ],

    "id": 1

  });

  let response = client.post(rpc_url)

    .json(&request_data)

    .send()

    .await?;

  let status = response.status();

  if !status.is_success(){

    let error_text = response.text().await?;

    return Err(format!("HTTP error {}: {}", status, error_text).into());

  }

  let response_text = response.text().await?;

  let response_body: JsonRpcResponse = serde_json::from_str(&response_text)?;

  if response_body.result == "0x0000000000000000000000000000000000000000" {

    return Err("No resolver found for this name".into());

  }

  let address = format!("0x{}", &response_body.result[26..]);

  Ok(address)

}

async fn resolve_ens_address(

  client: &Client,

  rpc_url: &str,

  resolver_address: &str,

  namehash: [u8; 32]

) -> Result<String, Box<dyn Error>>{

  let namehash_hex = format!("0x{}", hex::encode(namehash));

  println!("Namehash hex: {}", namehash_hex);

  let data = format!("0x3b3b57de{}", &namehash_hex[2..]);

  let request_data = serde_json::json!({

    "jsonrpc": "2.0",

    "method": "eth_call",

    "params": [

      {

        "to": resolver_address,

        "data": data

      },

      "latest"

    ],

    "id": 1

  });

  let response = client.post(rpc_url)

    .json(&request_data)

    .send()

    .await?;

  let status = response.status();

  if !status.is_success(){

    let error_text = response.text().await?;

    return Err(format!("HTTP error {}: {}", status, error_text).into());

  }

  let response_text = response.text().await?;

  let response_body: JsonRpcResponse = serde_json::from_str(&response_text)?;

  if response_body.result == "0x0000000000000000000000000000000000000000" {

    return Err("No address found for this name".into());

  }

  let address = format!("0x{}", &response_body.result[26..]);

  Ok(address)

}

async fn resolve_address_or_ens(

  client: &Client,

  input: &str,

  networks: &HashMap<u64, Network>

) -> Result<String, Box<dyn Error>> {

  if input.to_lowercase().ends_with(".eth"){

    let mainnet = networks.get(&1);

    if let Some(network) = mainnet {

      let namehash = namehash(input);

      let resolver_address = get_resolver_address(client, &network.rpc_url, namehash).await?;

      println!("Resolver address: {}", resolver_address);

      let eth_address = resolve_ens_address(client, &network.rpc_url, &resolver_address, namehash).await?;

      return Ok(eth_address);

    } else {

      return Err("Ethereum mainnet configuration not found for ENS resolution".into());

    }

  } else {

    if !input.starts_with("0x") || input.len() != 42 {

      return Err("Invalid Ethereum address format".into());

    }

    Ok(input.to_string())

  }

}

    let input = match matches.get_one::<String>("address"){

    let client = Client::new();

    let address = resolve_address_or_ens(&client, &input, &networks).await?;