ETH Price: $3,485.16 (+2.61%)

Contract

0x33db8d52d65F75E4cdDA1b02463760c9561A2aa1
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Claim Governance160522022022-11-26 5:54:35760 days ago1669442075IN
Origin Dollar: OUSD Implementation
0 ETH0.000204798.68286014

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
OUSD

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 8 : OUSD.sol
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;

/**
 * @title OUSD Token Contract
 * @dev ERC20 compatible contract for OUSD
 * @dev Implements an elastic supply
 * @author Origin Protocol Inc
 */
import { SafeMath } from "@openzeppelin/contracts/utils/math/SafeMath.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";

import { Initializable } from "../utils/Initializable.sol";
import { InitializableERC20Detailed } from "../utils/InitializableERC20Detailed.sol";
import { StableMath } from "../utils/StableMath.sol";
import { Governable } from "../governance/Governable.sol";

/**
 * NOTE that this is an ERC20 token but the invariant that the sum of
 * balanceOf(x) for all x is not >= totalSupply(). This is a consequence of the
 * rebasing design. Any integrations with OUSD should be aware.
 */

contract OUSD is Initializable, InitializableERC20Detailed, Governable {
    using SafeMath for uint256;
    using StableMath for uint256;

    event TotalSupplyUpdatedHighres(
        uint256 totalSupply,
        uint256 rebasingCredits,
        uint256 rebasingCreditsPerToken
    );

    enum RebaseOptions {
        NotSet,
        OptOut,
        OptIn
    }

    uint256 private constant MAX_SUPPLY = ~uint128(0); // (2^128) - 1
    uint256 public _totalSupply;
    mapping(address => mapping(address => uint256)) private _allowances;
    address public vaultAddress = address(0);
    mapping(address => uint256) private _creditBalances;
    uint256 private _rebasingCredits;
    uint256 private _rebasingCreditsPerToken;
    // Frozen address/credits are non rebasing (value is held in contracts which
    // do not receive yield unless they explicitly opt in)
    uint256 public nonRebasingSupply;
    mapping(address => uint256) public nonRebasingCreditsPerToken;
    mapping(address => RebaseOptions) public rebaseState;
    mapping(address => uint256) public isUpgraded;

    uint256 private constant RESOLUTION_INCREASE = 1e9;

    function initialize(
        string calldata _nameArg,
        string calldata _symbolArg,
        address _vaultAddress
    ) external onlyGovernor initializer {
        InitializableERC20Detailed._initialize(_nameArg, _symbolArg, 18);
        _rebasingCreditsPerToken = 1e18;
        vaultAddress = _vaultAddress;
    }

    /**
     * @dev Verifies that the caller is the Vault contract
     */
    modifier onlyVault() {
        require(vaultAddress == msg.sender, "Caller is not the Vault");
        _;
    }

    /**
     * @return The total supply of OUSD.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @return Low resolution rebasingCreditsPerToken
     */
    function rebasingCreditsPerToken() public view returns (uint256) {
        return _rebasingCreditsPerToken / RESOLUTION_INCREASE;
    }

    /**
     * @return Low resolution total number of rebasing credits
     */
    function rebasingCredits() public view returns (uint256) {
        return _rebasingCredits / RESOLUTION_INCREASE;
    }

    /**
     * @return High resolution rebasingCreditsPerToken
     */
    function rebasingCreditsPerTokenHighres() public view returns (uint256) {
        return _rebasingCreditsPerToken;
    }

    /**
     * @return High resolution total number of rebasing credits
     */
    function rebasingCreditsHighres() public view returns (uint256) {
        return _rebasingCredits;
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param _account Address to query the balance of.
     * @return A uint256 representing the amount of base units owned by the
     *         specified address.
     */
    function balanceOf(address _account)
        public
        view
        override
        returns (uint256)
    {
        if (_creditBalances[_account] == 0) return 0;
        return
            _creditBalances[_account].divPrecisely(_creditsPerToken(_account));
    }

    /**
     * @dev Gets the credits balance of the specified address.
     * @dev Backwards compatible with old low res credits per token.
     * @param _account The address to query the balance of.
     * @return (uint256, uint256) Credit balance and credits per token of the
     *         address
     */
    function creditsBalanceOf(address _account)
        public
        view
        returns (uint256, uint256)
    {
        uint256 cpt = _creditsPerToken(_account);
        if (cpt == 1e27) {
            // For a period before the resolution upgrade, we created all new
            // contract accounts at high resolution. Since they are not changing
            // as a result of this upgrade, we will return their true values
            return (_creditBalances[_account], cpt);
        } else {
            return (
                _creditBalances[_account] / RESOLUTION_INCREASE,
                cpt / RESOLUTION_INCREASE
            );
        }
    }

    /**
     * @dev Gets the credits balance of the specified address.
     * @param _account The address to query the balance of.
     * @return (uint256, uint256, bool) Credit balance, credits per token of the
     *         address, and isUpgraded
     */
    function creditsBalanceOfHighres(address _account)
        public
        view
        returns (
            uint256,
            uint256,
            bool
        )
    {
        return (
            _creditBalances[_account],
            _creditsPerToken(_account),
            isUpgraded[_account] == 1
        );
    }

    /**
     * @dev Transfer tokens to a specified address.
     * @param _to the address to transfer to.
     * @param _value the amount to be transferred.
     * @return true on success.
     */
    function transfer(address _to, uint256 _value)
        public
        override
        returns (bool)
    {
        require(_to != address(0), "Transfer to zero address");
        require(
            _value <= balanceOf(msg.sender),
            "Transfer greater than balance"
        );

        _executeTransfer(msg.sender, _to, _value);

        emit Transfer(msg.sender, _to, _value);

        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * @param _from The address you want to send tokens from.
     * @param _to The address you want to transfer to.
     * @param _value The amount of tokens to be transferred.
     */
    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) public override returns (bool) {
        require(_to != address(0), "Transfer to zero address");
        require(_value <= balanceOf(_from), "Transfer greater than balance");

        _allowances[_from][msg.sender] = _allowances[_from][msg.sender].sub(
            _value
        );

        _executeTransfer(_from, _to, _value);

        emit Transfer(_from, _to, _value);

        return true;
    }

    /**
     * @dev Update the count of non rebasing credits in response to a transfer
     * @param _from The address you want to send tokens from.
     * @param _to The address you want to transfer to.
     * @param _value Amount of OUSD to transfer
     */
    function _executeTransfer(
        address _from,
        address _to,
        uint256 _value
    ) internal {
        bool isNonRebasingTo = _isNonRebasingAccount(_to);
        bool isNonRebasingFrom = _isNonRebasingAccount(_from);

        // Credits deducted and credited might be different due to the
        // differing creditsPerToken used by each account
        uint256 creditsCredited = _value.mulTruncate(_creditsPerToken(_to));
        uint256 creditsDeducted = _value.mulTruncate(_creditsPerToken(_from));

        _creditBalances[_from] = _creditBalances[_from].sub(
            creditsDeducted,
            "Transfer amount exceeds balance"
        );
        _creditBalances[_to] = _creditBalances[_to].add(creditsCredited);

        if (isNonRebasingTo && !isNonRebasingFrom) {
            // Transfer to non-rebasing account from rebasing account, credits
            // are removed from the non rebasing tally
            nonRebasingSupply = nonRebasingSupply.add(_value);
            // Update rebasingCredits by subtracting the deducted amount
            _rebasingCredits = _rebasingCredits.sub(creditsDeducted);
        } else if (!isNonRebasingTo && isNonRebasingFrom) {
            // Transfer to rebasing account from non-rebasing account
            // Decreasing non-rebasing credits by the amount that was sent
            nonRebasingSupply = nonRebasingSupply.sub(_value);
            // Update rebasingCredits by adding the credited amount
            _rebasingCredits = _rebasingCredits.add(creditsCredited);
        }
    }

    /**
     * @dev Function to check the amount of tokens that _owner has allowed to
     *      `_spender`.
     * @param _owner The address which owns the funds.
     * @param _spender The address which will spend the funds.
     * @return The number of tokens still available for the _spender.
     */
    function allowance(address _owner, address _spender)
        public
        view
        override
        returns (uint256)
    {
        return _allowances[_owner][_spender];
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens
     *      on behalf of msg.sender. This method is included for ERC20
     *      compatibility. `increaseAllowance` and `decreaseAllowance` should be
     *      used instead.
     *
     *      Changing an allowance with this method brings the risk that someone
     *      may transfer both the old and the new allowance - if they are both
     *      greater than zero - if a transfer transaction is mined before the
     *      later approve() call is mined.
     * @param _spender The address which will spend the funds.
     * @param _value The amount of tokens to be spent.
     */
    function approve(address _spender, uint256 _value)
        public
        override
        returns (bool)
    {
        _allowances[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner has allowed to
     *      `_spender`.
     *      This method should be used instead of approve() to avoid the double
     *      approval vulnerability described above.
     * @param _spender The address which will spend the funds.
     * @param _addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address _spender, uint256 _addedValue)
        public
        returns (bool)
    {
        _allowances[msg.sender][_spender] = _allowances[msg.sender][_spender]
            .add(_addedValue);
        emit Approval(msg.sender, _spender, _allowances[msg.sender][_spender]);
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner has allowed to
            `_spender`.
     * @param _spender The address which will spend the funds.
     * @param _subtractedValue The amount of tokens to decrease the allowance
     *        by.
     */
    function decreaseAllowance(address _spender, uint256 _subtractedValue)
        public
        returns (bool)
    {
        uint256 oldValue = _allowances[msg.sender][_spender];
        if (_subtractedValue >= oldValue) {
            _allowances[msg.sender][_spender] = 0;
        } else {
            _allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
        }
        emit Approval(msg.sender, _spender, _allowances[msg.sender][_spender]);
        return true;
    }

    /**
     * @dev Mints new tokens, increasing totalSupply.
     */
    function mint(address _account, uint256 _amount) external onlyVault {
        _mint(_account, _amount);
    }

    /**
     * @dev Creates `_amount` tokens and assigns them to `_account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address _account, uint256 _amount) internal nonReentrant {
        require(_account != address(0), "Mint to the zero address");

        bool isNonRebasingAccount = _isNonRebasingAccount(_account);

        uint256 creditAmount = _amount.mulTruncate(_creditsPerToken(_account));
        _creditBalances[_account] = _creditBalances[_account].add(creditAmount);

        // If the account is non rebasing and doesn't have a set creditsPerToken
        // then set it i.e. this is a mint from a fresh contract
        if (isNonRebasingAccount) {
            nonRebasingSupply = nonRebasingSupply.add(_amount);
        } else {
            _rebasingCredits = _rebasingCredits.add(creditAmount);
        }

        _totalSupply = _totalSupply.add(_amount);

        require(_totalSupply < MAX_SUPPLY, "Max supply");

        emit Transfer(address(0), _account, _amount);
    }

    /**
     * @dev Burns tokens, decreasing totalSupply.
     */
    function burn(address account, uint256 amount) external onlyVault {
        _burn(account, amount);
    }

    /**
     * @dev Destroys `_amount` tokens from `_account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `_account` cannot be the zero address.
     * - `_account` must have at least `_amount` tokens.
     */
    function _burn(address _account, uint256 _amount) internal nonReentrant {
        require(_account != address(0), "Burn from the zero address");
        if (_amount == 0) {
            return;
        }

        bool isNonRebasingAccount = _isNonRebasingAccount(_account);
        uint256 creditAmount = _amount.mulTruncate(_creditsPerToken(_account));
        uint256 currentCredits = _creditBalances[_account];

        // Remove the credits, burning rounding errors
        if (
            currentCredits == creditAmount || currentCredits - 1 == creditAmount
        ) {
            // Handle dust from rounding
            _creditBalances[_account] = 0;
        } else if (currentCredits > creditAmount) {
            _creditBalances[_account] = _creditBalances[_account].sub(
                creditAmount
            );
        } else {
            revert("Remove exceeds balance");
        }

        // Remove from the credit tallies and non-rebasing supply
        if (isNonRebasingAccount) {
            nonRebasingSupply = nonRebasingSupply.sub(_amount);
        } else {
            _rebasingCredits = _rebasingCredits.sub(creditAmount);
        }

        _totalSupply = _totalSupply.sub(_amount);

        emit Transfer(_account, address(0), _amount);
    }

    /**
     * @dev Get the credits per token for an account. Returns a fixed amount
     *      if the account is non-rebasing.
     * @param _account Address of the account.
     */
    function _creditsPerToken(address _account)
        internal
        view
        returns (uint256)
    {
        if (nonRebasingCreditsPerToken[_account] != 0) {
            return nonRebasingCreditsPerToken[_account];
        } else {
            return _rebasingCreditsPerToken;
        }
    }

    /**
     * @dev Is an account using rebasing accounting or non-rebasing accounting?
     *      Also, ensure contracts are non-rebasing if they have not opted in.
     * @param _account Address of the account.
     */
    function _isNonRebasingAccount(address _account) internal returns (bool) {
        bool isContract = Address.isContract(_account);
        if (isContract && rebaseState[_account] == RebaseOptions.NotSet) {
            _ensureRebasingMigration(_account);
        }
        return nonRebasingCreditsPerToken[_account] > 0;
    }

    /**
     * @dev Ensures internal account for rebasing and non-rebasing credits and
     *      supply is updated following deployment of frozen yield change.
     */
    function _ensureRebasingMigration(address _account) internal {
        if (nonRebasingCreditsPerToken[_account] == 0) {
            if (_creditBalances[_account] == 0) {
                // Since there is no existing balance, we can directly set to
                // high resolution, and do not have to do any other bookkeeping
                nonRebasingCreditsPerToken[_account] = 1e27;
            } else {
                // Migrate an existing account:

                // Set fixed credits per token for this account
                nonRebasingCreditsPerToken[_account] = _rebasingCreditsPerToken;
                // Update non rebasing supply
                nonRebasingSupply = nonRebasingSupply.add(balanceOf(_account));
                // Update credit tallies
                _rebasingCredits = _rebasingCredits.sub(
                    _creditBalances[_account]
                );
            }
        }
    }

    /**
     * @dev Add a contract address to the non-rebasing exception list. The
     * address's balance will be part of rebases and the account will be exposed
     * to upside and downside.
     */
    function rebaseOptIn() public nonReentrant {
        require(_isNonRebasingAccount(msg.sender), "Account has not opted out");

        // Convert balance into the same amount at the current exchange rate
        uint256 newCreditBalance = _creditBalances[msg.sender]
            .mul(_rebasingCreditsPerToken)
            .div(_creditsPerToken(msg.sender));

        // Decreasing non rebasing supply
        nonRebasingSupply = nonRebasingSupply.sub(balanceOf(msg.sender));

        _creditBalances[msg.sender] = newCreditBalance;

        // Increase rebasing credits, totalSupply remains unchanged so no
        // adjustment necessary
        _rebasingCredits = _rebasingCredits.add(_creditBalances[msg.sender]);

        rebaseState[msg.sender] = RebaseOptions.OptIn;

        // Delete any fixed credits per token
        delete nonRebasingCreditsPerToken[msg.sender];
    }

    /**
     * @dev Explicitly mark that an address is non-rebasing.
     */
    function rebaseOptOut() public nonReentrant {
        require(!_isNonRebasingAccount(msg.sender), "Account has not opted in");

        // Increase non rebasing supply
        nonRebasingSupply = nonRebasingSupply.add(balanceOf(msg.sender));
        // Set fixed credits per token
        nonRebasingCreditsPerToken[msg.sender] = _rebasingCreditsPerToken;

        // Decrease rebasing credits, total supply remains unchanged so no
        // adjustment necessary
        _rebasingCredits = _rebasingCredits.sub(_creditBalances[msg.sender]);

        // Mark explicitly opted out of rebasing
        rebaseState[msg.sender] = RebaseOptions.OptOut;
    }

    /**
     * @dev Modify the supply without minting new tokens. This uses a change in
     *      the exchange rate between "credits" and OUSD tokens to change balances.
     * @param _newTotalSupply New total supply of OUSD.
     */
    function changeSupply(uint256 _newTotalSupply)
        external
        onlyVault
        nonReentrant
    {
        require(_totalSupply > 0, "Cannot increase 0 supply");

        if (_totalSupply == _newTotalSupply) {
            emit TotalSupplyUpdatedHighres(
                _totalSupply,
                _rebasingCredits,
                _rebasingCreditsPerToken
            );
            return;
        }

        _totalSupply = _newTotalSupply > MAX_SUPPLY
            ? MAX_SUPPLY
            : _newTotalSupply;

        _rebasingCreditsPerToken = _rebasingCredits.divPrecisely(
            _totalSupply.sub(nonRebasingSupply)
        );

        require(_rebasingCreditsPerToken > 0, "Invalid change in supply");

        _totalSupply = _rebasingCredits
            .divPrecisely(_rebasingCreditsPerToken)
            .add(nonRebasingSupply);

        emit TotalSupplyUpdatedHighres(
            _totalSupply,
            _rebasingCredits,
            _rebasingCreditsPerToken
        );
    }
}

File 2 of 8 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

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

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

File 3 of 8 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

        (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");

        (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");

        (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.4._
     */
    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.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

File 4 of 8 : Initializable.sol
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;

abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(
            initializing || !initialized,
            "Initializable: contract is already initialized"
        );

        bool isTopLevelCall = !initializing;
        if (isTopLevelCall) {
            initializing = true;
            initialized = true;
        }

        _;

        if (isTopLevelCall) {
            initializing = false;
        }
    }

    uint256[50] private ______gap;
}

File 5 of 8 : InitializableERC20Detailed.sol
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @dev Optional functions from the ERC20 standard.
 * Converted from openzeppelin/contracts/token/ERC20/ERC20Detailed.sol
 */
abstract contract InitializableERC20Detailed is IERC20 {
    // Storage gap to skip storage from prior to OUSD reset
    uint256[100] private _____gap;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
     * these values are immutable: they can only be set once during
     * construction.
     * @notice To avoid variable shadowing appended `Arg` after arguments name.
     */
    function _initialize(
        string memory nameArg,
        string memory symbolArg,
        uint8 decimalsArg
    ) internal {
        _name = nameArg;
        _symbol = symbolArg;
        _decimals = decimalsArg;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }
}

File 6 of 8 : StableMath.sol
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;

import { SafeMath } from "@openzeppelin/contracts/utils/math/SafeMath.sol";

// Based on StableMath from Stability Labs Pty. Ltd.
// https://github.com/mstable/mStable-contracts/blob/master/contracts/shared/StableMath.sol

library StableMath {
    using SafeMath for uint256;

    /**
     * @dev Scaling unit for use in specific calculations,
     * where 1 * 10**18, or 1e18 represents a unit '1'
     */
    uint256 private constant FULL_SCALE = 1e18;

    /***************************************
                    Helpers
    ****************************************/

    /**
     * @dev Adjust the scale of an integer
     * @param to Decimals to scale to
     * @param from Decimals to scale from
     */
    function scaleBy(
        uint256 x,
        uint256 to,
        uint256 from
    ) internal pure returns (uint256) {
        if (to > from) {
            x = x.mul(10**(to - from));
        } else if (to < from) {
            x = x.div(10**(from - to));
        }
        return x;
    }

    /***************************************
               Precise Arithmetic
    ****************************************/

    /**
     * @dev Multiplies two precise units, and then truncates by the full scale
     * @param x Left hand input to multiplication
     * @param y Right hand input to multiplication
     * @return Result after multiplying the two inputs and then dividing by the shared
     *         scale unit
     */
    function mulTruncate(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulTruncateScale(x, y, FULL_SCALE);
    }

    /**
     * @dev Multiplies two precise units, and then truncates by the given scale. For example,
     * when calculating 90% of 10e18, (10e18 * 9e17) / 1e18 = (9e36) / 1e18 = 9e18
     * @param x Left hand input to multiplication
     * @param y Right hand input to multiplication
     * @param scale Scale unit
     * @return Result after multiplying the two inputs and then dividing by the shared
     *         scale unit
     */
    function mulTruncateScale(
        uint256 x,
        uint256 y,
        uint256 scale
    ) internal pure returns (uint256) {
        // e.g. assume scale = fullScale
        // z = 10e18 * 9e17 = 9e36
        uint256 z = x.mul(y);
        // return 9e36 / 1e18 = 9e18
        return z.div(scale);
    }

    /**
     * @dev Multiplies two precise units, and then truncates by the full scale, rounding up the result
     * @param x Left hand input to multiplication
     * @param y Right hand input to multiplication
     * @return Result after multiplying the two inputs and then dividing by the shared
     *          scale unit, rounded up to the closest base unit.
     */
    function mulTruncateCeil(uint256 x, uint256 y)
        internal
        pure
        returns (uint256)
    {
        // e.g. 8e17 * 17268172638 = 138145381104e17
        uint256 scaled = x.mul(y);
        // e.g. 138145381104e17 + 9.99...e17 = 138145381113.99...e17
        uint256 ceil = scaled.add(FULL_SCALE.sub(1));
        // e.g. 13814538111.399...e18 / 1e18 = 13814538111
        return ceil.div(FULL_SCALE);
    }

    /**
     * @dev Precisely divides two units, by first scaling the left hand operand. Useful
     *      for finding percentage weightings, i.e. 8e18/10e18 = 80% (or 8e17)
     * @param x Left hand input to division
     * @param y Right hand input to division
     * @return Result after multiplying the left operand by the scale, and
     *         executing the division on the right hand input.
     */
    function divPrecisely(uint256 x, uint256 y)
        internal
        pure
        returns (uint256)
    {
        // e.g. 8e18 * 1e18 = 8e36
        uint256 z = x.mul(FULL_SCALE);
        // e.g. 8e36 / 10e18 = 8e17
        return z.div(y);
    }
}

File 7 of 8 : Governable.sol
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;

/**
 * @title OUSD Governable Contract
 * @dev Copy of the openzeppelin Ownable.sol contract with nomenclature change
 *      from owner to governor and renounce methods removed. Does not use
 *      Context.sol like Ownable.sol does for simplification.
 * @author Origin Protocol Inc
 */
contract Governable {
    // Storage position of the owner and pendingOwner of the contract
    // keccak256("OUSD.governor");
    bytes32 private constant governorPosition =
        0x7bea13895fa79d2831e0a9e28edede30099005a50d652d8957cf8a607ee6ca4a;

    // keccak256("OUSD.pending.governor");
    bytes32 private constant pendingGovernorPosition =
        0x44c4d30b2eaad5130ad70c3ba6972730566f3e6359ab83e800d905c61b1c51db;

    // keccak256("OUSD.reentry.status");
    bytes32 private constant reentryStatusPosition =
        0x53bf423e48ed90e97d02ab0ebab13b2a235a6bfbe9c321847d5c175333ac4535;

    // See OpenZeppelin ReentrancyGuard implementation
    uint256 constant _NOT_ENTERED = 1;
    uint256 constant _ENTERED = 2;

    event PendingGovernorshipTransfer(
        address indexed previousGovernor,
        address indexed newGovernor
    );

    event GovernorshipTransferred(
        address indexed previousGovernor,
        address indexed newGovernor
    );

    /**
     * @dev Initializes the contract setting the deployer as the initial Governor.
     */
    constructor() {
        _setGovernor(msg.sender);
        emit GovernorshipTransferred(address(0), _governor());
    }

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

    /**
     * @dev Returns the address of the current Governor.
     */
    function _governor() internal view returns (address governorOut) {
        bytes32 position = governorPosition;
        assembly {
            governorOut := sload(position)
        }
    }

    /**
     * @dev Returns the address of the pending Governor.
     */
    function _pendingGovernor()
        internal
        view
        returns (address pendingGovernor)
    {
        bytes32 position = pendingGovernorPosition;
        assembly {
            pendingGovernor := sload(position)
        }
    }

    /**
     * @dev Throws if called by any account other than the Governor.
     */
    modifier onlyGovernor() {
        require(isGovernor(), "Caller is not the Governor");
        _;
    }

    /**
     * @dev Returns true if the caller is the current Governor.
     */
    function isGovernor() public view returns (bool) {
        return msg.sender == _governor();
    }

    function _setGovernor(address newGovernor) internal {
        bytes32 position = governorPosition;
        assembly {
            sstore(position, newGovernor)
        }
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        bytes32 position = reentryStatusPosition;
        uint256 _reentry_status;
        assembly {
            _reentry_status := sload(position)
        }

        // On the first call to nonReentrant, _notEntered will be true
        require(_reentry_status != _ENTERED, "Reentrant call");

        // Any calls to nonReentrant after this point will fail
        assembly {
            sstore(position, _ENTERED)
        }

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        assembly {
            sstore(position, _NOT_ENTERED)
        }
    }

    function _setPendingGovernor(address newGovernor) internal {
        bytes32 position = pendingGovernorPosition;
        assembly {
            sstore(position, newGovernor)
        }
    }

    /**
     * @dev Transfers Governance of the contract to a new account (`newGovernor`).
     * Can only be called by the current Governor. Must be claimed for this to complete
     * @param _newGovernor Address of the new Governor
     */
    function transferGovernance(address _newGovernor) external onlyGovernor {
        _setPendingGovernor(_newGovernor);
        emit PendingGovernorshipTransfer(_governor(), _newGovernor);
    }

    /**
     * @dev Claim Governance of the contract to a new account (`newGovernor`).
     * Can only be called by the new Governor.
     */
    function claimGovernance() external {
        require(
            msg.sender == _pendingGovernor(),
            "Only the pending Governor can complete the claim"
        );
        _changeGovernor(msg.sender);
    }

    /**
     * @dev Change Governance of the contract to a new account (`newGovernor`).
     * @param _newGovernor Address of the new Governor
     */
    function _changeGovernor(address _newGovernor) internal {
        require(_newGovernor != address(0), "New Governor is address(0)");
        emit GovernorshipTransferred(_governor(), _newGovernor);
        _setGovernor(_newGovernor);
    }
}

File 8 of 8 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.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);
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousGovernor","type":"address"},{"indexed":true,"internalType":"address","name":"newGovernor","type":"address"}],"name":"GovernorshipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousGovernor","type":"address"},{"indexed":true,"internalType":"address","name":"newGovernor","type":"address"}],"name":"PendingGovernorshipTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rebasingCredits","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rebasingCreditsPerToken","type":"uint256"}],"name":"TotalSupplyUpdatedHighres","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTotalSupply","type":"uint256"}],"name":"changeSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"creditsBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"creditsBalanceOfHighres","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"governor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_nameArg","type":"string"},{"internalType":"string","name":"_symbolArg","type":"string"},{"internalType":"address","name":"_vaultAddress","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isGovernor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isUpgraded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonRebasingCreditsPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonRebasingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebaseOptIn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rebaseOptOut","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rebaseState","outputs":[{"internalType":"enum OUSD.RebaseOptions","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebasingCredits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebasingCreditsHighres","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebasingCreditsPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebasingCreditsPerTokenHighres","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newGovernor","type":"address"}],"name":"transferGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vaultAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

6080604052609c80546001600160a01b031916905534801561002057600080fd5b506100373360008051602061201b83398151915255565b60008051602061201b833981519152546040516001600160a01b03909116906000907fc7c0c772add429241571afb3805861fb3cfa2af374534088b76cdb4325a87e9a908290a3611f8e8061008d6000396000f3fe608060405234801561001057600080fd5b50600436106101fb5760003560e01c80636691cb3d1161011a578063a9059cbb116100ad578063dd62ed3e1161007c578063dd62ed3e14610418578063e5c4fffe14610451578063e696393a14610481578063f51b0fd41461048a578063f9854bfc1461049257600080fd5b8063a9059cbb146103e2578063c2376dff146103f5578063c7af3352146103fd578063d38bfff41461040557600080fd5b806395d89b41116100e957806395d89b411461039457806395ef84b91461039c5780639dc29fac146103bc578063a457c2d7146103cf57600080fd5b80636691cb3d1461036957806370a08231146103715780637a46a9c5146103845780637d0d66ff1461038c57600080fd5b80633950935111610192578063430bf08a11610161578063430bf08a146102fe578063456ee286146103115780635d36b19014610341578063609350cd1461034957600080fd5b806339509351146102bc57806339a7919f146102cf5780633eaaf86b146102e257806340c10f19146102eb57600080fd5b80630c340a24116101ce5780630c340a241461026c57806318160ddd1461028c57806323b872dd14610294578063313ce567146102a757600080fd5b806306fdde0314610200578063077f224a1461021e578063077f22b714610233578063095ea7b314610249575b600080fd5b6102086104ba565b6040516102159190611d6d565b60405180910390f35b61023161022c366004611cab565b61054c565b005b61023b6106fa565b604051908152602001610215565b61025c610257366004611c81565b610713565b6040519015158152602001610215565b61027461077f565b6040516001600160a01b039091168152602001610215565b609a5461023b565b61025c6102a2366004611c45565b610797565b60995460405160ff9091168152602001610215565b61025c6102ca366004611c81565b6108e4565b6102316102dd366004611d2c565b610969565b61023b609a5481565b6102316102f9366004611c81565b610b72565b609c54610274906001600160a01b031681565b61033461031f366004611bf7565b60a26020526000908152604090205460ff1681565b6040516102159190611d45565b610231610baa565b61023b610357366004611bf7565b60a16020526000908152604090205481565b61023b610c50565b61023b61037f366004611bf7565b610c64565b609f5461023b565b609e5461023b565b610208610cba565b61023b6103aa366004611bf7565b60a36020526000908152604090205481565b6102316103ca366004611c81565b610cc9565b61025c6103dd366004611c81565b610cfd565b61025c6103f0366004611c81565b610de4565b610231610ec5565b61025c610fb9565b610231610413366004611bf7565b610fea565b61023b610426366004611c12565b6001600160a01b039182166000908152609b6020908152604080832093909416825291909152205490565b61046461045f366004611bf7565b6110be565b604080519384526020840192909252151590820152606001610215565b61023b60a05481565b61023161110d565b6104a56104a0366004611bf7565b611231565b60408051928352602083019190915201610215565b6060609780546104c990611e91565b80601f01602080910402602001604051908101604052809291908181526020018280546104f590611e91565b80156105425780601f1061051757610100808354040283529160200191610542565b820191906000526020600020905b81548152906001019060200180831161052557829003601f168201915b5050505050905090565b610554610fb9565b6105a55760405162461bcd60e51b815260206004820152601a60248201527f43616c6c6572206973206e6f742074686520476f7665726e6f7200000000000060448201526064015b60405180910390fd5b600054610100900460ff16806105be575060005460ff16155b6106215760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840161059c565b600054610100900460ff16158015610643576000805461ffff19166101011790555b6106b986868080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050604080516020601f8a018190048102820181019092528881529250889150879081908401838280828437600092019190915250601292506112b5915050565b670de0b6b3a7640000609f55609c80546001600160a01b0319166001600160a01b03841617905580156106f2576000805461ff00191690555b505050505050565b6000633b9aca00609e5461070e9190611e39565b905090565b336000818152609b602090815260408083206001600160a01b038716808552925280832085905551919290917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259061076e9086815260200190565b60405180910390a350600192915050565b600061070e600080516020611f398339815191525490565b60006001600160a01b0383166107ea5760405162461bcd60e51b81526020600482015260186024820152775472616e7366657220746f207a65726f206164647265737360401b604482015260640161059c565b6107f384610c64565b8211156108425760405162461bcd60e51b815260206004820152601d60248201527f5472616e736665722067726561746572207468616e2062616c616e6365000000604482015260640161059c565b6001600160a01b0384166000908152609b6020908152604080832033845290915290205461087090836112f5565b6001600160a01b0385166000908152609b6020908152604080832033845290915290205561089f848484611308565b826001600160a01b0316846001600160a01b0316600080516020611f19833981519152846040516108d291815260200190565b60405180910390a35060019392505050565b336000908152609b602090815260408083206001600160a01b03861684529091528120546109129083611476565b336000818152609b602090815260408083206001600160a01b038916808552908352928190208590555193845290927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910161076e565b609c546001600160a01b031633146109935760405162461bcd60e51b815260040161059c90611dc2565b600080516020611ef9833981519152805460028114156109c55760405162461bcd60e51b815260040161059c90611df9565b600282556000609a5411610a1b5760405162461bcd60e51b815260206004820152601860248201527f43616e6e6f7420696e637265617365203020737570706c790000000000000000604482015260640161059c565b82609a541415610a7157609a54609e54609f5460408051938452602084019290925282820152517f41645eb819d3011b13f97696a8109d14bfcddfaca7d063ec0564d62a3e2572359181900360600190a1610b6a565b6001600160801b038311610a855782610a8e565b6001600160801b035b609a81905560a054610aac91610aa3916112f5565b609e5490611482565b609f819055610afd5760405162461bcd60e51b815260206004820152601860248201527f496e76616c6964206368616e676520696e20737570706c790000000000000000604482015260640161059c565b610b2060a054610b1a609f54609e5461148290919063ffffffff16565b90611476565b609a819055609e54609f5460408051938452602084019290925282820152517f41645eb819d3011b13f97696a8109d14bfcddfaca7d063ec0564d62a3e2572359181900360600190a15b506001905550565b609c546001600160a01b03163314610b9c5760405162461bcd60e51b815260040161059c90611dc2565b610ba682826114ab565b5050565b7f44c4d30b2eaad5130ad70c3ba6972730566f3e6359ab83e800d905c61b1c51db546001600160a01b0316336001600160a01b031614610c455760405162461bcd60e51b815260206004820152603060248201527f4f6e6c79207468652070656e64696e6720476f7665726e6f722063616e20636f60448201526f6d706c6574652074686520636c61696d60801b606482015260840161059c565b610c4e3361164c565b565b6000633b9aca00609f5461070e9190611e39565b6001600160a01b0381166000908152609d6020526040812054610c8957506000919050565b610cb4610c9583611710565b6001600160a01b0384166000908152609d602052604090205490611482565b92915050565b6060609880546104c990611e91565b609c546001600160a01b03163314610cf35760405162461bcd60e51b815260040161059c90611dc2565b610ba68282611757565b336000908152609b602090815260408083206001600160a01b0386168452909152812054808310610d5157336000908152609b602090815260408083206001600160a01b0388168452909152812055610d80565b610d5b81846112f5565b336000908152609b602090815260408083206001600160a01b03891684529091529020555b336000818152609b602090815260408083206001600160a01b038916808552908352928190205490519081529192917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a35060019392505050565b60006001600160a01b038316610e375760405162461bcd60e51b81526020600482015260186024820152775472616e7366657220746f207a65726f206164647265737360401b604482015260640161059c565b610e4033610c64565b821115610e8f5760405162461bcd60e51b815260206004820152601d60248201527f5472616e736665722067726561746572207468616e2062616c616e6365000000604482015260640161059c565b610e9a338484611308565b6040518281526001600160a01b038416903390600080516020611f198339815191529060200161076e565b600080516020611ef983398151915280546002811415610ef75760405162461bcd60e51b815260040161059c90611df9565b60028255610f0433611960565b15610f515760405162461bcd60e51b815260206004820152601860248201527f4163636f756e7420686173206e6f74206f7074656420696e0000000000000000604482015260640161059c565b610f66610f5d33610c64565b60a05490611476565b60a055609f5433600090815260a16020908152604080832093909355609d90522054609e54610f94916112f5565b609e555033600090815260a260205260409020805460ff191660019081179091559055565b6000610fd1600080516020611f398339815191525490565b6001600160a01b0316336001600160a01b031614905090565b610ff2610fb9565b61103e5760405162461bcd60e51b815260206004820152601a60248201527f43616c6c6572206973206e6f742074686520476f7665726e6f72000000000000604482015260640161059c565b611066817f44c4d30b2eaad5130ad70c3ba6972730566f3e6359ab83e800d905c61b1c51db55565b806001600160a01b0316611086600080516020611f398339815191525490565b6001600160a01b03167fa39cc5eb22d0f34d8beaefee8a3f17cc229c1a1d1ef87a5ad47313487b1c4f0d60405160405180910390a350565b6001600160a01b0381166000908152609d6020526040812054819081906110e485611710565b6001600160a01b0395909516600090815260a36020526040902054909560019091149350915050565b600080516020611ef98339815191528054600281141561113f5760405162461bcd60e51b815260040161059c90611df9565b6002825561114c33611960565b6111985760405162461bcd60e51b815260206004820152601960248201527f4163636f756e7420686173206e6f74206f70746564206f757400000000000000604482015260640161059c565b60006111c86111a633611710565b609f54336000908152609d60205260409020546111c2916119cb565b906119d7565b90506111df6111d633610c64565b60a054906112f5565b60a055336000908152609d60205260409020819055609e546112019082611476565b609e55505033600090815260a260209081526040808320805460ff1916600217905560a190915281205560019055565b600080600061123f84611710565b9050806b033b2e3c9fd0803ce80000001415611275576001600160a01b039093166000908152609d602052604090205493915050565b6001600160a01b0384166000908152609d602052604090205461129d90633b9aca0090611e39565b6112ab633b9aca0083611e39565b9250925050915091565b82516112c8906097906020860190611afe565b5081516112dc906098906020850190611afe565b506099805460ff191660ff929092169190911790555050565b60006113018284611e7a565b9392505050565b600061131383611960565b9050600061132085611960565b9050600061133761133086611710565b85906119e3565b9050600061134e61134788611710565b86906119e3565b90506113bf816040518060400160405280601f81526020017f5472616e7366657220616d6f756e7420657863656564732062616c616e636500815250609d60008b6001600160a01b03166001600160a01b03168152602001908152602001600020546119f89092919063ffffffff16565b6001600160a01b038089166000908152609d602052604080822093909355908816815220546113ee9083611476565b6001600160a01b0387166000908152609d6020526040902055838015611412575082155b1561143c5760a0546114249086611476565b60a055609e5461143490826112f5565b609e5561146d565b831580156114475750825b1561146d5760a05461145990866112f5565b60a055609e546114699083611476565b609e555b50505050505050565b60006113018284611e21565b60008061149784670de0b6b3a76400006119cb565b90506114a381846119d7565b949350505050565b600080516020611ef9833981519152805460028114156114dd5760405162461bcd60e51b815260040161059c90611df9565b600282556001600160a01b0384166115375760405162461bcd60e51b815260206004820152601860248201527f4d696e7420746f20746865207a65726f20616464726573730000000000000000604482015260640161059c565b600061154285611960565b9050600061155261134787611710565b6001600160a01b0387166000908152609d60205260409020549091506115789082611476565b6001600160a01b0387166000908152609d602052604090205581156115ac5760a0546115a49086611476565b60a0556115bd565b609e546115b99082611476565b609e555b609a546115ca9086611476565b609a8190556001600160801b03116116115760405162461bcd60e51b815260206004820152600a6024820152694d617820737570706c7960b01b604482015260640161059c565b6040518581526001600160a01b03871690600090600080516020611f198339815191529060200160405180910390a350506001825550505050565b6001600160a01b0381166116a25760405162461bcd60e51b815260206004820152601a60248201527f4e657720476f7665726e6f722069732061646472657373283029000000000000604482015260640161059c565b806001600160a01b03166116c2600080516020611f398339815191525490565b6001600160a01b03167fc7c0c772add429241571afb3805861fb3cfa2af374534088b76cdb4325a87e9a60405160405180910390a361170d81600080516020611f3983398151915255565b50565b6001600160a01b038116600090815260a160205260408120541561174a57506001600160a01b0316600090815260a1602052604090205490565b5050609f5490565b919050565b600080516020611ef9833981519152805460028114156117895760405162461bcd60e51b815260040161059c90611df9565b600282556001600160a01b0384166117e35760405162461bcd60e51b815260206004820152601a60248201527f4275726e2066726f6d20746865207a65726f2061646472657373000000000000604482015260640161059c565b826117ed57611957565b60006117f885611960565b9050600061180861134787611710565b6001600160a01b0387166000908152609d60205260409020549091508082148061183b575081611839600183611e7a565b145b1561185e576001600160a01b0387166000908152609d60205260408120556118e8565b818111156118a7576001600160a01b0387166000908152609d602052604090205461188990836112f5565b6001600160a01b0388166000908152609d60205260409020556118e8565b60405162461bcd60e51b815260206004820152601660248201527552656d6f766520657863656564732062616c616e636560501b604482015260640161059c565b82156119035760a0546118fb90876112f5565b60a055611914565b609e5461191090836112f5565b609e555b609a5461192190876112f5565b609a556040518681526000906001600160a01b03891690600080516020611f198339815191529060200160405180910390a35050505b50600190555050565b6000813b15801590819061199e57506001600160a01b038316600090815260a2602052604081205460ff16600281111561199c5761199c611ee2565b145b156119ac576119ac83611a24565b50506001600160a01b0316600090815260a16020526040902054151590565b60006113018284611e5b565b60006113018284611e39565b60006113018383670de0b6b3a7640000611adc565b60008184841115611a1c5760405162461bcd60e51b815260040161059c9190611d6d565b505050900390565b6001600160a01b038116600090815260a1602052604090205461170d576001600160a01b0381166000908152609d6020526040902054611a86576001600160a01b0316600090815260a1602052604090206b033b2e3c9fd0803ce80000009055565b609f546001600160a01b038216600090815260a16020526040902055611aae610f5d82610c64565b60a0556001600160a01b0381166000908152609d6020526040902054609e54611ad6916112f5565b609e5550565b600080611ae985856119cb565b9050611af581846119d7565b95945050505050565b828054611b0a90611e91565b90600052602060002090601f016020900481019282611b2c5760008555611b72565b82601f10611b4557805160ff1916838001178555611b72565b82800160010185558215611b72579182015b82811115611b72578251825591602001919060010190611b57565b50611b7e929150611b82565b5090565b5b80821115611b7e5760008155600101611b83565b80356001600160a01b038116811461175257600080fd5b60008083601f840112611bc057600080fd5b50813567ffffffffffffffff811115611bd857600080fd5b602083019150836020828501011115611bf057600080fd5b9250929050565b600060208284031215611c0957600080fd5b61130182611b97565b60008060408385031215611c2557600080fd5b611c2e83611b97565b9150611c3c60208401611b97565b90509250929050565b600080600060608486031215611c5a57600080fd5b611c6384611b97565b9250611c7160208501611b97565b9150604084013590509250925092565b60008060408385031215611c9457600080fd5b611c9d83611b97565b946020939093013593505050565b600080600080600060608688031215611cc357600080fd5b853567ffffffffffffffff80821115611cdb57600080fd5b611ce789838a01611bae565b90975095506020880135915080821115611d0057600080fd5b50611d0d88828901611bae565b9094509250611d20905060408701611b97565b90509295509295909350565b600060208284031215611d3e57600080fd5b5035919050565b6020810160038310611d6757634e487b7160e01b600052602160045260246000fd5b91905290565b600060208083528351808285015260005b81811015611d9a57858101830151858201604001528201611d7e565b81811115611dac576000604083870101525b50601f01601f1916929092016040019392505050565b60208082526017908201527f43616c6c6572206973206e6f7420746865205661756c74000000000000000000604082015260600190565b6020808252600e908201526d1499595b9d1c985b9d0818d85b1b60921b604082015260600190565b60008219821115611e3457611e34611ecc565b500190565b600082611e5657634e487b7160e01b600052601260045260246000fd5b500490565b6000816000190483118215151615611e7557611e75611ecc565b500290565b600082821015611e8c57611e8c611ecc565b500390565b600181811c90821680611ea557607f821691505b60208210811415611ec657634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052602160045260246000fdfe53bf423e48ed90e97d02ab0ebab13b2a235a6bfbe9c321847d5c175333ac4535ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef7bea13895fa79d2831e0a9e28edede30099005a50d652d8957cf8a607ee6ca4aa26469706673582212201b8ec42930889e5de1fe27c8e9555b99a6d3a74f39b4ad730ffae97e3dc9bd4464736f6c634300080700337bea13895fa79d2831e0a9e28edede30099005a50d652d8957cf8a607ee6ca4a

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106101fb5760003560e01c80636691cb3d1161011a578063a9059cbb116100ad578063dd62ed3e1161007c578063dd62ed3e14610418578063e5c4fffe14610451578063e696393a14610481578063f51b0fd41461048a578063f9854bfc1461049257600080fd5b8063a9059cbb146103e2578063c2376dff146103f5578063c7af3352146103fd578063d38bfff41461040557600080fd5b806395d89b41116100e957806395d89b411461039457806395ef84b91461039c5780639dc29fac146103bc578063a457c2d7146103cf57600080fd5b80636691cb3d1461036957806370a08231146103715780637a46a9c5146103845780637d0d66ff1461038c57600080fd5b80633950935111610192578063430bf08a11610161578063430bf08a146102fe578063456ee286146103115780635d36b19014610341578063609350cd1461034957600080fd5b806339509351146102bc57806339a7919f146102cf5780633eaaf86b146102e257806340c10f19146102eb57600080fd5b80630c340a24116101ce5780630c340a241461026c57806318160ddd1461028c57806323b872dd14610294578063313ce567146102a757600080fd5b806306fdde0314610200578063077f224a1461021e578063077f22b714610233578063095ea7b314610249575b600080fd5b6102086104ba565b6040516102159190611d6d565b60405180910390f35b61023161022c366004611cab565b61054c565b005b61023b6106fa565b604051908152602001610215565b61025c610257366004611c81565b610713565b6040519015158152602001610215565b61027461077f565b6040516001600160a01b039091168152602001610215565b609a5461023b565b61025c6102a2366004611c45565b610797565b60995460405160ff9091168152602001610215565b61025c6102ca366004611c81565b6108e4565b6102316102dd366004611d2c565b610969565b61023b609a5481565b6102316102f9366004611c81565b610b72565b609c54610274906001600160a01b031681565b61033461031f366004611bf7565b60a26020526000908152604090205460ff1681565b6040516102159190611d45565b610231610baa565b61023b610357366004611bf7565b60a16020526000908152604090205481565b61023b610c50565b61023b61037f366004611bf7565b610c64565b609f5461023b565b609e5461023b565b610208610cba565b61023b6103aa366004611bf7565b60a36020526000908152604090205481565b6102316103ca366004611c81565b610cc9565b61025c6103dd366004611c81565b610cfd565b61025c6103f0366004611c81565b610de4565b610231610ec5565b61025c610fb9565b610231610413366004611bf7565b610fea565b61023b610426366004611c12565b6001600160a01b039182166000908152609b6020908152604080832093909416825291909152205490565b61046461045f366004611bf7565b6110be565b604080519384526020840192909252151590820152606001610215565b61023b60a05481565b61023161110d565b6104a56104a0366004611bf7565b611231565b60408051928352602083019190915201610215565b6060609780546104c990611e91565b80601f01602080910402602001604051908101604052809291908181526020018280546104f590611e91565b80156105425780601f1061051757610100808354040283529160200191610542565b820191906000526020600020905b81548152906001019060200180831161052557829003601f168201915b5050505050905090565b610554610fb9565b6105a55760405162461bcd60e51b815260206004820152601a60248201527f43616c6c6572206973206e6f742074686520476f7665726e6f7200000000000060448201526064015b60405180910390fd5b600054610100900460ff16806105be575060005460ff16155b6106215760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840161059c565b600054610100900460ff16158015610643576000805461ffff19166101011790555b6106b986868080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050604080516020601f8a018190048102820181019092528881529250889150879081908401838280828437600092019190915250601292506112b5915050565b670de0b6b3a7640000609f55609c80546001600160a01b0319166001600160a01b03841617905580156106f2576000805461ff00191690555b505050505050565b6000633b9aca00609e5461070e9190611e39565b905090565b336000818152609b602090815260408083206001600160a01b038716808552925280832085905551919290917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259061076e9086815260200190565b60405180910390a350600192915050565b600061070e600080516020611f398339815191525490565b60006001600160a01b0383166107ea5760405162461bcd60e51b81526020600482015260186024820152775472616e7366657220746f207a65726f206164647265737360401b604482015260640161059c565b6107f384610c64565b8211156108425760405162461bcd60e51b815260206004820152601d60248201527f5472616e736665722067726561746572207468616e2062616c616e6365000000604482015260640161059c565b6001600160a01b0384166000908152609b6020908152604080832033845290915290205461087090836112f5565b6001600160a01b0385166000908152609b6020908152604080832033845290915290205561089f848484611308565b826001600160a01b0316846001600160a01b0316600080516020611f19833981519152846040516108d291815260200190565b60405180910390a35060019392505050565b336000908152609b602090815260408083206001600160a01b03861684529091528120546109129083611476565b336000818152609b602090815260408083206001600160a01b038916808552908352928190208590555193845290927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910161076e565b609c546001600160a01b031633146109935760405162461bcd60e51b815260040161059c90611dc2565b600080516020611ef9833981519152805460028114156109c55760405162461bcd60e51b815260040161059c90611df9565b600282556000609a5411610a1b5760405162461bcd60e51b815260206004820152601860248201527f43616e6e6f7420696e637265617365203020737570706c790000000000000000604482015260640161059c565b82609a541415610a7157609a54609e54609f5460408051938452602084019290925282820152517f41645eb819d3011b13f97696a8109d14bfcddfaca7d063ec0564d62a3e2572359181900360600190a1610b6a565b6001600160801b038311610a855782610a8e565b6001600160801b035b609a81905560a054610aac91610aa3916112f5565b609e5490611482565b609f819055610afd5760405162461bcd60e51b815260206004820152601860248201527f496e76616c6964206368616e676520696e20737570706c790000000000000000604482015260640161059c565b610b2060a054610b1a609f54609e5461148290919063ffffffff16565b90611476565b609a819055609e54609f5460408051938452602084019290925282820152517f41645eb819d3011b13f97696a8109d14bfcddfaca7d063ec0564d62a3e2572359181900360600190a15b506001905550565b609c546001600160a01b03163314610b9c5760405162461bcd60e51b815260040161059c90611dc2565b610ba682826114ab565b5050565b7f44c4d30b2eaad5130ad70c3ba6972730566f3e6359ab83e800d905c61b1c51db546001600160a01b0316336001600160a01b031614610c455760405162461bcd60e51b815260206004820152603060248201527f4f6e6c79207468652070656e64696e6720476f7665726e6f722063616e20636f60448201526f6d706c6574652074686520636c61696d60801b606482015260840161059c565b610c4e3361164c565b565b6000633b9aca00609f5461070e9190611e39565b6001600160a01b0381166000908152609d6020526040812054610c8957506000919050565b610cb4610c9583611710565b6001600160a01b0384166000908152609d602052604090205490611482565b92915050565b6060609880546104c990611e91565b609c546001600160a01b03163314610cf35760405162461bcd60e51b815260040161059c90611dc2565b610ba68282611757565b336000908152609b602090815260408083206001600160a01b0386168452909152812054808310610d5157336000908152609b602090815260408083206001600160a01b0388168452909152812055610d80565b610d5b81846112f5565b336000908152609b602090815260408083206001600160a01b03891684529091529020555b336000818152609b602090815260408083206001600160a01b038916808552908352928190205490519081529192917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a35060019392505050565b60006001600160a01b038316610e375760405162461bcd60e51b81526020600482015260186024820152775472616e7366657220746f207a65726f206164647265737360401b604482015260640161059c565b610e4033610c64565b821115610e8f5760405162461bcd60e51b815260206004820152601d60248201527f5472616e736665722067726561746572207468616e2062616c616e6365000000604482015260640161059c565b610e9a338484611308565b6040518281526001600160a01b038416903390600080516020611f198339815191529060200161076e565b600080516020611ef983398151915280546002811415610ef75760405162461bcd60e51b815260040161059c90611df9565b60028255610f0433611960565b15610f515760405162461bcd60e51b815260206004820152601860248201527f4163636f756e7420686173206e6f74206f7074656420696e0000000000000000604482015260640161059c565b610f66610f5d33610c64565b60a05490611476565b60a055609f5433600090815260a16020908152604080832093909355609d90522054609e54610f94916112f5565b609e555033600090815260a260205260409020805460ff191660019081179091559055565b6000610fd1600080516020611f398339815191525490565b6001600160a01b0316336001600160a01b031614905090565b610ff2610fb9565b61103e5760405162461bcd60e51b815260206004820152601a60248201527f43616c6c6572206973206e6f742074686520476f7665726e6f72000000000000604482015260640161059c565b611066817f44c4d30b2eaad5130ad70c3ba6972730566f3e6359ab83e800d905c61b1c51db55565b806001600160a01b0316611086600080516020611f398339815191525490565b6001600160a01b03167fa39cc5eb22d0f34d8beaefee8a3f17cc229c1a1d1ef87a5ad47313487b1c4f0d60405160405180910390a350565b6001600160a01b0381166000908152609d6020526040812054819081906110e485611710565b6001600160a01b0395909516600090815260a36020526040902054909560019091149350915050565b600080516020611ef98339815191528054600281141561113f5760405162461bcd60e51b815260040161059c90611df9565b6002825561114c33611960565b6111985760405162461bcd60e51b815260206004820152601960248201527f4163636f756e7420686173206e6f74206f70746564206f757400000000000000604482015260640161059c565b60006111c86111a633611710565b609f54336000908152609d60205260409020546111c2916119cb565b906119d7565b90506111df6111d633610c64565b60a054906112f5565b60a055336000908152609d60205260409020819055609e546112019082611476565b609e55505033600090815260a260209081526040808320805460ff1916600217905560a190915281205560019055565b600080600061123f84611710565b9050806b033b2e3c9fd0803ce80000001415611275576001600160a01b039093166000908152609d602052604090205493915050565b6001600160a01b0384166000908152609d602052604090205461129d90633b9aca0090611e39565b6112ab633b9aca0083611e39565b9250925050915091565b82516112c8906097906020860190611afe565b5081516112dc906098906020850190611afe565b506099805460ff191660ff929092169190911790555050565b60006113018284611e7a565b9392505050565b600061131383611960565b9050600061132085611960565b9050600061133761133086611710565b85906119e3565b9050600061134e61134788611710565b86906119e3565b90506113bf816040518060400160405280601f81526020017f5472616e7366657220616d6f756e7420657863656564732062616c616e636500815250609d60008b6001600160a01b03166001600160a01b03168152602001908152602001600020546119f89092919063ffffffff16565b6001600160a01b038089166000908152609d602052604080822093909355908816815220546113ee9083611476565b6001600160a01b0387166000908152609d6020526040902055838015611412575082155b1561143c5760a0546114249086611476565b60a055609e5461143490826112f5565b609e5561146d565b831580156114475750825b1561146d5760a05461145990866112f5565b60a055609e546114699083611476565b609e555b50505050505050565b60006113018284611e21565b60008061149784670de0b6b3a76400006119cb565b90506114a381846119d7565b949350505050565b600080516020611ef9833981519152805460028114156114dd5760405162461bcd60e51b815260040161059c90611df9565b600282556001600160a01b0384166115375760405162461bcd60e51b815260206004820152601860248201527f4d696e7420746f20746865207a65726f20616464726573730000000000000000604482015260640161059c565b600061154285611960565b9050600061155261134787611710565b6001600160a01b0387166000908152609d60205260409020549091506115789082611476565b6001600160a01b0387166000908152609d602052604090205581156115ac5760a0546115a49086611476565b60a0556115bd565b609e546115b99082611476565b609e555b609a546115ca9086611476565b609a8190556001600160801b03116116115760405162461bcd60e51b815260206004820152600a6024820152694d617820737570706c7960b01b604482015260640161059c565b6040518581526001600160a01b03871690600090600080516020611f198339815191529060200160405180910390a350506001825550505050565b6001600160a01b0381166116a25760405162461bcd60e51b815260206004820152601a60248201527f4e657720476f7665726e6f722069732061646472657373283029000000000000604482015260640161059c565b806001600160a01b03166116c2600080516020611f398339815191525490565b6001600160a01b03167fc7c0c772add429241571afb3805861fb3cfa2af374534088b76cdb4325a87e9a60405160405180910390a361170d81600080516020611f3983398151915255565b50565b6001600160a01b038116600090815260a160205260408120541561174a57506001600160a01b0316600090815260a1602052604090205490565b5050609f5490565b919050565b600080516020611ef9833981519152805460028114156117895760405162461bcd60e51b815260040161059c90611df9565b600282556001600160a01b0384166117e35760405162461bcd60e51b815260206004820152601a60248201527f4275726e2066726f6d20746865207a65726f2061646472657373000000000000604482015260640161059c565b826117ed57611957565b60006117f885611960565b9050600061180861134787611710565b6001600160a01b0387166000908152609d60205260409020549091508082148061183b575081611839600183611e7a565b145b1561185e576001600160a01b0387166000908152609d60205260408120556118e8565b818111156118a7576001600160a01b0387166000908152609d602052604090205461188990836112f5565b6001600160a01b0388166000908152609d60205260409020556118e8565b60405162461bcd60e51b815260206004820152601660248201527552656d6f766520657863656564732062616c616e636560501b604482015260640161059c565b82156119035760a0546118fb90876112f5565b60a055611914565b609e5461191090836112f5565b609e555b609a5461192190876112f5565b609a556040518681526000906001600160a01b03891690600080516020611f198339815191529060200160405180910390a35050505b50600190555050565b6000813b15801590819061199e57506001600160a01b038316600090815260a2602052604081205460ff16600281111561199c5761199c611ee2565b145b156119ac576119ac83611a24565b50506001600160a01b0316600090815260a16020526040902054151590565b60006113018284611e5b565b60006113018284611e39565b60006113018383670de0b6b3a7640000611adc565b60008184841115611a1c5760405162461bcd60e51b815260040161059c9190611d6d565b505050900390565b6001600160a01b038116600090815260a1602052604090205461170d576001600160a01b0381166000908152609d6020526040902054611a86576001600160a01b0316600090815260a1602052604090206b033b2e3c9fd0803ce80000009055565b609f546001600160a01b038216600090815260a16020526040902055611aae610f5d82610c64565b60a0556001600160a01b0381166000908152609d6020526040902054609e54611ad6916112f5565b609e5550565b600080611ae985856119cb565b9050611af581846119d7565b95945050505050565b828054611b0a90611e91565b90600052602060002090601f016020900481019282611b2c5760008555611b72565b82601f10611b4557805160ff1916838001178555611b72565b82800160010185558215611b72579182015b82811115611b72578251825591602001919060010190611b57565b50611b7e929150611b82565b5090565b5b80821115611b7e5760008155600101611b83565b80356001600160a01b038116811461175257600080fd5b60008083601f840112611bc057600080fd5b50813567ffffffffffffffff811115611bd857600080fd5b602083019150836020828501011115611bf057600080fd5b9250929050565b600060208284031215611c0957600080fd5b61130182611b97565b60008060408385031215611c2557600080fd5b611c2e83611b97565b9150611c3c60208401611b97565b90509250929050565b600080600060608486031215611c5a57600080fd5b611c6384611b97565b9250611c7160208501611b97565b9150604084013590509250925092565b60008060408385031215611c9457600080fd5b611c9d83611b97565b946020939093013593505050565b600080600080600060608688031215611cc357600080fd5b853567ffffffffffffffff80821115611cdb57600080fd5b611ce789838a01611bae565b90975095506020880135915080821115611d0057600080fd5b50611d0d88828901611bae565b9094509250611d20905060408701611b97565b90509295509295909350565b600060208284031215611d3e57600080fd5b5035919050565b6020810160038310611d6757634e487b7160e01b600052602160045260246000fd5b91905290565b600060208083528351808285015260005b81811015611d9a57858101830151858201604001528201611d7e565b81811115611dac576000604083870101525b50601f01601f1916929092016040019392505050565b60208082526017908201527f43616c6c6572206973206e6f7420746865205661756c74000000000000000000604082015260600190565b6020808252600e908201526d1499595b9d1c985b9d0818d85b1b60921b604082015260600190565b60008219821115611e3457611e34611ecc565b500190565b600082611e5657634e487b7160e01b600052601260045260246000fd5b500490565b6000816000190483118215151615611e7557611e75611ecc565b500290565b600082821015611e8c57611e8c611ecc565b500390565b600181811c90821680611ea557607f821691505b60208210811415611ec657634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052602160045260246000fdfe53bf423e48ed90e97d02ab0ebab13b2a235a6bfbe9c321847d5c175333ac4535ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef7bea13895fa79d2831e0a9e28edede30099005a50d652d8957cf8a607ee6ca4aa26469706673582212201b8ec42930889e5de1fe27c8e9555b99a6d3a74f39b4ad730ffae97e3dc9bd4464736f6c63430008070033

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.