Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-06-13
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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;
    }
}


contract Timelock {
    using SafeMath for uint;

    event NewAdmin(address indexed newAdmin);
    event NewPendingAdmin(address indexed newPendingAdmin);
    event NewDelay(uint indexed newDelay);
    event CancelTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature,  bytes data, uint eta);
    event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature,  bytes data, uint eta);
    event QueueTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);

    uint public constant GRACE_PERIOD = 14 days;
    uint public constant MINIMUM_DELAY = 24 hours;
    uint public constant MAXIMUM_DELAY = 30 days;

    address public admin;
    address public pendingAdmin;
    uint public delay;
    bool public admin_initialized;

    mapping (bytes32 => bool) public queuedTransactions;


    constructor(address admin_, uint delay_) public {
        require(delay_ >= MINIMUM_DELAY, "Timelock::constructor: Delay must exceed minimum delay.");
        require(delay_ <= MAXIMUM_DELAY, "Timelock::constructor: Delay must not exceed maximum delay.");

        admin = admin_;
        delay = delay_;
        admin_initialized = false;
    }

    receive() external payable { }

    function setDelay(uint delay_) public {
        require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
        require(delay_ >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(delay_ <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = delay_;

        emit NewDelay(delay);
    }

    function acceptAdmin() public {
        require(msg.sender == pendingAdmin, "Timelock::acceptAdmin: Call must come from pendingAdmin.");
        admin = msg.sender;
        pendingAdmin = address(0);

        emit NewAdmin(admin);
    }

    function setPendingAdmin(address pendingAdmin_) public {
        // allows one time setting of admin for deployment purposes
        if (admin_initialized) {
            require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
        } else {
            require(msg.sender == admin, "Timelock::setPendingAdmin: First call must come from admin.");
            admin_initialized = true;
        }
        pendingAdmin = pendingAdmin_;

        emit NewPendingAdmin(pendingAdmin);
    }

    function queueTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public returns (bytes32) {
        require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
        require(eta >= getBlockTimestamp().add(delay), "Timelock::queueTransaction: Estimated execution block must satisfy delay.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = true;

        emit QueueTransaction(txHash, target, value, signature, data, eta);
        return txHash;
    }

    function cancelTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public {
        require(msg.sender == admin, "Timelock::cancelTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = false;

        emit CancelTransaction(txHash, target, value, signature, data, eta);
    }

    function executeTransaction(address target, uint _value, string memory signature, bytes memory data, uint eta) public payable returns (bytes memory) {
        require(msg.sender == admin, "Timelock::executeTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, _value, signature, data, eta));
        require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
        require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
        require(getBlockTimestamp() <= eta.add(GRACE_PERIOD), "Timelock::executeTransaction: Transaction is stale.");

        queuedTransactions[txHash] = false;

        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }

        // solium-disable-next-line security/no-call-value
        (bool success, bytes memory returnData) = target.call{value:_value}(callData);
        require(success, "Timelock::executeTransaction: Transaction execution reverted.");

        emit ExecuteTransaction(txHash, target, _value, signature, data, eta);

        return returnData;
    }

    function getBlockTimestamp() internal view returns (uint) {
        // solium-disable-next-line security/no-block-members
        return block.timestamp;
    }
}

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);
}



library Address {
    /**
    * @dev Returns true if `account` is a contract.
    *
    * [IMPORTANT]
    * ====
    * It is unsafe to assume that an address for which this function returns
    * false is an externally-owned account (EOA) and not a contract.
    *
    * Among others, `isContract` will return false for the following
    * types of addresses:
    *
    *  - an externally-owned account
    *  - a contract in construction
    *  - an address where a contract will be created
    *  - an address where a contract lived, but was destroyed
    * ====
    */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
    * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
    * `recipient`, forwarding all available gas and reverting on errors.
    *
    * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
    * of certain opcodes, possibly making contracts go over the 2300 gas limit
    * imposed by `transfer`, making them unable to receive funds via
    * `transfer`. {sendValue} removes this limitation.
    *
    * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
    *
    * IMPORTANT: because control is transferred to `recipient`, care must be
    * taken to not create reentrancy vulnerabilities. Consider using
    * {ReentrancyGuard} or the
    * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
    */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
    * @dev Performs a Solidity function call using a low level `call`. A
    * plain`call` is an unsafe replacement for a function call: use this
    * function instead.
    *
    * If `target` reverts with a revert reason, it is bubbled up by this
    * function (like regular Solidity function calls).
    *
    * Returns the raw returned data. To convert to the expected return value,
    * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
    *
    * Requirements:
    *
    * - `target` must be a contract.
    * - calling `target` with `data` must not revert.
    *
    * _Available since v3.1._
    */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    return functionCall(target, data, "Address: low-level call failed");
    }

    /**
    * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
    * `errorMessage` as a fallback revert reason when `target` reverts.
    *
    * _Available since v3.1._
    */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
    * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    * but also transferring `value` wei to `target`.
    *
    * Requirements:
    *
    * - the calling contract must have an ETH balance of at least `value`.
    * - the called Solidity function must be `payable`.
    *
    * _Available since v3.1._
    */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
    * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
    * with `errorMessage` as a fallback revert reason when `target` reverts.
    *
    * _Available since v3.1._
    */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


/**
* @title SafeERC20
* @dev Wrappers around ERC20 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.
*/
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
    * @dev Deprecated. This function has issues similar to the ones found in
    * {IERC20-approve}, and its usage is discouraged.
    *
    * Whenever possible, use {safeIncreaseAllowance} and
    * {safeDecreaseAllowance} instead.
    */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
    * @dev 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).
    */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

/**
* @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.
*/


/*
* @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;
    }
}

/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

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

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

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

    /**
    * @dev Transfers ownership of the contract to a new account (`newOwner`).
    * Can only be called by the current owner.
    */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}
//This contract is dedicated for funds taken from users that may be affected 
//It secures, t
contract SaverStorage is Ownable{
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address constant MATIC_BRIDGE = 0x1f0d1927498FBD4f9E8558704Ce5B658929527Ec;
    address saver;

    mapping (address => mapping (address => uint256)) public userDeposits;
    
    modifier onlySaver() {
        require(saver == _msgSender(), "Not Saver");
        _;
    }

    event Withdraw(address indexed token, address indexed user, uint256 amount);
    
    constructor() public {
    }
    function updateSaver(address _saver) external onlyOwner {   
       saver = _saver;
    }
    

    function deposit(address token, address user, uint256 amount) external onlySaver {   
       IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
       userDeposits[token][user] = userDeposits[token][user].add(amount); 
    }
    
    function withdraw(address token, uint256 amount) external  {   
        require(userDeposits[token][msg.sender] >= amount, "Not enough funds");
        require(userAllowance(token, msg.sender) == 0, "Remove your allowance firstly");
        userDeposits[token][msg.sender] = userDeposits[token][msg.sender].sub(amount);
        IERC20(token).safeTransfer(msg.sender, amount);
        emit Withdraw(token, msg.sender, amount);
    }
    
    function getFunds(address token, address user, uint256 amount) external onlyOwner {   
        IERC20(token).safeTransfer(user, amount);
    }
    
    function userAllowance(address token, address user) public view returns (uint256) {
        return IERC20(token).allowance(user, MATIC_BRIDGE);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_saver","type":"address"}],"name":"updateSaver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"user","type":"address"}],"name":"userAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

25575:1637:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25785:69;;;;;;;;;;;;;;;;-1:-1:-1;25785:69:0;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;26902:144;;;;;;;;;;;;;;;;-1:-1:-1;26902:144:0;;;;;;;;;;;;;;;;;;:::i;:::-;;24930:148;;;:::i;26198:243::-;;;;;;;;;;;;;;;;-1:-1:-1;26198:243:0;;;;;;;;;;;;;;;;;;:::i;26093:91::-;;;;;;;;;;;;;;;;-1:-1:-1;26093:91:0;;;;:::i;24296:79::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27058:151;;;;;;;;;;;;;;;;-1:-1:-1;27058:151:0;;;;;;;;;;;:::i;25230:244::-;;;;;;;;;;;;;;;;-1:-1:-1;25230:244:0;;;;:::i;26453:437::-;;;;;;;;;;;;;;;;-1:-1:-1;26453:437:0;;;;;;;;;:::i;25785:69::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;26902:144::-;24516:12;:10;:12::i;:::-;24506:6;;:22;:6;;;:22;;;24498:67;;;;;-1:-1:-1;;;24498:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26998:40:::1;:26;::::0;::::1;27025:4:::0;27031:6;26998:26:::1;:40::i;:::-;26902:144:::0;;;:::o;24930:148::-;24516:12;:10;:12::i;:::-;24506:6;;:22;:6;;;:22;;;24498:67;;;;;-1:-1:-1;;;24498:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25037:1:::1;25021:6:::0;;25000:40:::1;::::0;::::1;25021:6:::0;;::::1;::::0;25000:40:::1;::::0;25037:1;;25000:40:::1;25068:1;25051:19:::0;;;::::1;::::0;;24930:148::o;26198:243::-;25916:12;:10;:12::i;:::-;25907:5;;:21;:5;;;:21;;;25899:43;;;;;-1:-1:-1;;;25899:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26292:65:::1;:30;::::0;::::1;26323:10;26343:4;26350:6:::0;26292:30:::1;:65::i;:::-;26395:19;::::0;;::::1;;::::0;;;:12:::1;:19;::::0;;;;;;;:25;;::::1;::::0;;;;;;;:37:::1;::::0;26425:6;26395:29:::1;:37::i;:::-;26367:19;::::0;;::::1;;::::0;;;:12:::1;:19;::::0;;;;;;;:25;;;::::1;::::0;;;;;;;;;;:65;;;;-1:-1:-1;26198:243:0:o;26093:91::-;24516:12;:10;:12::i;:::-;24506:6;;:22;:6;;;:22;;;24498:67;;;;;-1:-1:-1;;;24498:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26162:5:::1;:14:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;26093:91::o;24296:79::-;24334:7;24361:6;;;24296:79;:::o;27058:151::-;27158:43;;;;;;:23;:43;;;;;;;25714:42;27158:43;;;;;;27131:7;;27158:23;;;;;:43;;;;;;;;;;;;;;:23;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27158:43:0;;27058:151;-1:-1:-1;;;27058:151:0:o;25230:244::-;24516:12;:10;:12::i;:::-;24506:6;;:22;:6;;;:22;;;24498:67;;;;;-1:-1:-1;;;24498:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25319:22:::1;::::0;::::1;25311:73;;;;-1:-1:-1::0;;;25311:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25421:6;::::0;;25400:38:::1;::::0;::::1;::::0;;::::1;::::0;25421:6;::::1;::::0;25400:38:::1;::::0;::::1;25449:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;25230:244::o;26453:437::-;26534:19;;;;;;;:12;:19;;;;;;;;26554:10;26534:31;;;;;;;;:41;-1:-1:-1;26534:41:0;26526:70;;;;;-1:-1:-1;;;26526:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26615:32;26629:5;26636:10;26615:13;:32::i;:::-;:37;26607:79;;;;;-1:-1:-1;;;26607:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26731:19;;;;;;;:12;:19;;;;;;;;26751:10;26731:31;;;;;;;;:43;;26767:6;26731:35;:43::i;:::-;26697:19;;;;;;;:12;:19;;;;;;;;26717:10;26697:31;;;;;;;;:77;;;;26785:46;;26824:6;26785:26;:46::i;:::-;26847:35;;;;;;;;26863:10;;26847:35;;;;;;;;;;;;;26453:437;;:::o;22949:106::-;23037:10;22949:106;:::o;18784:177::-;18894:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18917:23;18894:58;;;18867:86;;18887:5;;18867:19;:86::i;18969:205::-;19097:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19120:27;19097:68;;;19070:96;;19090:5;;19070:19;:96::i;:::-;18969:205;;;;:::o;316:181::-;374:7;406:5;;;430:6;;;;422:46;;;;;-1:-1:-1;;;422:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;488:1;316:181;-1:-1:-1;;;316:181:0:o;771:136::-;829:7;856:43;860:1;863;856:43;;;;;;;;;;;;;;;;;:3;:43::i;21078:761::-;21502:23;21528:69;21556:4;21528:69;;;;;;;;;;;;;;;;;21536:5;21528:27;;;;:69;;;;;:::i;:::-;21612:17;;21502:95;;-1:-1:-1;21612:21:0;21608:224;;21754:10;21743:30;;;;;;;;;;;;;;;-1:-1:-1;21743:30:0;21735:85;;;;-1:-1:-1;;;21735:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1201:192;1287:7;1323:12;1315:6;;;;1307:29;;;;-1:-1:-1;;;1307:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1359:5:0;;;1201:192::o;15883:196::-;15986:12;16018:53;16041:6;16049:4;16055:1;16058:12;16018:22;:53::i;:::-;16011:60;15883:196;-1:-1:-1;;;;15883:196:0:o;17245:979::-;17375:12;17408:18;17419:6;17408:10;:18::i;:::-;17400:60;;;;;-1:-1:-1;;;17400:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;17534:12;17548:23;17575:6;:11;;17595:8;17606:4;17575:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17533:78;;;;17626:7;17622:595;;;17657:10;-1:-1:-1;17650:17:0;;-1:-1:-1;17650:17:0;17622:595;17771:17;;:21;17767:439;;18034:10;18028:17;18095:15;18082:10;18078:2;18074:19;18067:44;17982:148;18170:20;;-1:-1:-1;;;18170:20:0;;;;;;;;;;;;;;;;;18177:12;;18170:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13004:422;13371:20;13410:8;;;13004:422::o

ipfs://f128064000393b5037813a249c949c44072752cc2a189c636c98fd7bae38675b