Merge pull request #38 from malik672/performance

Performance

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "uniswap-sdk-core"
-version = "0.12.5"
+version = "0.13.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/addresses.rs

@@ -29,7 +29,7 @@ pub fn construct_same_address_map(address: Address, additional_networks: &[Chain
 }
 
 lazy_static! {
-    #[derive(Copy, Clone)]
+    #[derive(Debug, Clone, Copy)]
     pub static ref UNI_ADDRESSES: AddressMap = construct_same_address_map(
         address!("1f9840a85d5aF5bf1D1762F925BDADdC4201F984"),
         &[

src/chains.rs

@@ -1,4 +1,4 @@
-#[derive(Copy, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum ChainId {
     MAINNET = 1,
     GOERLI = 5,

src/constants.rs

@@ -8,7 +8,7 @@ pub enum TradeType {
     ExactOutput,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Rounding {
     RoundDown,
     RoundHalfUp,

src/entities/fractions/currency_amount.rs

@@ -82,7 +82,7 @@ impl<T: CurrencyTrait> CurrencyAmount<T> {
     // Addition of another currency amount to the current amount
     pub fn add(&self, other: &Self) -> Result<Self, Error> {
         if !self.meta.currency.equals(&other.meta.currency) {
-            return Err(Error::NotEqual("CURRENCY: not equal".to_owned()));
+            return Err(Error::NotEqual());
         }
         let added = self.as_fraction() + other.as_fraction();
         Self::from_fractional_amount(
@@ -95,7 +95,7 @@ impl<T: CurrencyTrait> CurrencyAmount<T> {
     // Subtraction of another currency amount from the current amount
     pub fn subtract(&self, other: &Self) -> Result<Self, Error> {
         if !self.meta.currency.equals(&other.meta.currency) {
-            return Err(Error::NotEqual("CURRENCY: not equal".to_owned()));
+            return Err(Error::NotEqual());
         }
         let subtracted = self.as_fraction() - other.as_fraction();
         Self::from_fractional_amount(
@@ -118,11 +118,7 @@ impl<T: CurrencyTrait> CurrencyAmount<T> {
     // Convert the currency amount to a string with a fixed number of decimal places
     pub fn to_fixed(&self, decimal_places: u8, rounding: Rounding) -> Result<String, Error> {
         if !decimal_places <= self.meta.currency.decimals() {
-            return Err(Error::NotEqual(format!(
-                "{} should be less than or equal to {}",
-                decimal_places,
-                self.meta.currency.decimals()
-            )));
+            return Err(Error::NotEqual());
         }
 
         Ok(

src/entities/fractions/fraction.rs

@@ -82,9 +82,7 @@ pub trait FractionBase<M>: Sized {
     // Converts the fraction to a string with a specified number of significant digits and rounding strategy
     fn to_significant(&self, significant_digits: u8, rounding: Rounding) -> Result<String, Error> {
         if significant_digits == 0 {
-            return Err(Error::Incorrect(
-                "significant dgits should always be greater than zero".to_string(),
-            ));
+            return Err(Error::Incorrect());
         }
         let rounding_strategy = to_rounding_strategy(rounding);
         let quotient = self.to_decimal().with_precision_round(

src/entities/fractions/price.rs

@@ -76,7 +76,7 @@ where
         other: &Price<TQuote, TOtherQuote>,
     ) -> Result<Price<TBase, TOtherQuote>, Error> {
         if !self.meta.quote_currency.equals(&other.meta.base_currency) {
-            return Err(Error::NotEqual("the comparison are not equal".to_owned()));
+            return Err(Error::NotEqual());
         }
 
         let fraction = self.as_fraction() * other.as_fraction();
@@ -98,7 +98,7 @@ where
             .currency
             .equals(&self.meta.base_currency)
         {
-            return Err(Error::NotEqual("the comparison are not equal".to_owned()));
+            return Err(Error::NotEqual());
         }
         let fraction = self.as_fraction() * currency_amount.as_fraction();
         CurrencyAmount::from_fractional_amount(

src/error.rs

@@ -11,10 +11,10 @@ pub enum Error {
     #[error("amount has exceeded MAX_UINT256")]
     MaxUint,
 
-    #[error("not equal: {0}")]
-    NotEqual(String),
+    #[error("not equal")]
+    NotEqual(),
 
     //Custo
-    #[error("incorrect: {0}")]
-    Incorrect(String),
+    #[error("incorrect")]
+    Incorrect(),
 }

src/utils/sorted_insert.rs

@@ -9,15 +9,11 @@ pub fn sorted_insert<T: Clone>(
     comparator: fn(&T, &T) -> Ordering,
 ) -> Result<Option<T>, Error> {
     if max_size == 0 {
-        return Err(Error::Incorrect(
-            "max_size can't be equal to zero".to_string(),
-        ));
+        return Err(Error::Incorrect());
     }
 
     if items.len() > max_size {
-        return Err(Error::Incorrect(
-            "array length cannot exceed max_size".to_string(),
-        ));
+        return Err(Error::Incorrect());
     }
 
     let removed_item = if items.len() == max_size {
@@ -51,14 +47,14 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "max_size can't be equal to zero")]
+    #[should_panic]
     fn test_max_size_zero() {
         let mut arr = Vec::new();
         sorted_insert(&mut arr, 1, 0, cmp).unwrap();
     }
 
     #[test]
-    #[should_panic(expected = "array length cannot exceed max_size")]
+    #[should_panic]
     fn test_length_greater_than_max_size() {
         let mut arr = vec![1, 2];
         let _w = sorted_insert(&mut arr, 1, 1, cmp).unwrap();

src/utils/sqrt.rs

@@ -10,7 +10,7 @@ use crate::prelude::*;
 ///
 pub fn sqrt(value: &BigInt) -> Result<BigInt, Error> {
     if !value >= Zero::zero() {
-        return Err(Error::Incorrect("value cannot be negative".to_string()));
+        return Err(Error::Incorrect());
     }
 
     // If the value is less than or equal to MAX_SAFE_INTEGER,

src/utils/validate_and_parse_address.rs

@@ -10,10 +10,10 @@ use regex::Regex;
 ///
 /// * If the input string satisfies the condition of starting with `0x` and being 42 characters long 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))`.
-pub fn check_valid_ethereum_address(ethereum_address: &str) -> Result<String, String> {
+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) {
-        Ok(ethereum_address.to_string())
+        Ok(ethereum_address)
     } else {
         Err(format!(
             "{} is not a valid Ethereum address.",