@etherisc/gif-next 0.0.2-85cbb88-630 → 0.0.2-860e68d-106

package/contracts/shared/Registerable.sol

@@ -1,16 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
 import {ObjectType} from "../type/ObjectType.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 
-contract Registerable is
+abstract contract Registerable is
+    AccessManagedUpgradeable,
     NftOwnable,
     IRegisterable
 {
@@ -24,46 +30,64 @@ contract Registerable is
         bytes _data;
     }
 
-    function initializeRegisterable(
-        address registryAddress,
+    modifier onlyActive() {
+        if (!isActive()) {
+            revert ErrorRegisterableNotActive();
+        }
+        _;
+    }
+
+    function __Registerable_init(
+        address authority,
+        address registry,
         NftId parentNftId,
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+        bytes memory data // writeonly data that will saved in the object info record of the registry
     )
-        public
+        internal
         virtual
-        onlyInitializing
+        onlyInitializing()
     {
-        initializeNftOwnable(
-            initialOwner,
-            registryAddress);
-
-        RegisterableStorage storage $;
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
+        if (!ContractLib.isAuthority(authority)) {
+            revert ErrorAuthorityInvalid(authority);
         }
 
+        __AccessManaged_init(authority);
+        __NftOwnable_init(registry, initialOwner);
+
+        RegisterableStorage storage $ = _getRegisterableStorage();
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        $._data = registryData;
+        $._data = data;
+
+        _registerInterface(type(IAccessManaged).interfaceId);
+    }
+
+
+    /// @inheritdoc IRegisterable
+    function isActive() public virtual view returns (bool active) {
+        return !AccessManagerCloneable(authority()).isTargetClosed(address(this));
+    }
+
+
+    /// @inheritdoc IRelease
+    function getRelease() public virtual view returns (VersionPart release) {
+        return AccessManagerCloneable(authority()).getRelease();
     }
 
 
+    /// @inheritdoc IRegisterable
     function getInitialInfo() 
         public 
         view 
         virtual 
         returns (IRegistry.ObjectInfo memory info) 
     {
-        RegisterableStorage storage $;
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
-        }
-
-        info = IRegistry.ObjectInfo(
+        RegisterableStorage storage $ = _getRegisterableStorage();
+        return IRegistry.ObjectInfo(
             NftIdLib.zero(),
             $._parentNftId,
             $._objectType,
@@ -72,4 +96,11 @@ contract Registerable is
             getOwner(),
             $._data);
     }
+
+
+    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+    }
 }

package/contracts/shared/RegistryLinked.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {ContractLib} from "../shared/ContractLib.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryLinked} from "./IRegistryLinked.sol";
 
@@ -10,30 +12,23 @@ contract RegistryLinked is
     IRegistryLinked
 {
 
+    // priorize simplicity and size over using standard upgradeability structs
     IRegistry private _registry;
 
     /// @dev initialization for upgradable contracts
     // used in _initializeRegisterable
-    function initializeRegistryLinked(
-        address registryAddress
+    function __RegistryLinked_init(
+        address registry
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        if (registryAddress.code.length == 0) {
-            revert ErrorNotRegistry(registryAddress);
+        if (!ContractLib.isRegistry(registry)) {
+            revert ErrorNotRegistry(registry);
         }
 
-        _registry = IRegistry(registryAddress);
-
-        try _registry.supportsInterface(type(IRegistry).interfaceId) returns (bool isRegistry) {
-            if (!isRegistry) {
-                revert ErrorNotRegistry(registryAddress);
-            }
-        } catch {
-            revert ErrorNotRegistry(registryAddress);
-        }
+        _registry = IRegistry(registry);
     }
 
 

package/contracts/shared/Service.sol

@@ -1,41 +1,39 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
-import {IVersionable} from "./IVersionable.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ObjectType, SERVICE} from "../type/ObjectType.sol";
 import {Registerable} from "./Registerable.sol";
 import {RoleId, RoleIdLib} from "../type/RoleId.sol";
-import {Version, VersionPart, VersionLib, VersionPartLib} from "../type/Version.sol";
-import {Versionable} from "./Versionable.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+import {Versionable} from "../upgradeability/Versionable.sol";
 
 
 /// @dev service base contract
 abstract contract Service is 
     Registerable,
     Versionable,
-    AccessManagedUpgradeable,
+    ReentrancyGuardUpgradeable,
     IService
 {
 
-    uint8 private constant GIF_MAJOR_VERSION = 3;
-
-
-    function initializeService(
-        address registry, 
+    function __Service_init(
         address authority, // real authority for registry service adress(0) for other services
+        address registry, 
         address initialOwner
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(
+        __ReentrancyGuard_init();
+
+        __Registerable_init(
+            authority,
             registry, 
             IRegistry(registry).getNftId(), 
             SERVICE(), 
@@ -43,41 +41,27 @@ abstract contract Service is
             initialOwner, 
             ""); // data
 
-        // externally provided authority
-        if(authority != address(0)) {
-            __AccessManaged_init(authority);
-        } else {
-            address registryServiceAddress = _getServiceAddress(REGISTRY());
-
-            // copy authority from already registered registry services
-            __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
-        }
-
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IService).interfaceId);
+        _registerInterface(type(IService).interfaceId);
     }
 
     function getDomain() external virtual pure returns(ObjectType serviceDomain) {
         return _getDomain();
     }
 
-    function getRoleId() external virtual pure returns(RoleId serviceRoleId) {
-        return RoleIdLib.roleForTypeAndVersion(_getDomain(), VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+    function getVersion() public pure virtual override (IVersionable, Versionable) returns(Version) {
+        return VersionLib.toVersion(3, 0, 0);
     }
 
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+
+    function getRoleId() external virtual view returns(RoleId serviceRoleId) {
+        return RoleIdLib.toServiceRoleId(_getDomain(), getRelease());
     }
 
+    //--- internal functions --------------------------------------------------------//
     function _getDomain() internal virtual pure returns (ObjectType);
 
+
     function _getServiceAddress(ObjectType domain) internal view returns (address) {
-        return getRegistry().getServiceAddress(domain, VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
 }

package/contracts/shared/TokenHandler.sol

@@ -1,58 +1,342 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import {Amount} from "../type/Amount.sol";
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {SERVICE} from "../type/ObjectType.sol";
 
-/// @dev token specific transfer helper
-/// a default token contract is provided via contract constructor
-/// relies internally on oz SafeERC20.safeTransferFrom
-contract TokenHandler {
-    IERC20Metadata private _token;
 
-    constructor(address token) {
-        _token = IERC20Metadata(token);
+/// @dev Token specific transfer helper base contract.
+/// A default token contract is provided via contract constructor.
+/// Relies internally on OpenZeppelin SafeERC20.safeTransferFrom.
+/// This base contract simplifies writing tests.
+contract TokenHandlerBase {
+
+    // _setWallet
+    event LogTokenHandlerWalletAddressChanged(NftId componentNftId, address oldWallet, address newWallet);
+    event LogTokenHandlerWalletTokensTransferred(NftId componentNftId, address oldWallet, address newWallet, Amount amount);
+
+    // _approveTokenHandler
+    event LogTokenHandlerTokenApproved(NftId nftId, address tokenHandler, address token, Amount amount, bool isMaxAmount);
+
+    // _transfer
+    event LogTokenHandlerTokenTransfer(address token, address from, address to, Amount amount);
+
+    // constructor
+    error ErrorTokenHandlerNotRegistry(address registry);
+    error ErrorTokenHandlerComponentNotRegistered(address component);
+    error ErrorTokenHandlerTokenAddressZero();
+
+    // _setWallet
+    error ErrorTokenHandlerNewWalletAddressZero();
+    error ErrorTokenHandlerAddressIsSameAsCurrent();
+
+    // _approveTokenHandler
+    error ErrorTokenHandlerNotWallet(NftId nftId, address tokenHandler, address wallet);
+
+    // _checkPreconditions
+    error ErrorTokenHandlerBalanceTooLow(address token, address from, uint256 balance, uint256 expectedBalance);
+    error ErrorTokenHandlerAllowanceTooSmall(address token, address from, address spender, uint256 allowance, uint256 expectedAllowance);
+    error ErrorTokenHandlerAmountIsZero();
+
+    IRegistry public immutable REGISTRY;
+    IERC20Metadata public immutable TOKEN;
+    address public immutable COMPONENT;
+    NftId public immutable NFT_ID;
+
+    address internal _wallet;
+
+    constructor(
+        address registry,
+        address component,
+        address token
+    )
+    {
+        if (!ContractLib.isRegistry(registry)) {
+            revert ErrorTokenHandlerNotRegistry(registry);
+        }
+
+        if (token == address(0)) {
+            revert ErrorTokenHandlerTokenAddressZero();
+        }
+
+        REGISTRY = IRegistry(registry);
+        COMPONENT = component;
+        NFT_ID = REGISTRY.getNftIdForAddress(component);
+
+        if (NFT_ID.eqz()) {
+            revert ErrorTokenHandlerComponentNotRegistered(component);
+        }
+
+        TOKEN = IERC20Metadata(token);
+
+        // self approval of token handler to max amount
+        _approve(TOKEN, AmountLib.max());
     }
 
-    /// @dev transfer amount default tokens 
-    function transfer(
+
+    /// @dev Checks the balance and allowance for the from address and amount.
+    /// When requiring amount > 0 set checkAmount to true.
+    function checkBalanceAndAllowance(
         address from,
-        address to,
-        Amount amount
+        Amount amount,
+        bool checkAmount
     )
         external
+        view
+    {
+        _checkBalanceAndAllowance(from, amount, checkAmount);
+    }
+
+
+    /// @dev Returns the wallet linked to this TokenHandler.
+    function getWallet()
+        public
+        view 
+        returns (address wallet)
+    {
+        if (_wallet == address(0)) {
+            return address(this);
+        }
+
+        return _wallet;
+    }
+
+
+    /// @dev Approves token handler to spend up to the specified amount of tokens.
+    /// Sets spending limit to type(uint256).max for AmountLib.max().
+    /// Reverts if wallet is not token handler itself.
+    /// Sets approvel using SareERC20.forceApprove internally.
+    function _approve(
+        IERC20Metadata token, 
+        Amount amount
+    )
+        internal
+    {
+        // check that wallet is token handler contract itself
+        if(_wallet != address(0)) {
+            revert ErrorTokenHandlerNotWallet(NFT_ID, address(this), _wallet);
+        }
+
+        // update spending limit for AmountLib.max() to type(uint256).max
+        uint256 amountInt = amount.toInt();
+        bool isMaxAmount = false;
+        if (amount == AmountLib.max()) {
+            amountInt = type(uint256).max;
+            isMaxAmount = true;
+        }
+
+        emit LogTokenHandlerTokenApproved(NFT_ID, address(this), address(token), amount, isMaxAmount);
+
+        // execute approval
+        SafeERC20.forceApprove(
+            token, 
+            address(this), 
+            amountInt);
+    }
+
+
+    function _setWallet(address newWallet)
+        internal
+    {
+        address oldWallet = _wallet;
+        if (newWallet == oldWallet) {
+            revert ErrorTokenHandlerAddressIsSameAsCurrent();
+        }
+
+        // effects
+        address oldWalletForBalance = getWallet();
+        _wallet = newWallet;
+
+        emit LogTokenHandlerWalletAddressChanged(NFT_ID, oldWallet, newWallet);
+
+        // interactions
+        Amount balanceAmount = AmountLib.toAmount(
+            TOKEN.balanceOf(oldWalletForBalance));
+
+        if (balanceAmount.gtz()) {
+            // move tokens from old to new wallet 
+            emit LogTokenHandlerWalletTokensTransferred(NFT_ID, oldWallet, newWallet, balanceAmount);
+
+            if (oldWallet == address(0)) {
+                // transfer from the component requires an allowance
+                _transfer(address(this), newWallet, balanceAmount, true);
+            } else if (newWallet == address(0)) {
+                _transfer(oldWallet, address(this), balanceAmount, true);
+            } else {
+                _transfer(oldWallet, newWallet, balanceAmount, true);
+            }
+        }
+    }
+
+
+    function _pullToken(address from, Amount amount)
+        internal
+    {
+        _transfer(from, getWallet(), amount, true);
+    }
+
+
+    function _pushToken(address to, Amount amount)
+        internal
     {
+        _transfer(getWallet(), to, amount, true);
+    }
+
+
+    function _transfer(
+        address from,
+        address to,
+        Amount amount,
+        bool checkPreconditions
+    )
+        internal
+    {
+        if (checkPreconditions) {
+            bool checkAmount = true;
+            _checkBalanceAndAllowance(from, amount, checkAmount);
+        }
+
+        // transfer the tokens
+        emit LogTokenHandlerTokenTransfer(address(TOKEN), from, to, amount);
+
         SafeERC20.safeTransferFrom(
-            _token, 
+            TOKEN, 
             from, 
             to, 
             amount.toInt());
     }
 
-    /// @dev transfer amount of the specified token
-    function safeTransferFrom(
-        address token,
+
+    function _checkBalanceAndAllowance(
         address from,
+        Amount amount,
+        bool checkAmount
+    ) 
+        internal
+        view
+    {
+        // amount must be greater than zero
+        if (checkAmount && amount.eqz()) {
+            revert ErrorTokenHandlerAmountIsZero();
+        }
+
+        // allowance must be >= amount
+        uint256 allowance = TOKEN.allowance(from, address(this));
+        if (allowance < amount.toInt()) {
+            revert ErrorTokenHandlerAllowanceTooSmall(address(TOKEN), from, address(this), allowance, amount.toInt());
+        }
+
+        // balance must be >= amount
+        uint256 balance = TOKEN.balanceOf(from);
+        if (balance < amount.toInt()) {
+            revert ErrorTokenHandlerBalanceTooLow(address(TOKEN), from, balance, amount.toInt());
+        }
+    }
+}
+
+
+/// @dev Token specific transfer helper.
+/// Contract is derived from TokenHandlerBase and adds 
+/// authorization based on OpenZeppelin AccessManaged.
+contract TokenHandler is
+    AccessManaged,
+    TokenHandlerBase
+{
+
+    // onlyService
+    error ErrorTokenHandlerNotService(address service);
+
+    modifier onlyService() {
+        if (!REGISTRY.isObjectType(msg.sender, SERVICE())) {
+            revert ErrorTokenHandlerNotService(msg.sender);
+        }
+        _;
+    }
+
+    constructor(
+        address registry,
+        address component,
+        address token, 
+        address authority
+    )
+        TokenHandlerBase(registry, component, token)
+        AccessManaged(authority)
+    { }
+
+    /// @dev Sets the wallet address for the component.
+    /// Seeting the new wallet address to address(0) will set the wallet to the tokenHandler contract itself.
+    /// If the current wallet has tokens, these will be transferred.
+    /// If the new wallet address is externally owned, an approval from the 
+    /// owner of the external wallet to the tokenhandler of the component that 
+    /// covers the current component balance must exist.
+    function setWallet(address newWallet)
+        external
+        restricted()
+        onlyService()
+    {
+        _setWallet(newWallet);
+    }
+
+
+    /// @dev Approves token handler to spend up to the specified amount of tokens.
+    /// Sets spending limit to type(uint256).max for AmountLib.max().
+    /// Reverts if component wallet is not component itself.
+    /// Sets approvel using SareERC20.forceApprove internally.
+    function approve(
+        IERC20Metadata token, 
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _approve(token, amount);
+    }
+
+    /// @dev Collect tokens from outside of GIF and transfer them to the wallet.
+    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
+    function pullToken(
+        address from,
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _pullToken(from, amount);
+    }
+
+
+    /// @dev Distribute tokens from a wallet within the scope of gif to some address.
+    function pushToken(
         address to,
         Amount amount
     )
         external
+        restricted()
+        onlyService()
     {
-        SafeERC20.safeTransferFrom(
-            IERC20Metadata(token), 
-            from, 
-            to, 
-            amount.toInt());
+        _pushToken(to, amount);
     }
 
-    /// @dev returns the default token defined for this TokenHandler
-    function getToken()
+
+    /// @dev Distribute fee tokens from a wallet within the scope of gif to some address.
+    /// Separate push function for component service.
+    function pushFeeToken(
+        address to,
+        Amount amount
+    )
         external
-        view 
-        returns (IERC20Metadata)
+        restricted()
+        onlyService()
     {
-        return _token;
+        _pushToken(to, amount);
     }
 }

package/contracts/shared/TokenHandlerDeployerLib.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {TokenHandler} from "./TokenHandler.sol";
+
+library TokenHandlerDeployerLib {
+
+    function deployTokenHandler(
+        address registry,
+        address component,
+        address token, 
+        address authority
+    )
+        public 
+        returns (TokenHandler)
+    {
+        return new TokenHandler(registry, component, token, authority);
+    }
+
+}