@etherisc/gif-next 0.0.2-d13bb9e-069 → 0.0.2-d1ee1ae-450

package/contracts/shared/TokenHandler.sol

@@ -5,91 +5,191 @@ import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManage
 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 is AccessManaged {
-    error ErrorTokenHandlerAmountIsZero();
+
+/// @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 ErrorTokenHandlerRecipientWalletsMustBeDistinct(address to, address to2, address to3);
-    
-    event LogTokenHandlerTokenTransfer(address token, address from, address to, uint256 amountTransferred);
+    error ErrorTokenHandlerAmountIsZero();
 
-    IERC20Metadata private _token;
+    IRegistry public immutable REGISTRY;
+    IERC20Metadata public immutable TOKEN;
+    address public immutable COMPONENT;
+    NftId public immutable NFT_ID;
 
-    constructor(address token, address initialAuthority) AccessManaged(initialAuthority) {
-        _token = IERC20Metadata(token);
-    }
+    address internal _wallet;
 
-    /// @dev returns the default token defined for this TokenHandler
-    function getToken()
-        external
-        view 
-        returns (IERC20Metadata)
-    {
-        return _token;
-    }
-    
-    /// @dev collect tokens from outside of the gif and transfer them to one wallet within the scope of gif.
-    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
-    function collectTokens(
-        address from,
-        address to,
-        Amount amount
+    constructor(
+        address registry,
+        address component,
+        address token
     )
-        external
-        restricted()
     {
-        _transfer(from, to, amount, true);
+        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 collect tokens from outside of the gif and transfer them to three distinct wallets within the scope of gif
-    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
-    function collectTokensToThreeRecipients( 
+
+    /// @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,
-        address to2,
-        Amount amount2,
-        address to3,
-        Amount amount3
+        bool checkAmount
     )
         external
-        restricted()
+        view
     {
-        if (to == to2 || to == to3 || to2 == to3) {
-            revert ErrorTokenHandlerRecipientWalletsMustBeDistinct(to, to2, to3);
+        _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);
         }
 
-        _checkPreconditions(from, amount + amount2 + amount3);
+        return _wallet;
+    }
+
 
-        if (amount.gtz()) {
-            _transfer(from, to, amount, false);
+    /// @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);
         }
-        if (amount2.gtz()) {
-            _transfer(from, to2, amount2, false);
+
+        // 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;
         }
-        if (amount3.gtz()) {
-            _transfer(from, to3, amount3, false);
+
+        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);
+            }
         }
     }
 
-    /// @dev distribute tokens from a wallet within the scope of gif to an external address.
-    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
-    function distributeTokens(
-        address from,
-        address to,
-        Amount amount
-    )
-        external
-        restricted()
+
+    function _pullToken(address from, Amount amount)
+        internal
     {
-        _transfer(from, to, amount, true);
+        _transfer(from, getWallet(), amount, true);
     }
 
+
+    function _pushToken(address to, Amount amount)
+        internal
+    {
+        _transfer(getWallet(), to, amount, true);
+    }
+
+
     function _transfer(
         address from,
         address to,
@@ -99,41 +199,144 @@ contract TokenHandler is AccessManaged {
         internal
     {
         if (checkPreconditions) {
-            // check amount > 0, balance >= amount and allowance >= amount
-            _checkPreconditions(from, amount);
+            bool checkAmount = true;
+            _checkBalanceAndAllowance(from, amount, checkAmount);
         }
 
         // transfer the tokens
-        emit LogTokenHandlerTokenTransfer(address(_token), from, to, amount.toInt());
+        emit LogTokenHandlerTokenTransfer(address(TOKEN), from, to, amount);
+
         SafeERC20.safeTransferFrom(
-            _token, 
+            TOKEN, 
             from, 
             to, 
             amount.toInt());
     }
 
-    function _checkPreconditions(
+
+    function _checkBalanceAndAllowance(
         address from,
-        Amount amount
+        Amount amount,
+        bool checkAmount
     ) 
         internal
         view
     {
         // amount must be greater than zero
-        if (amount.eqz()) {
+        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);
+        uint256 balance = TOKEN.balanceOf(from);
         if (balance < amount.toInt()) {
-            revert ErrorTokenHandlerBalanceTooLow(address(_token), from, balance, amount.toInt());
+            revert ErrorTokenHandlerBalanceTooLow(address(TOKEN), from, balance, amount.toInt());
         }
+    }
+}
 
-        // 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());
+
+/// @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()
+    {
+        _pushToken(to, amount);
+    }
+
+
+    /// @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
+        restricted()
+        onlyService()
+    {
+        _pushToken(to, amount);
     }
 }

package/contracts/shared/TokenHandlerDeployerLib.sol

@@ -5,8 +5,16 @@ import {TokenHandler} from "./TokenHandler.sol";
 
 library TokenHandlerDeployerLib {
 
-    function deployTokenHandler(address token, address authority) public returns (TokenHandler) {
-        return new TokenHandler(address(token), authority);
+    function deployTokenHandler(
+        address registry,
+        address component,
+        address token, 
+        address authority
+    )
+        public 
+        returns (TokenHandler)
+    {
+        return new TokenHandler(registry, component, token, authority);
     }
 
 }

package/contracts/staking/IStaking.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {Amount} from "../type/Amount.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IVersionable} from "../upgradeability/IVersionable.sol";
@@ -22,6 +24,7 @@ interface IStaking is
     // target parameters
     event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
     event LogStakingRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
+    event LogStakingMaxStakedAmountSet(NftId targetNftId, Amount maxStakedAmount);
 
     // modifiers
     error ErrorStakingNotStake(NftId stakeNftId);
@@ -30,6 +33,9 @@ interface IStaking is
     error ErrorStakingNotStakingOwner();
     error ErrorStakingNotNftOwner(NftId nftId);
 
+    // initializeTokenHandler
+    error ErrorStakingNotRegistry(address registry);
+
     // staking rate
     error ErrorStakingTokenNotRegistered(uint256 chainId, address token);
 
@@ -48,22 +54,31 @@ interface IStaking is
     error ErrorStakingRewardRateTooHigh(NftId targetNftId, UFixed maxRewardRate, UFixed rewardRate);
     error ErrorStakingTargetNotFound(NftId targetNftId);
     error ErrorStakingTargetTokenNotFound(NftId targetNftId, uint256 chainId, address token);
+    error ErrorStakingTargetMaxStakedAmountExceeded(NftId targetNftId, Amount maxStakedAmount, Amount stakedAmount);
 
-    error ErrorStakingTargetNotActive(NftId targetNftId);
     error ErrorStakingStakeAmountZero(NftId targetNftId);
 
     // info for individual stake
     struct StakeInfo {
+        // slot 0
         Timestamp lockedUntil;
     }
 
     struct TargetInfo {
+        // Slot 0
+        UFixed rewardRate;
+        Amount maxStakedAmount;
+        // Slot 1
         ObjectType objectType;
-        uint256 chainId;
         Seconds lockingPeriod;
-        UFixed rewardRate;
+        // Slot 2
+        uint256 chainId;
     }
 
+    function initializeTokenHandler() external;
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external;
+
     // staking rate management 
 
     /// @dev sets the rate that converts 1 token of total value locked into the
@@ -90,6 +105,10 @@ interface IStaking is
     /// permissioned: only the staking service may call this function
     function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
 
+    /// @dev set the maximum staked amount for the specified target.
+    /// permissioned: only the staking service may call this function
+    function setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount) external;
+
     /// @dev (re)fills the staking reward reserves for the specified target
     /// unpermissioned: anybody may fill up staking reward reserves
     function refillRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
@@ -127,7 +146,7 @@ interface IStaking is
     /// @dev restakes the dips to a new target.
     /// the sum of the staked dips and the accumulated rewards will be restaked.
     /// permissioned: only staking service may call this function.
-    function restake(NftId stakeNftId, NftId newTargetNftId) external returns (NftId newStakeNftId);
+    function restake(NftId stakeNftId, NftId newStakeNftId) external returns (Amount newStakeBalance);
 
     /// @dev retuns the specified amount of dips to the holder of the specified stake nft.
     /// if dipAmount is set to Amount.max() all staked dips and all rewards are transferred to 
@@ -153,14 +172,6 @@ interface IStaking is
             Amount rewardsClaimedAmount
         );
 
-    //--- helper functions --------------------------------------------------//
-
-    /// @dev transfers the specified amount of dips from the from address to the staking wallet.
-    function collectDipAmount(address from, Amount dipAmount) external;
-
-    /// @dev transfers the specified amount of dips from the staking wallet to the to addess.
-    function transferDipAmount(address to, Amount dipAmount) external;
-
     //--- view and pure functions -------------------------------------------//
 
     function getStakingStore() external view returns (StakingStore stakingStore);

package/contracts/staking/IStakingService.sol

@@ -7,9 +7,7 @@ import {Amount} from "../type/Amount.sol";
 import {IService} from "../shared/IService.sol";
 import {IStaking} from "./IStaking.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType} from "../type/ObjectType.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {Timestamp} from "../type/Timestamp.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
 
@@ -28,16 +26,18 @@ interface IStakingService is IService
     event LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
     event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount, Amount stakeBalance);
     event LogStakingServiceUnstaked(NftId stakeNftId, address stakeOwner, Amount totalAmount);
+    event LogStakingServiceStakeRestaked(address stakeOwner, NftId indexed stakeNftId, NftId newStakeNftId, NftId indexed newTargetNftId, Amount indexed newStakeBalance);
 
     event LogStakingServiceRewardsUpdated(NftId stakeNftId);
     event LogStakingServiceRewardsClaimed(NftId stakeNftId, address stakeOwner, Amount rewardsClaimedAmount);
 
     // modifiers
-    error ErrorStakingServiceNotNftOwner(NftId nftId, address expectedOwner, address owner);
+    error ErrorStakingServiceNotStakingOwner(address account);
     error ErrorStakingServiceNotStaking(address stakingAddress);
     error ErrorStakingServiceNotSupportingIStaking(address stakingAddress);
 
     // create
+    error ErrorStakingServiceTargetUnknown(NftId targetNftId);
     error ErrorStakingServiceZeroTargetNftId();
     error ErrorStakingServiceNotTargetNftId(NftId targetNftId);
     error ErrorStakingServiceNotActiveTargetNftId(NftId targetNftId);
@@ -51,6 +51,13 @@ interface IStakingService is IService
     // function setProtocolLockingPeriod(Seconds lockingPeriod) external;
     // TODO also make sure that protocol rewards can be refilled and withdrawn
 
+    /// @dev Approves the staking token handler.
+    /// Reverts if the staking token handler wallet is not the token handler itself.
+    function approveTokenHandler(
+        IERC20Metadata token,
+        Amount amount
+    ) external;
+
     /// @dev creates/registers an on-chain instance staking target.
     /// function granted to instance service
     function createInstanceTarget(
@@ -67,6 +74,10 @@ interface IStakingService is IService
     /// Permissioned: Only owner of the specified target.
     function setInstanceRewardRate(NftId instanceNftId, UFixed rewardRate) external;
 
+    /// @dev Set the instance max staked amount to the specified value.
+    /// Permissioned: Only owner of the specified target.
+    function setInstanceMaxStakedAmount(NftId instanceNftId, Amount maxStakingAmount) external;
+
     /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the reward provider.
     /// unpermissioned: anybody may fill up staking reward reserves
     function refillInstanceRewardReserves(NftId instanceNftId, address rewardProvider, Amount dipAmount) external returns (Amount newBalance);
@@ -111,7 +122,8 @@ interface IStakingService is IService
     )
         external
         returns (
-            NftId newStakeNftId
+            NftId newStakeNftId,
+            Amount newStakeBalance
         );
 
 
@@ -148,13 +160,16 @@ interface IStakingService is IService
 
     function getDipToken()
         external
+        view
         returns (IERC20Metadata dip);
 
     function getTokenHandler()
         external
+        view
         returns (TokenHandler tokenHandler);
 
     function getStaking()
         external
+        view
         returns (IStaking staking);
 }