Migrate NonZeroU256 to alloy

[jmg-duarte]

Description

Migrates the NonZero type for U256 to alloy

Changes

• Renames U256 -> NonZeroU256 to avoid aliases and confusion
• Migrates a bunch of to_wei calls to a more verbose but explicit calculation
• Refactors call sites to alloy

How to test

Existing tests

[m-sz]

I am not sure about the inconsistencies with using to_wei -> U256::from(10).pow(U256::from(18)) instead of using eth

[MartinquaXD]

I'm not a huge fan of the introduction of alloy::utils::Unit. If there is already the effort being made to change all those values I think something like this would make the most sense.

That way we can just do 12.mwei() and 1234.44.eth().

use alloy::primitives::{
    U256,
    ruint::uint,
    utils::{ParseUnits, parse_units},
};

trait Unit: std::marker::Sized {
    fn wei(self) -> U256;
    fn mwei(self) -> U256 {
        const BASE: U256 = uint!(1_000_000_U256);
        self.wei() * BASE
    }
    fn gwei(self) -> U256 {
        const BASE: U256 = uint!(1_000_000_000_U256);
        self.wei() * BASE
    }
    fn eth(self) -> U256 {
        const BASE: U256 = uint!(1_000_000_000_000_000_000_U256);
        self.wei() * BASE
    }
}

impl Unit for u64 {
    fn wei(self) -> U256 {
        U256::from(self)
    }
}

impl Unit for u128 {
    fn wei(self) -> U256 {
        U256::from(self)
    }
}

impl Unit for f64 {
    fn wei(self) -> U256 {
        match parse_units(&self.to_string(), "wei").unwrap() {
            ParseUnits::U256(val) => val,
            _ => panic!("could not parse number as u256: {self}"),
        }
    }

    fn mwei(self) -> U256 {
        match parse_units(&self.to_string(), "mwei").unwrap() {
            ParseUnits::U256(val) => val,
            _ => panic!("could not parse number as u256: {self}"),
        }
    }

    fn gwei(self) -> U256 {
        match parse_units(&self.to_string(), "gwei").unwrap() {
            ParseUnits::U256(val) => val,
            _ => panic!("could not parse number as u256: {self}"),
        }
    }

    fn eth(self) -> U256 {
        match parse_units(&self.to_string(), "ether").unwrap() {
            ParseUnits::U256(val) => val,
            _ => panic!("could not parse number as u256: {self}"),
        }
    }
}

[MartinquaXD]

I'm fine with unifying the number values in a follow up PR.