feat: add back assoc. error type to IOwnable (#851)

<!--
Thank you for your interest in contributing to OpenZeppelin!

Consider opening an issue for discussion prior to submitting a PR. New
features will be merged faster if they were first discussed and designed
with the team.

Describe the changes introduced in this pull request. Include any
context necessary for understanding the PR's purpose.
-->

<!-- Fill in with issue number -->
Resolves #???

#### PR Checklist

<!--
Before merging the pull request all of the following must be completed.
Feel free to submit a PR or Draft PR even if some items are pending.
Some of the items may not apply.
-->

- [x] Tests
- [x] Documentation
- [x] Changelog

Author: 0xNeshi

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `IErc721Wrapper` returns `Vec<u8>` instead of typed `Error`. #822
 - Consolidated Solidity interfaces and standardized naming (`*Interface`, `*Abi`, `I*`). #829
+- Added back associated error type to `IOwnable` trait.
+- `IUpgradeableBeacon` now expects `IOwnable<Error = Vec<u8>>` instead of `IOwnable`.
 
 ## [v0.3.0] - 2025-09-10
 

contracts/src/access/ownable.rs

@@ -75,6 +75,9 @@ pub struct Ownable {
 /// Interface for an [`Ownable`] contract.
 #[interface_id]
 pub trait IOwnable {
+    /// The error type associated to the trait implementation.
+    type Error: Into<alloc::vec::Vec<u8>>;
+
     /// Returns the address of the current owner.
     ///
     /// # Arguments
@@ -98,8 +101,10 @@ pub trait IOwnable {
     /// # Events
     ///
     /// * [`OwnershipTransferred`].
-    fn transfer_ownership(&mut self, new_owner: Address)
-        -> Result<(), Vec<u8>>;
+    fn transfer_ownership(
+        &mut self,
+        new_owner: Address,
+    ) -> Result<(), Self::Error>;
 
     /// Leaves the contract without owner. It will not be possible to call
     /// functions that require `only_owner`. Can only be called by the current
@@ -119,11 +124,11 @@ pub trait IOwnable {
     /// # Events
     ///
     /// * [`OwnershipTransferred`].
-    fn renounce_ownership(&mut self) -> Result<(), Vec<u8>>;
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error>;
 }
 
 #[public]
-#[implements(IOwnable, IErc165)]
+#[implements(IOwnable<Error = Error>, IErc165)]
 impl Ownable {
     /// Constructor.
     ///
@@ -149,19 +154,21 @@ impl Ownable {
 
 #[public]
 impl IOwnable for Ownable {
+    type Error = Error;
+
     fn owner(&self) -> Address {
         self.owner()
     }
 
     fn transfer_ownership(
         &mut self,
         new_owner: Address,
-    ) -> Result<(), Vec<u8>> {
-        Ok(self.transfer_ownership(new_owner)?)
+    ) -> Result<(), Self::Error> {
+        self.transfer_ownership(new_owner)
     }
 
-    fn renounce_ownership(&mut self) -> Result<(), Vec<u8>> {
-        Ok(self.renounce_ownership()?)
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
+        self.renounce_ownership()
     }
 }
 

contracts/src/access/ownable_two_step.rs

@@ -202,6 +202,27 @@ impl IOwnable2Step for Ownable2Step {
     }
 }
 
+// This is implemented so that [`Ownable2Step`] could be passed to functions
+// expecting [`ownable::IOwnable`].
+impl ownable::IOwnable for Ownable2Step {
+    type Error = ownable::Error;
+
+    fn owner(&self) -> Address {
+        IOwnable2Step::owner(self)
+    }
+
+    fn transfer_ownership(
+        &mut self,
+        new_owner: Address,
+    ) -> Result<(), Self::Error> {
+        IOwnable2Step::transfer_ownership(self, new_owner)
+    }
+
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
+        IOwnable2Step::renounce_ownership(self)
+    }
+}
+
 impl Ownable2Step {
     /// Transfers ownership of the contract to a new account (`new_owner`) and
     /// sets [`Self::pending_owner`] to [`Address::ZERO`] to avoid situations
@@ -239,7 +260,6 @@ mod tests {
     use stylus_sdk::{alloy_primitives::Address, prelude::*};
 
     use super::*;
-    use crate::access::ownable::IOwnable;
 
     unsafe impl TopLevelStorage for Ownable2Step {}
 
@@ -452,9 +472,11 @@ mod tests {
         assert!(contract.sender(alice).supports_interface(
             <Ownable2Step as IOwnable2Step>::interface_id()
         ));
-        assert!(contract
-            .sender(alice)
-            .supports_interface(<Ownable as IOwnable>::interface_id()));
+        assert!(
+            contract.sender(alice).supports_interface(
+                <Ownable as ownable::IOwnable>::interface_id()
+            )
+        );
         assert!(contract
             .sender(alice)
             .supports_interface(<Ownable2Step as IErc165>::interface_id()));

contracts/src/proxy/beacon/upgradeable.rs

@@ -73,7 +73,7 @@ impl From<ownable::Error> for Error {
 /// upgrading the proxies that use this beacon.
 ///
 /// [BeaconProxy]: super::BeaconProxy
-pub trait IUpgradeableBeacon: IBeacon + IOwnable {
+pub trait IUpgradeableBeacon: IBeacon + IOwnable<Error = Vec<u8>> {
     /// Upgrades the beacon to a new implementation.
     ///
     /// # Arguments
@@ -108,7 +108,7 @@ pub struct UpgradeableBeacon {
 unsafe impl TopLevelStorage for UpgradeableBeacon {}
 
 #[public]
-#[implements(IBeacon, IOwnable)]
+#[implements(IBeacon, IOwnable<Error = Error>)]
 impl UpgradeableBeacon {
     /// Sets the address of the initial implementation, and the initial owner
     /// who can upgrade the beacon.
@@ -203,18 +203,20 @@ impl IBeacon for UpgradeableBeacon {
 
 #[public]
 impl IOwnable for UpgradeableBeacon {
+    type Error = Error;
+
     fn owner(&self) -> Address {
         self.ownable.owner()
     }
 
     fn transfer_ownership(
         &mut self,
         new_owner: Address,
-    ) -> Result<(), Vec<u8>> {
+    ) -> Result<(), Self::Error> {
         Ok(self.ownable.transfer_ownership(new_owner)?)
     }
 
-    fn renounce_ownership(&mut self) -> Result<(), Vec<u8>> {
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
         Ok(self.ownable.renounce_ownership()?)
     }
 }
@@ -529,13 +531,13 @@ mod tests {
             );
 
         // the error should be from the ownable contract.
-        assert_eq!(
+        assert!(matches!(
             err,
-            Error::InvalidOwner(ownable::OwnableInvalidOwner {
-                owner: Address::ZERO,
-            })
-            .encode()
-        );
+            Error::InvalidOwner(
+                ownable::OwnableInvalidOwner {
+                owner,
+            }) if owner == Address::ZERO,
+        ));
 
         // ownership should remain unchanged.
         let owner = beacon.sender(alice).owner();
@@ -558,13 +560,12 @@ mod tests {
             .transfer_ownership(charlie)
             .expect_err("should fail when called by non-owner");
 
-        assert_eq!(
+        assert!(matches!(
             err,
             Error::UnauthorizedAccount(ownable::OwnableUnauthorizedAccount {
-                account: bob,
-            })
-            .encode()
-        );
+                account,
+            }) if account == bob
+        ));
 
         // ownership should remain unchanged.
         let owner = beacon.sender(alice).owner();
@@ -618,13 +619,12 @@ mod tests {
             .renounce_ownership()
             .expect_err("should fail when called by non-owner");
 
-        assert_eq!(
+        assert!(matches!(
             err,
             Error::UnauthorizedAccount(ownable::OwnableUnauthorizedAccount {
-                account: bob,
-            })
-            .encode()
-        );
+                account,
+            }) if account == bob
+        ));
 
         // ownership should remain unchanged.
         let owner = beacon.sender(alice).owner();

docs/modules/ROOT/pages/beacon-proxy.adoc

@@ -137,15 +137,17 @@ impl IBeacon for MyUpgradeableBeacon {
 
 #[public]
 impl IOwnable for MyUpgradeableBeacon {
+    type Error = Vec<u8>;
+
     fn owner(&self) -> Address {
         self.beacon.owner()
     }
 
-    fn transfer_ownership(&mut self, new_owner: Address) -> Result<(), Vec<u8>> {
+    fn transfer_ownership(&mut self, new_owner: Address) -> Result<(), Self::Error> {
         self.beacon.transfer_ownership(new_owner)
     }
 
-    fn renounce_ownership(&mut self) -> Result<(), Vec<u8>> {
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
         self.beacon.renounce_ownership()
     }
 }

docs/modules/ROOT/pages/uups-proxy.adoc

@@ -72,6 +72,79 @@ Minimal example with `Ownable`, `UUPSUpgradeable`, and `Erc20` logic:
 
 [source,rust]
 ----
+use openzeppelin_stylus::{
+    access::ownable::{self, IOwnable, Ownable},
+    proxy::{
+        erc1967,
+        utils::{
+            erc1822::IErc1822Proxiable,
+            uups_upgradeable::{self, IUUPSUpgradeable, UUPSUpgradeable},
+        },
+    },
+    token::erc20::{self, Erc20, IErc20},
+    utils::address,
+};
+
+#[derive(SolidityError, Debug)]
+enum Error {
+    UnauthorizedAccount(ownable::OwnableUnauthorizedAccount),
+    InvalidOwner(ownable::OwnableInvalidOwner),
+    UnauthorizedCallContext(uups_upgradeable::UUPSUnauthorizedCallContext),
+    UnsupportedProxiableUUID(uups_upgradeable::UUPSUnsupportedProxiableUUID),
+    InvalidImplementation(erc1967::utils::ERC1967InvalidImplementation),
+    InvalidAdmin(erc1967::utils::ERC1967InvalidAdmin),
+    InvalidBeacon(erc1967::utils::ERC1967InvalidBeacon),
+    NonPayable(erc1967::utils::ERC1967NonPayable),
+    EmptyCode(address::AddressEmptyCode),
+    FailedCall(address::FailedCall),
+    FailedCallWithReason(address::FailedCallWithReason),
+    InvalidInitialization(uups_upgradeable::InvalidInitialization),
+    InvalidVersion(uups_upgradeable::InvalidVersion),
+}
+
+impl From<uups_upgradeable::Error> for Error {
+    fn from(e: uups_upgradeable::Error) -> Self {
+        match e {
+            uups_upgradeable::Error::InvalidImplementation(e) => {
+                Error::InvalidImplementation(e)
+            }
+            uups_upgradeable::Error::InvalidAdmin(e) => Error::InvalidAdmin(e),
+            uups_upgradeable::Error::InvalidBeacon(e) => {
+                Error::InvalidBeacon(e)
+            }
+            uups_upgradeable::Error::NonPayable(e) => Error::NonPayable(e),
+            uups_upgradeable::Error::EmptyCode(e) => Error::EmptyCode(e),
+            uups_upgradeable::Error::FailedCall(e) => Error::FailedCall(e),
+            uups_upgradeable::Error::FailedCallWithReason(e) => {
+                Error::FailedCallWithReason(e)
+            }
+            uups_upgradeable::Error::InvalidInitialization(e) => {
+                Error::InvalidInitialization(e)
+            }
+            uups_upgradeable::Error::UnauthorizedCallContext(e) => {
+                Error::UnauthorizedCallContext(e)
+            }
+            uups_upgradeable::Error::UnsupportedProxiableUUID(e) => {
+                Error::UnsupportedProxiableUUID(e)
+            }
+            uups_upgradeable::Error::InvalidVersion(e) => {
+                Error::InvalidVersion(e)
+            }
+        }
+    }
+}
+
+impl From<ownable::Error> for Error {
+    fn from(e: ownable::Error) -> Self {
+        match e {
+            ownable::Error::UnauthorizedAccount(e) => {
+                Error::UnauthorizedAccount(e)
+            }
+            ownable::Error::InvalidOwner(e) => Error::InvalidOwner(e),
+        }
+    }
+}
+
 #[entrypoint]
 #[storage]
 struct MyUUPSContract {
@@ -81,7 +154,7 @@ struct MyUUPSContract {
 }
 
 #[public]
-#[implements(IErc20<Error = erc20::Error>, IUUPSUpgradeable, IErc1822Proxiable, IOwnable)]
+#[implements(IErc20<Error = erc20::Error>, IUUPSUpgradeable, IErc1822Proxiable, IOwnable<Error = Error>)]
 impl MyUUPSContract {
     // Accepting owner here only to enable invoking functions directly on the
     // UUPS
@@ -148,6 +221,11 @@ A simple UUPS-compatible proxy using ERC-1967:
 
 [source,rust]
 ----
+use openzeppelin_stylus::proxy::{
+    erc1967::{self, Erc1967Proxy},
+    IProxy,
+};
+
 #[entrypoint]
 #[storage]
 struct MyUUPSProxy {

examples/ownable/src/lib.rs

@@ -59,7 +59,7 @@ struct OwnableExample {
 }
 
 #[public]
-#[implements(IErc20<Error = Error>, IOwnable)]
+#[implements(IErc20<Error = Error>, IOwnable<Error = ownable::Error>)]
 impl OwnableExample {
     #[constructor]
     fn constructor(&mut self, initial_owner: Address) -> Result<(), Error> {
@@ -119,18 +119,20 @@ impl IErc20 for OwnableExample {
 
 #[public]
 impl IOwnable for OwnableExample {
+    type Error = ownable::Error;
+
     fn owner(&self) -> Address {
         self.ownable.owner()
     }
 
     fn transfer_ownership(
         &mut self,
         new_owner: Address,
-    ) -> Result<(), Vec<u8>> {
-        Ok(self.ownable.transfer_ownership(new_owner)?)
+    ) -> Result<(), Self::Error> {
+        self.ownable.transfer_ownership(new_owner)
     }
 
-    fn renounce_ownership(&mut self) -> Result<(), Vec<u8>> {
-        Ok(self.ownable.renounce_ownership()?)
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
+        self.ownable.renounce_ownership()
     }
 }