wip

Cargo.toml

@@ -78,7 +78,7 @@ all = "warn"
 
 [workspace.dependencies]
 # Stylus SDK related
-stylus-sdk = { version = "0.8.0", default-features = false, features = [
+stylus-sdk = { version = "0.8.1-alpha.1", default-features = false, features = [
   "mini-alloc",
 ] }
 

contracts/src/access/control.rs

@@ -18,7 +18,7 @@
 //!
 //! ```rust,ignore
 //! pub fn foo() {
-//!   assert!(self.has_role(MY_ROLE.into(), msg::sender()));
+//!   assert!(self.has_role(MY_ROLE.into(), self.vm().msg_sender()));
 //!   // ...
 //! }
 //! ```
@@ -39,16 +39,14 @@
 //! taken to secure accounts that have been granted it. We recommend using
 //! `AccessControlDefaultAdminRules` to enforce additional security measures for
 //! this role.
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 use alloy_primitives::{Address, FixedBytes, B256};
 use openzeppelin_stylus_proc::interface_id;
 pub use sol::*;
 use stylus_sdk::{
-    evm, msg,
-    prelude::storage,
+    prelude::*,
     storage::{StorageBool, StorageFixedBytes, StorageMap},
-    stylus_proc::{public, SolidityError},
 };
 
 #[cfg_attr(coverage_nightly, coverage(off))]
@@ -250,7 +248,7 @@ impl IAccessControl for AccessControl {
     }
 
     fn only_role(&self, role: B256) -> Result<(), Self::Error> {
-        self._check_role(role, msg::sender())
+        self._check_role(role, self.vm().msg_sender())
     }
 
     #[must_use]
@@ -285,7 +283,7 @@ impl IAccessControl for AccessControl {
         role: B256,
         confirmation: Address,
     ) -> Result<(), Self::Error> {
-        if msg::sender() != confirmation {
+        if self.vm().msg_sender() != confirmation {
             return Err(Error::BadConfirmation(
                 AccessControlBadConfirmation {},
             ));
@@ -314,11 +312,10 @@ impl AccessControl {
     pub fn _set_role_admin(&mut self, role: B256, new_admin_role: B256) {
         let previous_admin_role = self.get_role_admin(role);
         self.roles.setter(role).admin_role.set(new_admin_role);
-        evm::log(RoleAdminChanged {
-            role,
-            previous_admin_role,
-            new_admin_role,
-        });
+        log(
+            self.vm(),
+            RoleAdminChanged { role, previous_admin_role, new_admin_role },
+        );
     }
 
     /// Checks if `account` has been granted `role`.
@@ -366,7 +363,10 @@ impl AccessControl {
             false
         } else {
             self.roles.setter(role).has_role.insert(account, true);
-            evm::log(RoleGranted { role, account, sender: msg::sender() });
+            log(
+                self.vm(),
+                RoleGranted { role, account, sender: self.vm().msg_sender() },
+            );
             true
         }
     }
@@ -388,7 +388,10 @@ impl AccessControl {
     pub fn _revoke_role(&mut self, role: B256, account: Address) -> bool {
         if self.has_role(role, account) {
             self.roles.setter(role).has_role.insert(account, false);
-            evm::log(RoleRevoked { role, account, sender: msg::sender() });
+            log(
+                self.vm(),
+                RoleRevoked { role, account, sender: self.vm().msg_sender() },
+            );
             true
         } else {
             false
@@ -400,7 +403,7 @@ impl AccessControl {
 mod tests {
     use alloy_primitives::Address;
     use motsu::prelude::Contract;
-    use stylus_sdk::prelude::TopLevelStorage;
+    use stylus_sdk::prelude::*;
 
     use super::{AccessControl, Error, IAccessControl};
 

contracts/src/access/ownable.rs

@@ -8,18 +8,12 @@
 //! This module is used through inheritance. It will make available the
 //! [`Ownable::only_owner`] function, which can be called to restrict operations
 //! to the owner.
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 use alloy_primitives::Address;
 use openzeppelin_stylus_proc::interface_id;
 pub use sol::*;
-use stylus_sdk::{
-    call::MethodError,
-    evm, msg,
-    prelude::storage,
-    storage::StorageAddress,
-    stylus_proc::{public, SolidityError},
-};
+use stylus_sdk::{call::MethodError, prelude::*, storage::StorageAddress};
 
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod sol {
@@ -170,7 +164,7 @@ impl Ownable {
     /// * [`Error::UnauthorizedAccount`] - If called by any account other than
     ///   the owner.
     pub fn only_owner(&self) -> Result<(), Error> {
-        let account = msg::sender();
+        let account = self.vm().msg_sender();
         if self.owner() != account {
             return Err(Error::UnauthorizedAccount(
                 OwnableUnauthorizedAccount { account },
@@ -194,15 +188,15 @@ impl Ownable {
     pub fn _transfer_ownership(&mut self, new_owner: Address) {
         let previous_owner = self.owner.get();
         self.owner.set(new_owner);
-        evm::log(OwnershipTransferred { previous_owner, new_owner });
+        log(self.vm(), OwnershipTransferred { previous_owner, new_owner });
     }
 }
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
     use alloy_primitives::Address;
     use motsu::prelude::Contract;
-    use stylus_sdk::prelude::TopLevelStorage;
+    use stylus_sdk::prelude::*;
 
     use super::{Error, IOwnable, Ownable};
 

contracts/src/access/ownable_two_step.rs

@@ -16,16 +16,11 @@
 //! This module uses [`Ownable`] as a member, and makes all its public functions
 //! available.
 
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 use alloy_primitives::Address;
 pub use sol::*;
-use stylus_sdk::{
-    evm, msg,
-    prelude::storage,
-    storage::StorageAddress,
-    stylus_proc::{public, SolidityError},
-};
+use stylus_sdk::{prelude::*, storage::StorageAddress};
 
 use crate::access::ownable::{
     Error as OwnableError, IOwnable, Ownable, OwnableUnauthorizedAccount,
@@ -172,15 +167,18 @@ impl IOwnable2Step for Ownable2Step {
         self.pending_owner.set(new_owner);
 
         let current_owner = self.owner();
-        evm::log(OwnershipTransferStarted {
-            previous_owner: current_owner,
-            new_owner,
-        });
+        log(
+            self.vm(),
+            OwnershipTransferStarted {
+                previous_owner: current_owner,
+                new_owner,
+            },
+        );
         Ok(())
     }
 
     fn accept_ownership(&mut self) -> Result<(), Self::Error> {
-        let sender = msg::sender();
+        let sender = self.vm().msg_sender();
         let pending_owner = self.pending_owner();
         if sender != pending_owner {
             return Err(OwnableError::UnauthorizedAccount(
@@ -225,7 +223,7 @@ impl Ownable2Step {
 mod tests {
     use alloy_primitives::Address;
     use motsu::prelude::Contract;
-    use stylus_sdk::prelude::TopLevelStorage;
+    use stylus_sdk::prelude::*;
 
     use super::{Error, IOwnable2Step, Ownable2Step, OwnableError};
 

contracts/src/finance/vesting_wallet.rs

@@ -25,18 +25,17 @@
 //! adjustment in the vesting schedule to ensure the vested amount is as
 //! intended.
 
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 use alloy_primitives::{Address, U256, U64};
 use openzeppelin_stylus_proc::interface_id;
 pub use sol::*;
 use stylus_sdk::{
     block,
     call::{self, call, Call},
-    contract, evm, function_selector,
-    prelude::storage,
-    storage::{StorageMap, StorageU256, StorageU64, TopLevelStorage},
-    stylus_proc::{public, SolidityError},
+    contract, function_selector,
+    prelude::*,
+    storage::{StorageMap, StorageU256, StorageU64},
 };
 
 use crate::{
@@ -421,7 +420,7 @@ impl IVestingWallet for VestingWallet {
 
         call(Call::new_in(self).value(amount), owner, &[])?;
 
-        evm::log(EtherReleased { amount });
+        log(self.vm(), EtherReleased { amount });
 
         Ok(())
     }
@@ -438,7 +437,7 @@ impl IVestingWallet for VestingWallet {
 
         self.safe_erc20.safe_transfer(token, owner, amount)?;
 
-        evm::log(ERC20Released { token, amount });
+        log(self.vm(), ERC20Released { token, amount });
 
         Ok(())
     }

contracts/src/token/erc1155/extensions/burnable.rs

@@ -3,7 +3,7 @@
 use alloc::vec::Vec;
 
 use alloy_primitives::{Address, U256};
-use stylus_sdk::msg;
+use stylus_sdk::prelude::*;
 
 use crate::token::erc1155::{
     self, ERC1155MissingApprovalForAll, Erc1155, IErc1155,
@@ -94,7 +94,7 @@ impl Erc1155 {
         &self,
         account: Address,
     ) -> Result<(), erc1155::Error> {
-        let sender = msg::sender();
+        let sender = self.vm().msg_sender();
         if account != sender && !self.is_approved_for_all(account, sender) {
             return Err(erc1155::Error::MissingApprovalForAll(
                 ERC1155MissingApprovalForAll {

contracts/src/token/erc1155/extensions/metadata_uri.rs

@@ -3,14 +3,12 @@
 //!
 //! [ERC]: https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions
 
-use alloc::{string::String, vec::Vec};
+use alloc::{string::String, vec, vec::Vec};
 
 use alloy_primitives::{FixedBytes, U256};
 use openzeppelin_stylus_proc::interface_id;
 pub use sol::*;
-use stylus_sdk::{
-    prelude::storage, storage::StorageString, stylus_proc::public,
-};
+use stylus_sdk::{prelude::*, storage::StorageString};
 
 use crate::utils::introspection::erc165::{Erc165, IErc165};
 
@@ -76,7 +74,7 @@ impl IErc165 for Erc1155MetadataUri {
 mod tests {
     use alloy_primitives::Address;
     use motsu::prelude::Contract;
-    use stylus_sdk::{alloy_primitives::uint, prelude::TopLevelStorage};
+    use stylus_sdk::{alloy_primitives::uint, prelude::*};
 
     use super::{Erc1155MetadataUri, IErc1155MetadataUri, IErc165};
 

contracts/src/token/erc1155/extensions/supply.rs

@@ -17,8 +17,7 @@ use alloy_primitives::{Address, U256};
 use openzeppelin_stylus_proc::interface_id;
 use stylus_sdk::{
     abi::Bytes,
-    msg,
-    prelude::{public, storage},
+    prelude::*,
     storage::{StorageMap, StorageU256},
 };
 
@@ -279,7 +278,7 @@ impl Erc1155Supply {
 
         if !to.is_zero() {
             self.erc1155._check_on_erc1155_received(
-                msg::sender(),
+                self.vm().msg_sender(),
                 from,
                 to,
                 erc1155::Erc1155ReceiverData::new(ids, values),
@@ -359,7 +358,7 @@ impl Erc1155Supply {
 mod tests {
     use alloy_primitives::{Address, U256};
     use motsu::prelude::Contract;
-    use stylus_sdk::prelude::TopLevelStorage;
+    use stylus_sdk::prelude::*;
 
     use super::{Erc1155Supply, IErc1155Supply};
     use crate::token::erc1155::{