refactor!: address mappings for conciseness (#80)

* refactor!: address mappings for conciseness

Refactored address mappings to use `AddressMap` and `from_iter` for brevity and readability. This change removes redundant code and improves maintainability. Adjusted constant definitions and function signatures accordingly.

* refactor(weth9): Simplify WETH9 tokens initialization

Replaced multiple `FxHashMap::insert` calls with `FxHashMap::from_iter` using a vector. This improves code readability and reduces redundancy.

* fix(clippy): Add #[inline] annotations to various functions

Inline annotations were added to functions across multiple modules to suggest the compiler to replace function calls with the function's body. This could potentially optimize runtime performance by reducing the overhead of function calls.

* fix(clippy): Enable additional Clippy lints and refactor assertions

Re-enable several Clippy lints for cleaner code validation. Refactor `panic!` calls to `assert!` for better consistency and clarity. Update function arguments to use references where appropriate.

* fix(clippy): Enable `clippy::must_use_candidate` lint

Uncommented the `clippy::must_use_candidate` lint and annotated essential functions with `#[must_use]` attribute. This increases code reliability by enforcing that critical return values are not ignored.

---------

Co-authored-by: malik <[email protected]>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "uniswap-sdk-core"
-version = "2.1.0"
+version = "2.2.0"
 edition = "2021"
 authors = ["malik <[email protected]>", "Shuhui Luo <twitter.com/aureliano_law>"]
 description = "The Uniswap SDK Core in Rust provides essential functionality for interacting with the Uniswap decentralized exchange"

src/chains.rs

@@ -1,3 +1,5 @@
+#![allow(non_camel_case_types)]
+
 /// Represents the unique identifier for different blockchain networks supported by the Uniswap SDK.
 ///
 /// Each variant corresponds to a specific blockchain network, identified by its unique chain ID.
@@ -12,23 +14,23 @@ pub enum ChainId {
     /// The Optimism network.
     OPTIMISM = 10,
     /// The Optimism Goerli Testnet.
-    OPTIMISMGOERLI = 420,
+    OPTIMISM_GOERLI = 420,
     /// The Optimism Sepolia Testnet.
-    OPTIMISMSEPOLIA = 11155420,
+    OPTIMISM_SEPOLIA = 11155420,
     /// The Arbitrum One network.
-    ARBITRUMONE = 42161,
+    ARBITRUM_ONE = 42161,
     /// The Arbitrum Goerli Testnet.
-    ARBITRUMGOERLI = 421613,
+    ARBITRUM_GOERLI = 421613,
     /// The Arbitrum Sepolia Testnet.
-    ARBITRUMSEPOLIA = 421614,
+    ARBITRUM_SEPOLIA = 421614,
     /// The Polygon network.
     POLYGON = 137,
     /// The Polygon Mumbai Testnet.
-    POLYGONMUMBAI = 80001,
+    POLYGON_MUMBAI = 80001,
     /// The Celo network.
     CELO = 42220,
     /// The Celo Alfajores Testnet.
-    CELOALFAJORES = 44787,
+    CELO_ALFAJORES = 44787,
     /// The Gnosis network.
     GNOSIS = 100,
     /// The Moonbeam network.
@@ -38,13 +40,13 @@ pub enum ChainId {
     /// The Avalanche network.
     AVALANCHE = 43114,
     /// The Base network.
-    BASEGOERLI = 84531,
+    BASE_GOERLI = 84531,
     /// The Base Goerli Testnet.
     BASE = 8453,
     /// The Zora network.
     ZORA = 7777777,
     /// The Zora Sepolia Testnet.
-    ZORASEPOLIA = 999999999,
+    ZORA_SEPOLIA = 999999999,
     /// The Rootstock network.
     ROOTSTOCK = 30,
     /// The Blast network.
@@ -58,23 +60,23 @@ pub enum ChainId {
 pub const SUPPORTED_CHAINS: [ChainId; 21] = [
     ChainId::MAINNET,
     ChainId::OPTIMISM,
-    ChainId::OPTIMISMGOERLI,
-    ChainId::OPTIMISMSEPOLIA,
-    ChainId::ARBITRUMONE,
-    ChainId::ARBITRUMGOERLI,
-    ChainId::ARBITRUMSEPOLIA,
+    ChainId::OPTIMISM_GOERLI,
+    ChainId::OPTIMISM_SEPOLIA,
+    ChainId::ARBITRUM_ONE,
+    ChainId::ARBITRUM_GOERLI,
+    ChainId::ARBITRUM_SEPOLIA,
     ChainId::POLYGON,
-    ChainId::POLYGONMUMBAI,
+    ChainId::POLYGON_MUMBAI,
     ChainId::GOERLI,
     ChainId::SEPOLIA,
-    ChainId::CELOALFAJORES,
+    ChainId::CELO_ALFAJORES,
     ChainId::CELO,
     ChainId::BNB,
     ChainId::AVALANCHE,
     ChainId::BASE,
-    ChainId::BASEGOERLI,
+    ChainId::BASE_GOERLI,
     ChainId::ZORA,
-    ChainId::ZORASEPOLIA,
+    ChainId::ZORA_SEPOLIA,
     ChainId::ROOTSTOCK,
     ChainId::BLAST,
 ];

src/entities/ether.rs

@@ -32,6 +32,7 @@ impl Currency for Ether {
 impl Ether {
     /// Creates a new instance of [`Ether`] with the specified chain ID.
     #[inline]
+    #[must_use]
     pub fn new(chain_id: u64) -> Self {
         Self {
             chain_id,
@@ -44,6 +45,7 @@ impl Ether {
 
     /// Retrieves or creates an [`Ether`] instance for the specified chain ID.
     #[inline]
+    #[must_use]
     pub fn on_chain(chain_id: u64) -> Self {
         Self::new(chain_id)
     }

src/entities/fractions/currency_amount.rs

@@ -33,7 +33,7 @@ impl<T: Currency> CurrencyAmount<T> {
             denominator,
             CurrencyMeta {
                 currency,
-                decimal_scale: BigUint::from(10u64).pow(exponent as u32),
+                decimal_scale: BigUint::from(10_u64).pow(exponent as u32),
             },
         ))
     }

src/entities/fractions/fraction.rs

@@ -167,9 +167,7 @@ impl<M: Clone> FractionBase<M> for FractionLike<M> {
     fn new(numerator: impl Into<BigInt>, denominator: impl Into<BigInt>, meta: M) -> Self {
         let denominator = denominator.into();
         // Ensure the denominator is not zero
-        if denominator.is_zero() {
-            panic!("denominator is zero");
-        }
+        assert!(!denominator.is_zero(), "denominator is zero");
         Self {
             numerator: numerator.into(),
             denominator,

src/entities/fractions/percent.rs

@@ -35,6 +35,7 @@ impl Percent {
     /// Converts the [`Percent`] to a string with a fixed number of decimal places and rounding
     /// strategy
     #[inline]
+    #[must_use]
     pub fn to_fixed(&self, decimal_places: u8, rounding: Rounding) -> String {
         // Convert the Percent to a simple Fraction, multiply by 100, and then call to_fixed on the
         // result

src/entities/fractions/price.rs

@@ -71,8 +71,8 @@ where
         Price::new(
             self.quote_currency.clone(),
             self.base_currency.clone(),
-            self.numerator().clone(),
-            self.denominator().clone(),
+            self.numerator.clone(),
+            self.denominator.clone(),
         )
     }
 
@@ -116,7 +116,7 @@ where
     /// Get the value scaled by decimals for formatting
     #[inline]
     pub fn adjusted_for_decimals(&self) -> Fraction {
-        self.as_fraction() * self.scalar.clone()
+        self.as_fraction() * &self.scalar
     }
 
     /// Converts the adjusted price to a string with a specified number of significant digits and

src/entities/native_currency.rs

@@ -2,10 +2,12 @@ use crate::prelude::*;
 
 /// Represents the native currency of the chain on which it resides
 pub trait NativeCurrency: Currency {
+    #[inline]
     fn is_native(&self) -> bool {
         true
     }
 
+    #[inline]
     fn is_token(&self) -> bool {
         false
     }

src/entities/token.rs

@@ -60,6 +60,7 @@ impl Token {
     ///
     /// Panics if `chain_id` is 0.
     #[inline]
+    #[must_use]
     pub const fn new(
         chain_id: u64,
         address: Address,
@@ -69,9 +70,7 @@ impl Token {
         buy_fee_bps: Option<BigUint>,
         sell_fee_bps: Option<BigUint>,
     ) -> Self {
-        if chain_id == 0 {
-            panic!("chain id can't be zero");
-        }
+        assert!(chain_id != 0, "chain id can't be zero");
         Self {
             chain_id,
             decimals,

src/entities/weth9.rs

@@ -1,4 +1,5 @@
 use crate::{prelude::*, token};
+use alloc::vec;
 
 /// Represents the WETH9 contract and provides information about WETH tokens on different Ethereum
 /// chains.
@@ -11,6 +12,7 @@ pub struct WETH9 {
 /// Default implementation for [`WETH9`], creating an instance with predefined WETH tokens on
 /// various chains.
 impl Default for WETH9 {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }
@@ -27,21 +29,23 @@ impl WETH9 {
     ///
     /// A new `WETH9` instance with predefined WETH tokens.
     #[inline]
+    #[must_use]
     pub fn new() -> Self {
-        let mut tokens = FxHashMap::default();
-        tokens.insert(1, Self::on_chain(1).unwrap());
-        tokens.insert(3, Self::on_chain(3).unwrap());
-        tokens.insert(4, Self::on_chain(4).unwrap());
-        tokens.insert(5, Self::on_chain(5).unwrap());
-        tokens.insert(42, Self::on_chain(42).unwrap());
-        tokens.insert(10, Self::on_chain(10).unwrap());
-        tokens.insert(69, Self::on_chain(69).unwrap());
-        tokens.insert(42161, Self::on_chain(42161).unwrap());
-        tokens.insert(421611, Self::on_chain(421611).unwrap());
-        tokens.insert(8453, Self::on_chain(8453).unwrap());
-        tokens.insert(56, Self::on_chain(56).unwrap());
-        tokens.insert(137, Self::on_chain(137).unwrap());
-        tokens.insert(43114, Self::on_chain(43114).unwrap());
+        let tokens = FxHashMap::from_iter(vec![
+            (1, Self::on_chain(1).unwrap()),
+            (3, Self::on_chain(3).unwrap()),
+            (4, Self::on_chain(4).unwrap()),
+            (5, Self::on_chain(5).unwrap()),
+            (42, Self::on_chain(42).unwrap()),
+            (10, Self::on_chain(10).unwrap()),
+            (69, Self::on_chain(69).unwrap()),
+            (42161, Self::on_chain(42161).unwrap()),
+            (421611, Self::on_chain(421611).unwrap()),
+            (8453, Self::on_chain(8453).unwrap()),
+            (56, Self::on_chain(56).unwrap()),
+            (137, Self::on_chain(137).unwrap()),
+            (43114, Self::on_chain(43114).unwrap()),
+        ]);
         Self { tokens }
     }
 
@@ -53,6 +57,7 @@ impl WETH9 {
     ///
     /// Returns: `Some(Token)` if the token exists, `None` otherwise.
     #[inline]
+    #[must_use]
     pub fn on_chain(chain_id: u64) -> Option<Token> {
         match chain_id {
             1 => Some(token!(
@@ -158,6 +163,7 @@ impl WETH9 {
     ///
     /// Returns: `Some(Token)` if the token exists, `None` otherwise.
     #[inline]
+    #[must_use]
     pub fn get(&self, chain_id: u64) -> Option<&Token> {
         self.tokens.get(&chain_id)
     }

src/lib.rs

@@ -2,18 +2,25 @@
 //!
 //! The Uniswap SDK Core in Rust provides essential functionality for interacting with the Uniswap
 //! decentralized exchange.
+
 #![cfg_attr(not(any(feature = "std", test)), no_std)]
 #![warn(
     missing_copy_implementations,
     missing_debug_implementations,
     unreachable_pub,
     clippy::missing_const_for_fn,
+    clippy::missing_inline_in_public_items,
+    clippy::needless_pass_by_value,
     clippy::redundant_clone,
+    clippy::manual_assert,
+    clippy::must_use_candidate,
+    clippy::unseparated_literal_suffix,
     rustdoc::all
 )]
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![deny(unused_must_use, rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
 extern crate alloc;
 
 /// Contains functionality related to All Contracts deployed and supported by the Uniswap SDK.

src/utils/compute_price_impact.rs

@@ -11,7 +11,7 @@ use crate::prelude::*;
 /// returns: Percent
 #[inline]
 pub fn compute_price_impact<TBase: Currency, TQuote: Currency>(
-    mid_price: Price<TBase, TQuote>,
+    mid_price: &Price<TBase, TQuote>,
     input_amount: &CurrencyAmount<TBase>,
     output_amount: &CurrencyAmount<TQuote>,
 ) -> Result<Percent, Error> {
@@ -42,7 +42,7 @@ mod tests {
         //is correct for zero
         assert!(
             compute_price_impact(
-                Price::new(Ether::on_chain(1), token.clone(), 10, 100),
+                &Price::new(Ether::on_chain(1), token.clone(), 10, 100),
                 &CurrencyAmount::from_raw_amount(Ether::on_chain(1), 10).unwrap(),
                 &CurrencyAmount::from_raw_amount(token.clone(), 100).unwrap()
             )
@@ -53,7 +53,7 @@ mod tests {
         //is correct for half output
         assert!(
             compute_price_impact(
-                Price::new(token.clone(), token_1.clone(), 10, 100),
+                &Price::new(token.clone(), token_1.clone(), 10, 100),
                 &CurrencyAmount::from_raw_amount(token.clone(), 10).unwrap(),
                 &CurrencyAmount::from_raw_amount(token_1.clone(), 50).unwrap()
             )
@@ -64,9 +64,9 @@ mod tests {
         //is negative for more output
         assert_eq!(
             compute_price_impact(
-                Price::new(token.clone(), token_1.clone(), 10, 100),
-                &CurrencyAmount::from_raw_amount(token.clone(), 10).unwrap(),
-                &CurrencyAmount::from_raw_amount(token_1.clone(), 200).unwrap()
+                &Price::new(token.clone(), token_1.clone(), 10, 100),
+                &CurrencyAmount::from_raw_amount(token, 10).unwrap(),
+                &CurrencyAmount::from_raw_amount(token_1, 200).unwrap()
             )
             .unwrap(),
             Percent::new(-10000, 10000)

src/utils/sorted_insert.rs

@@ -2,6 +2,7 @@ use crate::prelude::*;
 
 /// Given an array of items sorted by `comparator`, insert an item into its sort index and constrain
 /// the size to `maxSize` by removing the last item
+#[inline]
 pub fn sorted_insert<T: Clone>(
     items: &mut Vec<T>,
     add: T,

src/utils/sqrt.rs

@@ -8,6 +8,7 @@ use num_traits::Signed;
 /// * `value`: the value for which to compute the square root, rounded down
 ///
 /// returns: BigInt
+#[inline]
 pub fn sqrt(value: &BigInt) -> Result<BigInt, Error> {
     if value.is_negative() {
         Err(Error::Invalid)

src/utils/validate_and_parse_address.rs

@@ -12,6 +12,7 @@ use regex::Regex;
 ///   with only hexadecimal characters after `0x`, returns `Ok(ethereum_address.to_string())`.
 /// * Otherwise, returns an error message in the form of `Err(format!("{} is not a valid Ethereum
 ///   address.", ethereum_address))`.
+#[inline]
 pub fn check_valid_ethereum_address(ethereum_address: &str) -> Result<&str, String> {
     let valid_address_regex = Regex::new(r"^0x[0-9a-fA-F]{40}$").unwrap();
     if valid_address_regex.is_match(ethereum_address) {
@@ -37,6 +38,7 @@ pub fn check_valid_ethereum_address(ethereum_address: &str) -> Result<&str, Stri
 ///   with only hexadecimal characters after `0x`, returns the checksummed address.
 /// * Otherwise, returns an error message in the form of `Err(format!("{} is not a valid Ethereum
 ///   address.", ethereum_address))`.
+#[inline]
 pub fn validate_and_parse_address(ethereum_address: &str) -> Result<String, String> {
     let checksummed_address = eth_checksum::checksum(ethereum_address);
     check_valid_ethereum_address(&checksummed_address)?;