/

    Contract Diff Checker

    Contract Name:
    USDG

    Contract Source Code:

    File 1 of 1 : USDG

    // SPDX-License-Identifier: MIT
    
    pragma solidity 0.6.12;
    
    /**
     * @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;
        }
    }
    pragma solidity 0.6.12;
    
    /**
     * @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);
    }
    pragma solidity ^0.6.2;
    
    /**
     * @dev Collection of functions related to the address type
     */
    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 on 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");
            require(isContract(target), "Address: call to non-contract");
    
            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory returndata) = target.call{ value: value }(data);
            return _verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
            return functionStaticCall(target, data, "Address: low-level static call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
            require(isContract(target), "Address: static call to non-contract");
    
            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory returndata) = target.staticcall(data);
            return _verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.3._
         */
        function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionDelegateCall(target, data, "Address: low-level delegate call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.3._
         */
        function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
            require(isContract(target), "Address: delegate call to non-contract");
    
            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory returndata) = target.delegatecall(data);
            return _verifyCallResult(success, returndata, errorMessage);
        }
    
        function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
            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);
                }
            }
        }
    }
    pragma solidity 0.6.12;
    
    interface IYieldTracker {
        function claim(address _account, address _receiver) external returns (uint256);
        function updateRewards(address _account) external;
        function getTokensPerInterval() external view returns (uint256);
        function claimable(address _account) external view returns (uint256);
    }
    pragma solidity 0.6.12;
    
    interface IYieldToken {
        function totalStaked() external view returns (uint256);
        function stakedBalance(address _account) external view returns (uint256);
        function removeAdmin(address _account) external;
    }
    pragma solidity 0.6.12;
    
    /**
     * @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");
            }
        }
    }
    pragma solidity 0.6.12;
    
    interface IUSDG {
        function addVault(address _vault) external;
        function removeVault(address _vault) external;
        function mint(address _account, uint256 _amount) external;
        function burn(address _account, uint256 _amount) external;
    }
    pragma solidity 0.6.12;
    
    contract YieldToken is IERC20, IYieldToken {
        using SafeMath for uint256;
        using SafeERC20 for IERC20;
    
        string public name;
        string public symbol;
        uint8 public constant decimals = 18;
    
        uint256 public override totalSupply;
        uint256 public nonStakingSupply;
    
        address public gov;
    
        mapping (address => uint256) public balances;
        mapping (address => mapping (address => uint256)) public allowances;
    
        address[] public yieldTrackers;
        mapping (address => bool) public nonStakingAccounts;
        mapping (address => bool) public admins;
    
        bool public inWhitelistMode;
        mapping (address => bool) public whitelistedHandlers;
    
        modifier onlyGov() {
            require(msg.sender == gov, "YieldToken: forbidden");
            _;
        }
    
        modifier onlyAdmin() {
            require(admins[msg.sender], "YieldToken: forbidden");
            _;
        }
    
        constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
            name = _name;
            symbol = _symbol;
            gov = msg.sender;
            admins[msg.sender] = true;
            _mint(msg.sender, _initialSupply);
        }
    
        function setGov(address _gov) external onlyGov {
            gov = _gov;
        }
    
        function setInfo(string memory _name, string memory _symbol) external onlyGov {
            name = _name;
            symbol = _symbol;
        }
    
        function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
            yieldTrackers = _yieldTrackers;
        }
    
        function addAdmin(address _account) external onlyGov {
            admins[_account] = true;
        }
    
        function removeAdmin(address _account) external override onlyGov {
            admins[_account] = false;
        }
    
        // to help users who accidentally send their tokens to this contract
        function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
            IERC20(_token).safeTransfer(_account, _amount);
        }
    
        function setInWhitelistMode(bool _inWhitelistMode) external onlyGov {
            inWhitelistMode = _inWhitelistMode;
        }
    
        function setWhitelistedHandler(address _handler, bool _isWhitelisted) external onlyGov {
            whitelistedHandlers[_handler] = _isWhitelisted;
        }
    
        function addNonStakingAccount(address _account) external onlyAdmin {
            require(!nonStakingAccounts[_account], "YieldToken: _account already marked");
            _updateRewards(_account);
            nonStakingAccounts[_account] = true;
            nonStakingSupply = nonStakingSupply.add(balances[_account]);
        }
    
        function removeNonStakingAccount(address _account) external onlyAdmin {
            require(nonStakingAccounts[_account], "YieldToken: _account not marked");
            _updateRewards(_account);
            nonStakingAccounts[_account] = false;
            nonStakingSupply = nonStakingSupply.sub(balances[_account]);
        }
    
        function recoverClaim(address _account, address _receiver) external onlyAdmin {
            for (uint256 i = 0; i < yieldTrackers.length; i++) {
                address yieldTracker = yieldTrackers[i];
                IYieldTracker(yieldTracker).claim(_account, _receiver);
            }
        }
    
        function claim(address _receiver) external {
            for (uint256 i = 0; i < yieldTrackers.length; i++) {
                address yieldTracker = yieldTrackers[i];
                IYieldTracker(yieldTracker).claim(msg.sender, _receiver);
            }
        }
    
        function totalStaked() external view override returns (uint256) {
            return totalSupply.sub(nonStakingSupply);
        }
    
        function balanceOf(address _account) external view override returns (uint256) {
            return balances[_account];
        }
    
        function stakedBalance(address _account) external view override returns (uint256) {
            if (nonStakingAccounts[_account]) {
                return 0;
            }
            return balances[_account];
        }
    
        function transfer(address _recipient, uint256 _amount) external override returns (bool) {
            _transfer(msg.sender, _recipient, _amount);
            return true;
        }
    
        function allowance(address _owner, address _spender) external view override returns (uint256) {
            return allowances[_owner][_spender];
        }
    
        function approve(address _spender, uint256 _amount) external override returns (bool) {
            _approve(msg.sender, _spender, _amount);
            return true;
        }
    
        function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
            uint256 nextAllowance = allowances[_sender][msg.sender].sub(_amount, "YieldToken: transfer amount exceeds allowance");
            _approve(_sender, msg.sender, nextAllowance);
            _transfer(_sender, _recipient, _amount);
            return true;
        }
    
        function _mint(address _account, uint256 _amount) internal {
            require(_account != address(0), "YieldToken: mint to the zero address");
    
            _updateRewards(_account);
    
            totalSupply = totalSupply.add(_amount);
            balances[_account] = balances[_account].add(_amount);
    
            if (nonStakingAccounts[_account]) {
                nonStakingSupply = nonStakingSupply.add(_amount);
            }
    
            emit Transfer(address(0), _account, _amount);
        }
    
        function _burn(address _account, uint256 _amount) internal {
            require(_account != address(0), "YieldToken: burn from the zero address");
    
            _updateRewards(_account);
    
            balances[_account] = balances[_account].sub(_amount, "YieldToken: burn amount exceeds balance");
            totalSupply = totalSupply.sub(_amount);
    
            if (nonStakingAccounts[_account]) {
                nonStakingSupply = nonStakingSupply.sub(_amount);
            }
    
            emit Transfer(_account, address(0), _amount);
        }
    
        function _transfer(address _sender, address _recipient, uint256 _amount) private {
            require(_sender != address(0), "YieldToken: transfer from the zero address");
            require(_recipient != address(0), "YieldToken: transfer to the zero address");
    
            if (inWhitelistMode) {
                require(whitelistedHandlers[msg.sender], "YieldToken: msg.sender not whitelisted");
            }
    
            _updateRewards(_sender);
            _updateRewards(_recipient);
    
            balances[_sender] = balances[_sender].sub(_amount, "YieldToken: transfer amount exceeds balance");
            balances[_recipient] = balances[_recipient].add(_amount);
    
            if (nonStakingAccounts[_sender]) {
                nonStakingSupply = nonStakingSupply.sub(_amount);
            }
            if (nonStakingAccounts[_recipient]) {
                nonStakingSupply = nonStakingSupply.add(_amount);
            }
    
            emit Transfer(_sender, _recipient,_amount);
        }
    
        function _approve(address _owner, address _spender, uint256 _amount) private {
            require(_owner != address(0), "YieldToken: approve from the zero address");
            require(_spender != address(0), "YieldToken: approve to the zero address");
    
            allowances[_owner][_spender] = _amount;
    
            emit Approval(_owner, _spender, _amount);
        }
    
        function _updateRewards(address _account) private {
            for (uint256 i = 0; i < yieldTrackers.length; i++) {
                address yieldTracker = yieldTrackers[i];
                IYieldTracker(yieldTracker).updateRewards(_account);
            }
        }
    }
    pragma solidity 0.6.12;
    
    contract USDG is YieldToken, IUSDG {
    
        mapping (address => bool) public vaults;
    
        modifier onlyVault() {
            require(vaults[msg.sender], "USDG: forbidden");
            _;
        }
    
        constructor(address _vault) public YieldToken("USD Gambit", "USDG", 0) {
            vaults[_vault] = true;
        }
    
        function addVault(address _vault) external override onlyGov {
            vaults[_vault] = true;
        }
    
        function removeVault(address _vault) external override onlyGov {
            vaults[_vault] = false;
        }
    
        function mint(address _account, uint256 _amount) external override onlyVault {
            _mint(_account, _amount);
        }
    
        function burn(address _account, uint256 _amount) external override onlyVault {
            _burn(_account, _amount);
        }
    }

    Please enter a contract address above to load the contract details and source code.

    Context size (optional):