Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IProtocolWallet
•    - function getBalance()
•    - function topUp(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function setMaxAnnualRate(uint256 _an ...
•    - function getMaxAnnualRate()
•    - function resetOutstandingTokens(uint2 ...
•    - function emergencyWithdraw(address er ...
•    - function setClient(address _client)
•    - function _msgSender()
•    - function _msgData()
•  contract WithClaimableMigrationOwn ...
•    - function migrationOwner()
•    - function isMigrationOwner()
•    - function renounceMigrationOwnership()
•    - function _transferMigrationOwnership( ...
•    - function transferMigrationOwnership(a ...
•    - function claimMigrationOwnership()
•    - function pendingMigrationOwner()
•  contract WithClaimableFunctionalOw ...
•    - function functionalOwner()
•    - function isFunctionalOwner()
•    - function renounceFunctionalOwnership( ...
•    - function _transferFunctionalOwnership ...
•    - function transferFunctionalOwnership( ...
•    - function claimFunctionalOwnership()
•    - function pendingFunctionalOwner()
•  contract ProtocolWallet is IProtoc ... *
•    - function getBalance()
•    - function topUp(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function setMaxAnnualRate(uint256 _an ...
•    - function getMaxAnnualRate()
•    - function resetOutstandingTokens(uint2 ...
•    - function emergencyWithdraw(address er ...
•    - function setClient(address _client)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-11-04
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: contracts/spec_interfaces/IProtocolWallet.sol

pragma solidity 0.6.12;


/// @title Protocol Wallet interface
interface IProtocolWallet {
    event FundsAddedToPool(uint256 added, uint256 total);

    /*
    * External functions
    */

    /// Returns the address of the underlying staked token
    /// @return balance is the wallet balance
    function getBalance() external view returns (uint256 balance);

    /// Transfers the given amount of orbs tokens form the sender to this contract and updates the pool
    /// @dev assumes the caller approved the amount prior to calling
    /// @param amount is the amount to add to the wallet
    function topUp(uint256 amount) external;

    /// Withdraws from pool to the client address, limited by the pool's MaxRate.
    /// @dev may only be called by the wallet client
    /// @dev no more than MaxRate x time period since the last withdraw may be withdrawn
    /// @dev allocation that wasn't withdrawn can not be withdrawn in the next call
    /// @param amount is the amount to withdraw
    function withdraw(uint256 amount) external; /* onlyClient */


    /*
    * Governance functions
    */

    event ClientSet(address client);
    event MaxAnnualRateSet(uint256 maxAnnualRate);
    event EmergencyWithdrawal(address addr, address token);
    event OutstandingTokensReset(uint256 startTime);

    /// Sets a new annual withdraw rate for the pool
    /// @dev governance function called only by the migration owner
    /// @dev the rate for a duration is duration x annualRate / 1 year 
    /// @param _annualRate is the maximum annual rate that can be withdrawn
    function setMaxAnnualRate(uint256 _annualRate) external; /* onlyMigrationOwner */

    /// Returns the annual withdraw rate of the pool
    /// @return annualRate is the maximum annual rate that can be withdrawn
    function getMaxAnnualRate() external view returns (uint256);

    /// Resets the outstanding tokens to new start time
    /// @dev governance function called only by the migration owner
    /// @dev the next duration will be calculated starting from the given time
    /// @param startTime is the time to set as the last withdrawal time
    function resetOutstandingTokens(uint256 startTime) external; /* onlyMigrationOwner */

    /// Emergency withdraw the wallet funds
    /// @dev governance function called only by the migration owner
    /// @dev used in emergencies, when a migration to a new wallet is needed
    /// @param erc20 is the erc20 address of the token to withdraw
    function emergencyWithdraw(address erc20) external; /* onlyMigrationOwner */

    /// Sets the address of the client that can withdraw funds
    /// @dev governance function called only by the functional owner
    /// @param _client is the address of the new client
    function setClient(address _client) external; /* onlyFunctionalOwner */

}

// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: contracts/WithClaimableMigrationOwnership.sol

pragma solidity 0.6.12;


/**
 * @title Claimable
 * @dev Extension for the Ownable contract, where the ownership needs to be claimed.
 * This allows the new owner to accept the transfer.
 */
contract WithClaimableMigrationOwnership is Context{
    address private _migrationOwner;
    address private _pendingMigrationOwner;

    event MigrationOwnershipTransferred(address indexed previousMigrationOwner, address indexed newMigrationOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial migrationMigrationOwner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _migrationOwner = msgSender;
        emit MigrationOwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current migrationOwner.
     */
    function migrationOwner() public view returns (address) {
        return _migrationOwner;
    }

    /**
     * @dev Throws if called by any account other than the migrationOwner.
     */
    modifier onlyMigrationOwner() {
        require(isMigrationOwner(), "WithClaimableMigrationOwnership: caller is not the migrationOwner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current migrationOwner.
     */
    function isMigrationOwner() public view returns (bool) {
        return _msgSender() == _migrationOwner;
    }

    /**
     * @dev Leaves the contract without migrationOwner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current migrationOwner.
     *
     * NOTE: Renouncing migrationOwnership will leave the contract without an migrationOwner,
     * thereby removing any functionality that is only available to the migrationOwner.
     */
    function renounceMigrationOwnership() public onlyMigrationOwner {
        emit MigrationOwnershipTransferred(_migrationOwner, address(0));
        _migrationOwner = address(0);
    }

    /**
     * @dev Transfers migrationOwnership of the contract to a new account (`newOwner`).
     */
    function _transferMigrationOwnership(address newMigrationOwner) internal {
        require(newMigrationOwner != address(0), "MigrationOwner: new migrationOwner is the zero address");
        emit MigrationOwnershipTransferred(_migrationOwner, newMigrationOwner);
        _migrationOwner = newMigrationOwner;
    }

    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingMigrationOwner() {
        require(msg.sender == _pendingMigrationOwner, "Caller is not the pending migrationOwner");
        _;
    }
    /**
     * @dev Allows the current migrationOwner to set the pendingOwner address.
     * @param newMigrationOwner The address to transfer migrationOwnership to.
     */
    function transferMigrationOwnership(address newMigrationOwner) public onlyMigrationOwner {
        _pendingMigrationOwner = newMigrationOwner;
    }
    /**
     * @dev Allows the _pendingMigrationOwner address to finalize the transfer.
     */
    function claimMigrationOwnership() external onlyPendingMigrationOwner {
        _transferMigrationOwnership(_pendingMigrationOwner);
        _pendingMigrationOwner = address(0);
    }

    /**
     * @dev Returns the current _pendingMigrationOwner
    */
    function pendingMigrationOwner() public view returns (address) {
       return _pendingMigrationOwner;  
    }
}

// File: contracts/WithClaimableFunctionalOwnership.sol

pragma solidity 0.6.12;


/**
 * @title Claimable
 * @dev Extension for the Ownable contract, where the ownership needs to be claimed.
 * This allows the new owner to accept the transfer.
 */
contract WithClaimableFunctionalOwnership is Context{
    address private _functionalOwner;
    address private _pendingFunctionalOwner;

    event FunctionalOwnershipTransferred(address indexed previousFunctionalOwner, address indexed newFunctionalOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial functionalFunctionalOwner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _functionalOwner = msgSender;
        emit FunctionalOwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current functionalOwner.
     */
    function functionalOwner() public view returns (address) {
        return _functionalOwner;
    }

    /**
     * @dev Throws if called by any account other than the functionalOwner.
     */
    modifier onlyFunctionalOwner() {
        require(isFunctionalOwner(), "WithClaimableFunctionalOwnership: caller is not the functionalOwner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current functionalOwner.
     */
    function isFunctionalOwner() public view returns (bool) {
        return _msgSender() == _functionalOwner;
    }

    /**
     * @dev Leaves the contract without functionalOwner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current functionalOwner.
     *
     * NOTE: Renouncing functionalOwnership will leave the contract without an functionalOwner,
     * thereby removing any functionality that is only available to the functionalOwner.
     */
    function renounceFunctionalOwnership() public onlyFunctionalOwner {
        emit FunctionalOwnershipTransferred(_functionalOwner, address(0));
        _functionalOwner = address(0);
    }

    /**
     * @dev Transfers functionalOwnership of the contract to a new account (`newOwner`).
     */
    function _transferFunctionalOwnership(address newFunctionalOwner) internal {
        require(newFunctionalOwner != address(0), "FunctionalOwner: new functionalOwner is the zero address");
        emit FunctionalOwnershipTransferred(_functionalOwner, newFunctionalOwner);
        _functionalOwner = newFunctionalOwner;
    }

    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingFunctionalOwner() {
        require(msg.sender == _pendingFunctionalOwner, "Caller is not the pending functionalOwner");
        _;
    }
    /**
     * @dev Allows the current functionalOwner to set the pendingOwner address.
     * @param newFunctionalOwner The address to transfer functionalOwnership to.
     */
    function transferFunctionalOwnership(address newFunctionalOwner) public onlyFunctionalOwner {
        _pendingFunctionalOwner = newFunctionalOwner;
    }
    /**
     * @dev Allows the _pendingFunctionalOwner address to finalize the transfer.
     */
    function claimFunctionalOwnership() external onlyPendingFunctionalOwner {
        _transferFunctionalOwnership(_pendingFunctionalOwner);
        _pendingFunctionalOwner = address(0);
    }

    /**
     * @dev Returns the current _pendingFunctionalOwner
    */
    function pendingFunctionalOwner() public view returns (address) {
       return _pendingFunctionalOwner;  
    }
}

// File: contracts/ProtocolWallet.sol

pragma solidity 0.6.12;






/// @title Protocol Wallet contract
/// @dev the protocol wallet utilizes two claimable owners: migrationOwner and functionalOwner
contract ProtocolWallet is IProtocolWallet, WithClaimableMigrationOwnership, WithClaimableFunctionalOwnership {
    using SafeMath for uint256;

    IERC20 public token;
    address public client;
    uint256 public lastWithdrawal;
    uint256 maxAnnualRate;

    /// Constructor
    /// @param _token is the wallet token
    /// @param _client is the initial wallet client address
    /// @param _maxAnnualRate is the maximum annual rate that can be withdrawn
    constructor(IERC20 _token, address _client, uint256 _maxAnnualRate) public {
        token = _token;
        client = _client;
        lastWithdrawal = block.timestamp;

        setMaxAnnualRate(_maxAnnualRate);
    }

    modifier onlyClient() {
        require(msg.sender == client, "caller is not the wallet client");

        _;
    }

    /*
    * External functions
    */

    /// Returns the address of the underlying staked token
    /// @return balance is the wallet balance
    function getBalance() public override view returns (uint256 balance) {
        return token.balanceOf(address(this));
    }

    /// Transfers the given amount of orbs tokens form the sender to this contract and updates the pool
    /// @dev assumes the caller approved the amount prior to calling
    /// @param amount is the amount to add to the wallet
    function topUp(uint256 amount) external override {
        emit FundsAddedToPool(amount, getBalance().add(amount));
        require(token.transferFrom(msg.sender, address(this), amount), "ProtocolWallet::topUp - insufficient allowance");
    }

    /// Withdraws from pool to the client address, limited by the pool's MaxRate.
    /// @dev may only be called by the wallet client
    /// @dev no more than MaxRate x time period since the last withdraw may be withdrawn
    /// @dev allocation that wasn't withdrawn can not be withdrawn in the next call
    /// @param amount is the amount to withdraw
    function withdraw(uint256 amount) external override onlyClient {
        uint256 _lastWithdrawal = lastWithdrawal;
        require(_lastWithdrawal <= block.timestamp, "withdrawal is not yet active");

        uint duration = block.timestamp.sub(_lastWithdrawal);
        require(amount.mul(365 * 24 * 60 * 60) <= maxAnnualRate.mul(duration), "ProtocolWallet::withdraw - requested amount is larger than allowed by rate");

        lastWithdrawal = block.timestamp;
        if (amount > 0) {
            require(token.transfer(msg.sender, amount), "ProtocolWallet::withdraw - transfer failed");
        }
    }

    /*
    * Governance functions
    */

    /// Sets a new annual withdraw rate for the pool
    /// @dev governance function called only by the migration owner
    /// @dev the rate for a duration is duration x annualRate / 1 year
    /// @param _annualRate is the maximum annual rate that can be withdrawn
    function setMaxAnnualRate(uint256 _annualRate) public override onlyMigrationOwner {
        maxAnnualRate = _annualRate;
        emit MaxAnnualRateSet(_annualRate);
    }

    /// Returns the annual withdraw rate of the pool
    /// @return annualRate is the maximum annual rate that can be withdrawn
    function getMaxAnnualRate() external override view returns (uint256) {
        return maxAnnualRate;
    }

    /// Resets the outstanding tokens to new start time
    /// @dev governance function called only by the migration owner
    /// @dev the next duration will be calculated starting from the given time
    /// @param startTime is the time to set as the last withdrawal time
    function resetOutstandingTokens(uint256 startTime) external override onlyMigrationOwner {
        lastWithdrawal = startTime;
        emit OutstandingTokensReset(startTime);
    }

    /// Emergency withdraw the wallet funds
    /// @dev governance function called only by the migration owner
    /// @dev used in emergencies, when a migration to a new wallet is needed
    /// @param erc20 is the erc20 address of the token to withdraw
    function emergencyWithdraw(address erc20) external override onlyMigrationOwner {
        IERC20 _token = IERC20(erc20);
        emit EmergencyWithdrawal(msg.sender, address(_token));
        require(_token.transfer(msg.sender, _token.balanceOf(address(this))), "FeesWallet::emergencyWithdraw - transfer failed");
    }

    /// Sets the address of the client that can withdraw funds
    /// @dev governance function called only by the functional owner
    /// @param _client is the address of the new client
    function setClient(address _client) external override onlyFunctionalOwner {
        client = _client;
        emit ClientSet(_client);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"address","name":"_client","type":"address"},{"internalType":"uint256","name":"_maxAnnualRate","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"client","type":"address"}],"name":"ClientSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"EmergencyWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousFunctionalOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newFunctionalOwner","type":"address"}],"name":"FunctionalOwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"added","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"}],"name":"FundsAddedToPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxAnnualRate","type":"uint256"}],"name":"MaxAnnualRateSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousMigrationOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newMigrationOwner","type":"address"}],"name":"MigrationOwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"OutstandingTokensReset","type":"event"},{"inputs":[],"name":"claimFunctionalOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimMigrationOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"client","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"erc20","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"functionalOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxAnnualRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFunctionalOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMigrationOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastWithdrawal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"migrationOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingFunctionalOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingMigrationOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceFunctionalOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceMigrationOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"resetOutstandingTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_client","type":"address"}],"name":"setClient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_annualRate","type":"uint256"}],"name":"setMaxAnnualRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"topUp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newFunctionalOwner","type":"address"}],"name":"transferFunctionalOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMigrationOwner","type":"address"}],"name":"transferMigrationOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

19572:4736:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13505:112;;;:::i;:::-;;;;;;;;;;;;;;;;;;19750:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;20558:125;;;:::i;:::-;;;;;;;;;;;;;;;;18967:191;;;:::i;:::-;;19778:29;;;:::i;15602:112::-;;;:::i;14013:185::-;;;:::i;13052:97::-;;;:::i;21539:619::-;;;;;;;;;;;;;;;;-1:-1:-1;21539:619:0;;:::i;17102:114::-;;;:::i;17617:190::-;;;:::i;22484:173::-;;;;;;;;;;;;;;;;-1:-1:-1;22484:173:0;;:::i;20924:246::-;;;;;;;;;;;;;;;;-1:-1:-1;20924:246:0;;:::i;23641:322::-;;;;;;;;;;;;;;;;-1:-1:-1;23641:322:0;;;;:::i;15335:186::-;;;:::i;24162:143::-;;;;;;;;;;;;;;;;-1:-1:-1;24162:143:0;;;;:::i;19240:114::-;;;:::i;18706:155::-;;;;;;;;;;;;;;;;-1:-1:-1;18706:155:0;;;;:::i;15080:150::-;;;;;;;;;;;;;;;;-1:-1:-1;15080:150:0;;;;:::i;23191:182::-;;;;;;;;;;;;;;;;-1:-1:-1;23191:182:0;;:::i;16641:99::-;;;:::i;22796:108::-;;;:::i;19724:19::-;;;:::i;13505:112::-;13554:4;13594:15;;;;13578:12;:10;:12::i;:::-;:31;;;13571:38;;13505:112;:::o;19750:21::-;;;;;;:::o;20558:125::-;20645:5;;;:30;;;;;;20669:4;20645:30;;;;;;;;20610:15;;20645:5;;;;;:15;;:30;;;;;;;;;;;;;;:5;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20645:30:0;;-1:-1:-1;20558:125:0;:::o;18967:191::-;18430:23;;;;18416:10;:37;18408:91;;;;-1:-1:-1;;;18408:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19079:23:::1;::::0;19050:53:::1;::::0;19079:23:::1;;19050:28;:53::i;:::-;19114:23;:36:::0;;;::::1;::::0;;18967:191::o;19778:29::-;;;;:::o;15602:112::-;15682:22;;;;15602:112;:::o;14013:185::-;13300:18;:16;:18::i;:::-;13292:96;;;;-1:-1:-1;;;13292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14148:1:::1;14123:15:::0;;14093:58:::1;::::0;::::1;14123:15:::0;;::::1;::::0;14093:58:::1;::::0;14148:1;;14093:58:::1;14188:1;14162:28:::0;;;::::1;::::0;;14013:185::o;13052:97::-;13099:7;13126:15;;;13052:97;:::o;21539:619::-;20335:6;;;;20321:10;:20;20313:64;;;;;-1:-1:-1;;;20313:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21639:14:::1;::::0;21691:15:::1;21672:34:::0;::::1;;21664:75;;;::::0;;-1:-1:-1;;;21664:75:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;21752:13;21768:36;:15;21788::::0;21768:19:::1;:36::i;:::-;21857:13;::::0;21752:52;;-1:-1:-1;21857:27:0::1;::::0;21752:52;21857:17:::1;:27::i;:::-;21823:30;:6:::0;21834:18:::1;21823:10;:30::i;:::-;:61;;21815:148;;;;-1:-1:-1::0;;;21815:148:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21993:15;21976:14;:32:::0;22023:10;;22019:132:::1;;22058:5;::::0;;:34:::1;::::0;;;;;22073:10:::1;22058:34:::0;;::::1;::::0;;;;;;;;;;;:5:::1;::::0;;::::1;::::0;:14:::1;::::0;:34;;;;;::::1;::::0;;;;;;;;:5:::1;::::0;:34;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;22058:34:0;22050:89:::1;;;;-1:-1:-1::0;;;22050:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20390:1;;21539:619:::0;:::o;17102:114::-;17192:16;;17152:4;;17192:16;;17176:12;:10;:12::i;17617:190::-;16893:19;:17;:19::i;:::-;16885:99;;;;-1:-1:-1;;;16885:99:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17730:16:::1;::::0;17699:60:::1;::::0;17756:1:::1;::::0;17699:60:::1;17730:16;::::0;17699:60:::1;::::0;17756:1;;17699:60:::1;17770:16;:29:::0;;;::::1;::::0;;17617:190::o;22484:173::-;13300:18;:16;:18::i;:::-;13292:96;;;;-1:-1:-1;;;13292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22577:13:::1;:27:::0;;;22620:29:::1;::::0;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;22484:173:::0;:::o;20924:246::-;20989:50;21006:6;21014:24;21031:6;21014:12;:10;:12::i;:::-;:16;;:24::i;:::-;20989:50;;;;;;;;;;;;;;;;;;;;;;21058:5;;;:53;;;;;;21077:10;21058:53;;;;;;;21097:4;21058:53;;;;;;;;;;;:5;;;;;:18;;:53;;;;;;;;;;;;;;:5;;:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21058:53:0;21050:112;;;;-1:-1:-1;;;21050:112:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20924:246;:::o;23641:322::-;13300:18;:16;:18::i;:::-;13292:96;;;;-1:-1:-1;;;13292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23776:48:::1;::::0;;23796:10:::1;23776:48:::0;;::::1;::::0;::::1;;::::0;::::1;::::0;;;23754:5;;23776:48:::1;::::0;;;;;;::::1;23843:6;:15;;;23859:10;23871:6;:16;;;23896:4;23871:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;23871:31:0;23843:60:::1;::::0;;;::::1;::::0;;;;;;::::1;::::0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;23871:31:::1;::::0;23843:60;;;;;;;-1:-1:-1;23843:60:0;;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;23843:60:0;23835:120:::1;;;;-1:-1:-1::0;;;23835:120:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13399:1;23641:322:::0;:::o;15335:186::-;14809:22;;;;14795:10;:36;14787:89;;;;-1:-1:-1;;;14787:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15444:22:::1;::::0;15416:51:::1;::::0;15444:22:::1;;15416:27;:51::i;:::-;15478:22;:35:::0;;;::::1;::::0;;15335:186::o;24162:143::-;16893:19;:17;:19::i;:::-;16885:99;;;;-1:-1:-1;;;16885:99:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24247:6:::1;:16:::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;24279:18:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;24162:143:::0;:::o;19240:114::-;19321:23;;;;19240:114;:::o;18706:155::-;16893:19;:17;:19::i;:::-;16885:99;;;;-1:-1:-1;;;16885:99:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18809:23:::1;:44:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;18706:155::o;15080:150::-;13300:18;:16;:18::i;:::-;13292:96;;;;-1:-1:-1;;;13292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15180:22:::1;:42:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;15080:150::o;23191:182::-;13300:18;:16;:18::i;:::-;13292:96;;;;-1:-1:-1;;;13292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23290:14:::1;:26:::0;;;23332:33:::1;::::0;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;23191:182:::0;:::o;16641:99::-;16716:16;;;;16641:99;:::o;22796:108::-;22883:13;;22796:108;:::o;19724:19::-;;;;;;:::o;11790:106::-;11878:10;11790:106;:::o;17923:327::-;18017:32;;;18009:101;;;;-1:-1:-1;;;18009:101:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18157:16;;18126:68;;;;;;;18157:16;;18126:68;;18157:16;;18126:68;18205:16;:37;;;;;;;;;;;;;;;17923:327::o;4219:136::-;4277:7;4304:43;4308:1;4311;4304:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4297:50;;4219:136;;;;;:::o;5109:471::-;5167:7;5412:6;5408:47;;-1:-1:-1;5442:1:0;5435:8;;5408:47;5479:5;;;5483:1;5479;:5;:1;5503:5;;;;;:10;5495:56;;;;-1:-1:-1;;;5495:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3755:181;3813:7;3845:5;;;3869:6;;;;3861:46;;;;;-1:-1:-1;;;3861:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;14313:317;14405:31;;;14397:98;;;;-1:-1:-1;;;14397:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14541:15;;;14511:65;;;;;;;14541:15;;;14511:65;;;14587:15;:35;;;;;;;;;;;;;;;14313:317::o;4658:192::-;4744:7;4780:12;4772:6;;;;4764:29;;;;-1:-1:-1;;;4764:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4816:5:0;;;4658:192::o

ipfs://5bea6d61c0509b01fa676d039fa937764073d84a95209676c2241dde32a8689d