feat: SafeErc20 utility

Cargo.toml

@@ -17,6 +17,7 @@ members = [
   "examples/basic/token",
   "examples/basic/script",
   "examples/ecdsa",
+  "examples/safe-erc20",
   "benches",
 ]
 default-members = [
@@ -30,6 +31,7 @@ default-members = [
   "examples/erc721",
   "examples/erc721-consecutive",
   "examples/erc721-metadata",
+  "examples/safe-erc20",
   "examples/merkle-proofs",
   "examples/ownable",
   "examples/access-control",

contracts/src/token/erc20/mod.rs

@@ -14,6 +14,7 @@ use stylus_sdk::{
 };
 
 pub mod extensions;
+pub mod utils;
 
 sol! {
     /// Emitted when `value` tokens are moved from one account (`from`) to

contracts/src/token/erc20/utils/mod.rs

@@ -0,0 +1,4 @@
+//! Utilities for the ERC-20 standard.
+pub mod safe_erc20;
+
+pub use safe_erc20::SafeErc20;

contracts/src/token/erc20/utils/safe_erc20.rs

@@ -0,0 +1,185 @@
+//! Wrappers around ERC-20 operations that throw on failure.
+
+use alloc::vec::Vec;
+use alloy_primitives::{Address, U256};
+use alloy_sol_types::{
+    sol,
+    sol_data::{Address as SOLAddress, Uint},
+    SolType,
+};
+use stylus_proc::{public, sol_interface, sol_storage, SolidityError};
+use stylus_sdk::{
+    call::{call, Call},
+    function_selector,
+    storage::TopLevelStorage,
+    types::AddressVM,
+};
+
+use crate::token::erc20;
+
+sol! {
+    /// An operation with an ERC-20 token failed.
+    #[derive(Debug)]
+    #[allow(missing_docs)]
+    error SafeErc20FailedOperation(address token);
+
+     /// Indicates a failed `decreaseAllowance` request.
+    #[derive(Debug)]
+    #[allow(missing_docs)]
+    error SafeErc20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
+}
+
+/// A SafeErc20 error
+#[derive(SolidityError, Debug)]
+pub enum Error {
+    /// Error type from [`Erc20`] contract [`erc20::Error`].
+    Erc20(erc20::Error),
+    /// An operation with an ERC-20 token failed.
+    SafeErc20FailedOperation(SafeErc20FailedOperation),
+    /// Indicates a failed `decreaseAllowance` request.
+    SafeErc20FailedDecreaseAllowance(SafeErc20FailedDecreaseAllowance),
+}
+
+sol_storage! {
+    /// Wrappers around ERC-20 operations that throw on failure (when the token
+    /// contract returns false). Tokens that return no value (and instead revert or
+    /// throw on failure) are also supported, non-reverting calls are assumed to be
+    /// successful.
+    /// To use this library you can add a `using SafeERC20 for IERC20;` statement to
+    /// your contract, which allows you to call the safe operations as
+    /// `token.safeTransfer(...)`, etc.
+    pub struct SafeErc20 {}
+}
+
+/// NOTE: Implementation of [`TopLevelStorage`] to be able use `&mut self` when
+/// calling other contracts and not `&mut (impl TopLevelStorage +
+/// BorrowMut<Self>)`. Should be fixed in the future by the Stylus team.
+unsafe impl TopLevelStorage for SafeErc20 {}
+
+#[public]
+impl SafeErc20 {
+    /// Transfer `value` amount of `token` from the calling contract to `to`. If
+    /// `token` returns no value, non-reverting calls are assumed to be
+    /// successful.
+    pub fn safe_transfer(
+        &mut self,
+        token: Address,
+        to: Address,
+        value: U256,
+    ) -> Result<(), Error> {
+        type TransferType = (SOLAddress, Uint<256>);
+        let tx_data = (to, value);
+        let data = TransferType::abi_encode_params(&tx_data);
+        let hashed_function_selector =
+            function_selector!("transfer", Address, U256);
+        // Combine function selector and input data (use abi_packed way)
+        let calldata = [&hashed_function_selector[..4], &data].concat();
+
+        self.call_optional_return(token, calldata)
+    }
+
+    /// Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
+    /// calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
+    pub fn safe_transfer_from(
+        &mut self,
+        token: Address,
+        from: Address,
+        to: Address,
+        value: U256,
+    ) -> Result<(), Error> {
+        type TransferType = (SOLAddress, SOLAddress, Uint<256>);
+        let tx_data = (from, to, value);
+        let data = TransferType::abi_encode_params(&tx_data);
+        let hashed_function_selector =
+            function_selector!("transferFrom", Address, Address, U256);
+        // Combine function selector and input data (use abi_packed way)
+        let calldata = [&hashed_function_selector[..4], &data].concat();
+
+        self.call_optional_return(token, calldata)
+    }
+
+    /// Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
+    /// non-reverting calls are assumed to be successful.
+    pub fn safe_increase_allowance(
+        &mut self,
+        token: Address,
+        spender: Address,
+        value: U256,
+    ) -> Result<(), Error> {
+        todo!()
+    }
+
+    /// Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
+    /// value, non-reverting calls are assumed to be successful.
+    pub fn safe_decrease_allowance(
+        &mut self,
+        token: Address,
+        spender: Address,
+        requested_decrease: U256,
+    ) -> Result<(), Error> {
+        todo!()
+    }
+
+    /// Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
+    /// non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
+    /// to be set to zero before setting it to a non-zero value, such as USDT.
+    pub fn force_approve(
+        &mut self,
+        token: Address,
+        spender: Address,
+        value: U256,
+    ) -> Result<(), Error> {
+        type TransferType = (SOLAddress, Uint<256>);
+        let tx_data = (spender, value);
+        let data = TransferType::abi_encode_params(&tx_data);
+        let hashed_function_selector =
+            function_selector!("approve", Address, U256);
+        // Combine function selector and input data (use abi_packed way)
+        let approve_calldata = [&hashed_function_selector[..4], &data].concat();
+
+        if self.call_optional_return(token, approve_calldata.clone()).is_err() {
+            let tx_data = (spender, U256::ZERO);
+            let data = TransferType::abi_encode_params(&tx_data);
+            self.call_optional_return(
+                token,
+                [&hashed_function_selector[..4], &data].concat(),
+            )?;
+            self.call_optional_return(token, approve_calldata)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl SafeErc20 {
+    /// Imitates a Solidity high-level call (i.e. a regular function call to a
+    /// contract), relaxing the requirement on the return value: the return
+    /// value is optional (but if data is returned, it must not be false).
+    /// @param token The token targeted by the call.
+    /// @param data The call data (encoded using abi.encode or one of its
+    /// variants).
+    ///
+    /// This is a variant of {_callOptionalReturnBool} that reverts if call
+    /// fails to meet the requirements.
+    fn call_optional_return(
+        &self,
+        token: Address,
+        data: Vec<u8>,
+    ) -> Result<(), Error> {
+        match call(Call::new(), token, data.as_slice()) {
+            Ok(data) => {
+                if data.is_empty() && !Address::has_code(&token) {
+                    return Err(Error::SafeErc20FailedOperation(
+                        SafeErc20FailedOperation { token },
+                    ));
+                }
+            }
+            Err(_) => {
+                return Err(Error::SafeErc20FailedOperation(
+                    SafeErc20FailedOperation { token },
+                ))
+            }
+        }
+        Ok(())
+    }
+}

examples/safe-erc20/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "safe-erc20-example"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+version = "0.0.0"
+
+[dependencies]
+openzeppelin-stylus = { path = "../../contracts" }
+alloy-primitives = { workspace = true, features = ["tiny-keccak"] }
+stylus-sdk.workspace = true
+stylus-proc.workspace = true
+mini-alloc.workspace = true
+
+[dev-dependencies]
+alloy.workspace = true
+eyre.workspace = true
+tokio.workspace = true
+e2e = { path = "../../lib/e2e" }
+
+[features]
+e2e = []
+
+[lib]
+crate-type = ["lib", "cdylib"]

examples/safe-erc20/src/constructor.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.21;
+
+contract SafeErc20Example {
+}

examples/safe-erc20/src/lib.rs

@@ -0,0 +1,17 @@
+#![cfg_attr(not(test), no_main, no_std)]
+extern crate alloc;
+
+use openzeppelin_stylus::token::erc20::utils::safe_erc20::SafeErc20;
+use stylus_sdk::prelude::{entrypoint, public, sol_storage};
+
+sol_storage! {
+    #[entrypoint]
+    struct SafeErc20Example {
+        #[borrow]
+        SafeErc20 safe_erc20;
+    }
+}
+
+#[public]
+#[inherit(SafeErc20)]
+impl SafeErc20Example {}

examples/safe-erc20/tests/abi/mod.rs

@@ -0,0 +1,16 @@
+#![allow(dead_code)]
+use alloy::sol;
+
+sol!(
+    #[sol(rpc)]
+   contract SafeErc20 {
+        function safeTransfer(address token, address to, uint256 value) external;
+        function safeTransferFrom(address token, address from, address to, uint256 value) external;
+        function safeIncreaseAllowance(address token, address spender, uint256 value) external;
+        function safeDecreaseAllowance(address token, address spender, uint256 requestedDecrease) external;
+        function forceApprove(address token, address spender, uint256 value) external;
+
+        error SafeErc20FailedOperation(address token);
+        error SafeErc20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
+    }
+);