fix: proper Erc4626Example contract

contracts/src/token/erc20/extensions/erc4626.rs

@@ -12,7 +12,7 @@ use alloy_sol_macro::sol;
 use stylus_sdk::{
     call::Call,
     contract, evm, msg,
-    prelude::storage,
+    prelude::{public, storage},
     storage::{StorageAddress, StorageU8, TopLevelStorage},
     stylus_proc::SolidityError,
 };
@@ -283,6 +283,10 @@ pub trait IErc4626 {
     /// * `&mut self` - Write access to the contract's state.
     /// * `assets` - Amount of the underlying asset to deposit.
     /// * `receiver` - The address receiving the shares.
+    ///
+    /// # Errors
+    ///
+    /// *
     fn deposit(
         &mut self,
         assets: U256,
@@ -522,6 +526,7 @@ pub trait IErc4626 {
 /// BorrowMut<Self>)`. Should be fixed in the future by the Stylus team.
 unsafe impl TopLevelStorage for Erc4626 {}
 
+#[public]
 impl IErc4626 for Erc4626 {
     type Error = Error;
 

contracts/src/utils/math/alloy.rs

@@ -27,8 +27,8 @@ pub trait Math {
     /// following the selected `rounding` direction. Throws if result
     /// overflows a `U256` or `denominator` is zero.
     ///
-    /// Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
-    /// Uniswap Labs also under MIT license.
+    /// Original credit to Remco Bloemen under MIT license (<https://xn--2-umb.com/21/muldiv>)
+    /// with further edits by Uniswap Labs also under MIT license.
     ///
     /// # Arguments
     ///
@@ -40,6 +40,13 @@ pub trait Math {
     fn mul_div(self, y: Self, denominator: Self, rounding: Rounding) -> Self;
 
     #[must_use]
+    /// Multiplies `self` * `y` and calculates modulo `m`.
+    ///
+    /// # Arguments
+    ///
+    /// * `self` -
+    /// * `y` -
+    /// * `m` -
     fn mul_mod(self, y: Self, m: Self) -> Self;
 }
 
@@ -187,9 +194,7 @@ impl Math for U256 {
     fn mul_mod(self, y: Self, m: Self) -> Self {
         let x = self;
         // Ensure m is not zero to avoid division by zero
-        if m.is_zero() {
-            panic!("Modulus cannot be zero");
-        }
+        assert!(!m.is_zero(), "Modulus cannot be zero in `Math::mul_mod`");
 
         let mut result = U256::ZERO;
 
@@ -228,9 +233,10 @@ impl Math for U256 {
         let two = U256::from(2);
         let three = U256::from(3);
 
-        if denominator.is_zero() {
-            panic!("Division by U256::ZERO in `Math::mul_div`")
-        }
+        assert!(
+            !denominator.is_zero(),
+            "Division by U256::ZERO in `Math::mul_div`"
+        );
 
         let x = self;
 
@@ -244,7 +250,8 @@ impl Math for U256 {
         // Most significant 256 bits of the product.
         let mut prod1: U256 = {
             let mm: U256 = x.wrapping_mul(y);
-            mm.wrapping_sub(prod0).wrapping_sub(U256::from((mm < prod0) as u8))
+            mm.wrapping_sub(prod0)
+                .wrapping_sub(U256::from(u8::from(mm < prod0)))
         };
         // Handle non-overflow cases, 256 by 256 division.
         if prod1.is_zero() {
@@ -253,9 +260,7 @@ impl Math for U256 {
         }
 
         // Make sure the result is less than 2²⁵⁶.
-        if denominator <= prod1 {
-            panic!("Under overflow in `Math::mul_div`");
-        }
+        assert!((denominator > prod1), "Under overflow in `Math::mul_div`");
 
         ///////////////////////////////////////////////
         // 512 by 256 division.
@@ -267,17 +272,17 @@ impl Math for U256 {
 
         // Subtract 256 bit number from 512 bit number.
         if remainder > prod0 {
-            prod1 = prod1 - one;
+            prod1 -= one;
         }
-        prod0 = prod0 - remainder;
+        prod0 -= remainder;
 
         // Factor powers of two out of denominator and compute largest power of
         // two divisor of denominator. Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
         let mut twos: U256 = denominator & (!denominator + one);
         // Divide denominator by twos.
         let denominator = denominator / twos;
         // Divide [prod1 prod0] by twos.
-        prod0 = prod0 / twos;
+        prod0 /= twos;
         // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it
         // becomes one.
         twos =
@@ -313,7 +318,7 @@ impl Math for U256 {
         if rounding.unsigned_rounds_up()
             && x.mul_mod(y, denominator) > U256::ZERO
         {
-            result = result + one;
+            result += one;
         }
 
         result

examples/erc4626/src/lib.rs

@@ -3,132 +3,16 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 
-use openzeppelin_stylus::token::erc20::{
-    extensions::{Erc20Metadata, Erc4626},
-    utils::SafeErc20,
-    Erc20,
-};
+use openzeppelin_stylus::token::erc20::extensions::Erc4626;
 use stylus_sdk::prelude::{entrypoint, public, storage};
 
 #[entrypoint]
 #[storage]
 struct Erc4626Example {
-    #[borrow]
-    pub erc20: Erc20,
     #[borrow]
     pub erc4626: Erc4626,
-    #[borrow]
-    pub metadata: Erc20Metadata,
-    #[borrow]
-    pub safe_erc20: SafeErc20,
 }
 
 #[public]
-#[inherit(Erc20)]
-impl Erc4626Example {
-    /*
-    fn name(&self) -> String {
-        self.metadata.name()
-    }
-
-    fn symbol(&self) -> String {
-        self.metadata.symbol()
-    }
-
-    fn decimals(&self) -> u8 {
-        self.erc4626._underlying_decimals.get().to()
-    }
-
-    fn max_mint(&self, _receiver: Address) -> U256 {
-        self.erc4626.max_mint(_receiver)
-    }
-
-    fn asset(&self) -> Address {
-        self.erc4626.asset()
-    }
-
-    fn total_assets(&self) -> U256 {
-        self.erc4626.total_assets(&self.erc20)
-    }
-
-    fn convert_to_shares(&mut self, assets: U256) -> U256 {
-        self.erc4626.convert_to_shares(assets, &mut self.erc20)
-    }
-
-    fn convert_to_assets(&mut self, shares: U256) -> U256 {
-        self.erc4626.convert_to_assets(shares, &mut self.erc20)
-    }
-
-    fn preview_deposit(&mut self, assets: U256) -> U256 {
-        self.erc4626.preview_deposit(assets, &mut self.erc20)
-    }
-
-    fn deposit(
-        &mut self,
-        assets: U256,
-        receiver: Address,
-    ) -> Result<U256, Vec<u8>> {
-        Ok(self.erc4626.deposit(assets, receiver, &mut self.erc20)?)
-    }
-
-    fn preview_mint(&mut self, shares: U256) -> U256 {
-        self.erc4626.preview_mint(shares, &mut self.erc20)
-    }
-
-    fn mint(
-        &mut self,
-        shares: U256,
-        receiver: Address,
-    ) -> Result<U256, Vec<u8>> {
-        Ok(self.erc4626.mint(shares, receiver, &mut self.erc20)?)
-    }
-
-    fn max_withdraw(&mut self, owner: Address) -> U256 {
-        self.erc4626.max_withdraw(owner, &mut self.erc20)
-    }
-
-    fn preview_withdraw(&mut self, assets: U256) -> U256 {
-        self.erc4626.preview_withdraw(assets, &mut self.erc20)
-    }
-
-    fn withdraw(
-        &mut self,
-        _assets: U256,
-        _receiver: Address,
-        _owner: Address,
-    ) -> Result<U256, Vec<u8>> {
-        // Ok(self.erc4626.withdraw(
-        //     assets,
-        //     receiver,
-        //     owner,
-        //     &mut self.erc20,
-        //     &mut self.safe_erc20,
-        // )?)
-        Ok(U256::from(100))
-    }
-
-    fn max_redeem(&mut self, owner: Address) -> U256 {
-        self.erc4626.max_redeem(owner, &mut self.erc20)
-    }
-
-    fn preview_redeem(&mut self, shares: U256) -> U256 {
-        self.erc4626.preview_redeem(shares, &mut self.erc20)
-    }
-
-    fn redeem(
-        &mut self,
-        _shares: U256,
-        _receiver: Address,
-        _owner: Address,
-    ) -> Result<U256, Vec<u8>> {
-        // Ok(self.erc4626.redeem(
-        //     shares,
-        //     receiver,
-        //     owner,
-        //     &mut self.erc20,
-        //     &mut self.safe_erc20,
-        // )?)
-        Ok(U256::from(100))
-    }
-    */
-}
+#[inherit(Erc4626)]
+impl Erc4626Example {}