Token

Frax (FRAX)

ERC-20

DeFi

Overview

Max Total Supply

4,675,603.879454045909154044 FRAX

Holders

7,445 ( 0.013%)

Market

Price

$1.00 @ 0.000424 ETH (+0.02%)

Onchain Market Cap

$4,661,132.89

Circulating Supply Market Cap

$647,701,149.00

Other Info

Token Contract (WITH 18 Decimals)

0x2e3d870790dc77a83dd1d18184acc7439a53f475

Filtered by Token Holder

0xAdF902b11e4ad36B227B84d856B229258b0b0465

Balance

242.154065238336971809 FRAX

Value

$241.40 ( ~0.102568227324237 ETH) [0.0052%]

0xadf902b11e4ad36b227b84d856b229258b0b0465

OVERVIEW

Frax is a fractional-algorithmic stablecoin protocol. Frax is open-source, permissionless, and entirely on-chain – currently implemented on Ethereum. It aims to provide a highly scalable, decentralized, algorithmic money in place of fixed-supply assets like BTC.

Market

Volume (24H)	:	$26,309,779.00
Market Capitalization	:	$647,701,149.00
Circulating Supply	:	649,433,438.00 FRAX
Market Data Source: Coinmarketcap

Contract Source Code Verified (Exact Match)

Contract Name:

CrossChainCanonicalFRAX

Compiler Version

v0.8.10+commit.fc410830

Optimization Enabled:

Yes with 100000 runs

Other Settings:

default evmVersion, GNU GPLv2 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at optimistic.etherscan.io on 2022-01-09
*/

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;

// Sources flattened with hardhat v2.8.1 https://hardhat.org

// File contracts/Common/Context.sol


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

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


// File contracts/Math/SafeMath.sol


/**
 * @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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File contracts/ERC20/IERC20.sol



/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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


// File contracts/Utils/Address.sol


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

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


// File contracts/ERC20/ERC20.sol





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
 
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory __name, string memory __symbol) public {
        _name = __name;
        _symbol = __symbol;
        _decimals = 18;
    }

    /**
     * @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. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * 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;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.approve(address spender, uint256 amount)
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, 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 virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for `accounts`'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _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 virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal virtual {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of `from`'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}


// File contracts/ERC20/ERC20Permit/IERC20Permit.sol



/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File contracts/ERC20/ERC20Permit/ECDSA.sol



/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File contracts/ERC20/ERC20Permit/EIP712.sol



/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}


// File contracts/ERC20/ERC20Permit/Counters.sol



/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File contracts/ERC20/ERC20Permit/ERC20Permit.sol







/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    function PERMIT_TYPEHASH() external view returns (bytes32) {
        return _PERMIT_TYPEHASH;
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}


// File contracts/Uniswap/TransferHelper.sol


// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}


// File contracts/Staking/Owned.sol


// https://docs.synthetix.io/contracts/Owned
contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor (address _owner) public {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only the contract owner may perform this action");
        _;
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}


// File contracts/Utils/ReentrancyGuard.sol


/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

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


// File contracts/ERC20/__CROSSCHAIN/CrossChainCanonical.sol


// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ======================== CrossChainCanonical =======================
// ====================================================================
// Cross-chain / non mainnet canonical token contract.
// Can accept any number of old non-canonical tokens. These will be 
// withdrawable by the owner so they can de-bridge it and get back mainnet 'real' tokens
// Does not include any spurious mainnet logic

// Frax Finance: https://github.com/FraxFinance

// Primary Author(s)
// Travis Moore: https://github.com/FortisFortuna

// Reviewer(s) / Contributor(s)
// Jason Huan: https://github.com/jasonhuan
// Sam Kazemian: https://github.com/samkazemian
// Dennis: github.com/denett





contract CrossChainCanonical is ERC20Permit, Owned, ReentrancyGuard {
    using SafeMath for uint256;

    /* ========== STATE VARIABLES ========== */

    // Core
    address public timelock_address; // Governance timelock address
    address public custodian_address; 

    // Misc
    uint256 public mint_cap;
    mapping(address => uint256[2]) public swap_fees;
    mapping(address => bool) public fee_exempt_list;

    // Acceptable old tokens
    address[] public bridge_tokens_array;
    mapping(address => bool) public bridge_tokens;

    // The addresses in this array are able to mint tokens
    address[] public minters_array;
    mapping(address => bool) public minters; // Mapping is also used for faster verification

    // Constants for various precisions
    uint256 private constant PRICE_PRECISION = 1e6;

    // Administrative booleans
    bool public exchangesPaused; // Pause old token exchanges in case of an emergency
    mapping(address => bool) public canSwap;

    /* ========== MODIFIERS ========== */

    modifier onlyByOwnGov() {
        require(msg.sender == timelock_address || msg.sender == owner, "Not owner or timelock");
        _;
    }

    modifier onlyByOwnGovCust() {
        require(msg.sender == timelock_address || msg.sender == owner || msg.sender == custodian_address, "Not owner, tlck, or custd");
        _;
    }

    modifier onlyMinters() {
       require(minters[msg.sender], "Not a minter");
        _;
    } 

    modifier onlyMintersOwnGov() {
       require(_isMinterOwnGov(msg.sender), "Not minter, owner, or tlck");
        _;
    } 

    modifier validBridgeToken(address token_address) {
       require(bridge_tokens[token_address], "Invalid old token");
        _;
    } 

    /* ========== CONSTRUCTOR ========== */

    constructor (
        string memory _name,
        string memory _symbol,
        address _creator_address,
        uint256 _initial_mint_amt,
        address _custodian_address,
        address[] memory _bridge_tokens
    ) ERC20(_name, _symbol) ERC20Permit(_name) Owned(_creator_address) {
        custodian_address = _custodian_address;

        // Initialize the starting old tokens
        for (uint256 i = 0; i < _bridge_tokens.length; i++){ 
            // Mark as accepted
            bridge_tokens[_bridge_tokens[i]] = true;

            // Add to the array
            bridge_tokens_array.push(_bridge_tokens[i]);

            // Set a small swap fee initially of 0.04%
            swap_fees[_bridge_tokens[i]] = [400, 400];

            // Make sure swapping is on
            canSwap[_bridge_tokens[i]] = true;
        }

        // Set the mint cap to the initial mint amount
        mint_cap = _initial_mint_amt;

        // Mint some canonical tokens to the creator
        super._mint(_creator_address, _initial_mint_amt);


    }

    /* ========== VIEWS ========== */

    // Helpful for UIs
    function allBridgeTokens() external view returns (address[] memory) {
        return bridge_tokens_array;
    }

    function _isMinterOwnGov(address the_address) internal view returns (bool) {
        return (the_address == timelock_address || the_address == owner || minters[the_address]);
    }

    function _isFeeExempt(address the_address) internal view returns (bool) {
        return (_isMinterOwnGov(the_address) || fee_exempt_list[the_address]);
    }

    /* ========== INTERNAL FUNCTIONS ========== */

    // Enforce a minting cap
    function _mint_capped(address account, uint256 amount) internal {
        require(totalSupply() + amount <= mint_cap, "Mint cap");
        super._mint(account, amount);
    }

    /* ========== PUBLIC FUNCTIONS ========== */

    // Exchange old or bridge tokens for these canonical tokens
    function exchangeOldForCanonical(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 canonical_tokens_out) {
        require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");

        // Pull in the old / bridge tokens
        TransferHelper.safeTransferFrom(bridge_token_address, msg.sender, address(this), token_amount);

        // Handle the fee, if applicable
        canonical_tokens_out = token_amount;
        if (!_isFeeExempt(msg.sender)) {
            canonical_tokens_out -= ((canonical_tokens_out * swap_fees[bridge_token_address][0]) / PRICE_PRECISION);
        }

        // Mint canonical tokens and give it to the sender
        _mint_capped(msg.sender, canonical_tokens_out);
    }

    // Exchange canonical tokens for old or bridge tokens
    function exchangeCanonicalForOld(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 bridge_tokens_out) {
        require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");
        
        // Burn the canonical tokens
        super._burn(msg.sender, token_amount);

        // Handle the fee, if applicable
        bridge_tokens_out = token_amount;
        if (!_isFeeExempt(msg.sender)) {
            bridge_tokens_out -= ((bridge_tokens_out * swap_fees[bridge_token_address][1]) / PRICE_PRECISION);
        }

        // Give old / bridge tokens to the sender
        TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_tokens_out);
    }

    /* ========== MINTERS OR GOVERNANCE FUNCTIONS ========== */

    // Collect old / bridge tokens so you can de-bridge them back on mainnet
    function withdrawBridgeTokens(address bridge_token_address, uint256 bridge_token_amount) external onlyMintersOwnGov validBridgeToken(bridge_token_address) {
        TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_token_amount);
    }

    /* ========== MINTERS ONLY ========== */

    // This function is what other minters will call to mint new tokens 
    function minter_mint(address m_address, uint256 m_amount) external onlyMinters {
        _mint_capped(m_address, m_amount);
        emit TokenMinted(msg.sender, m_address, m_amount);
    }

    // This function is what other minters will call to burn tokens
    function minter_burn(uint256 amount) external onlyMinters {
        super._burn(msg.sender, amount);
        emit TokenBurned(msg.sender, amount);
    }

    /* ========== RESTRICTED FUNCTIONS, BUT CUSTODIAN CAN CALL TOO ========== */

    function toggleExchanges() external onlyByOwnGovCust {
        exchangesPaused = !exchangesPaused;
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    function addBridgeToken(address bridge_token_address, uint256 _brdg_to_can_fee, uint256 _can_to_brdg_fee) external onlyByOwnGov {
        // Make sure the token is not already present
        for (uint i = 0; i < bridge_tokens_array.length; i++){ 
            if (bridge_tokens_array[i] == bridge_token_address){
                revert("Token already present");
            }
        }

        // Add the old token
        bridge_tokens[bridge_token_address] = true;
        bridge_tokens_array.push(bridge_token_address);

        // Turn swapping on
        canSwap[bridge_token_address] = true;

        // Set the fees
        swap_fees[bridge_token_address][0] = _brdg_to_can_fee;
        swap_fees[bridge_token_address][1] = _can_to_brdg_fee;

        emit BridgeTokenAdded(bridge_token_address);
    }

    function toggleBridgeToken(address bridge_token_address) external onlyByOwnGov {
        // Make sure the token is already present in the array
        bool bridge_tkn_found;
        for (uint i = 0; i < bridge_tokens_array.length; i++){ 
            if (bridge_tokens_array[i] == bridge_token_address){
                bridge_tkn_found = true;
                break;
            }
        }
        require(bridge_tkn_found, "Bridge tkn not in array");

        // Toggle the token
        bridge_tokens[bridge_token_address] = !bridge_tokens[bridge_token_address];

        // Toggle swapping
        canSwap[bridge_token_address] = !canSwap[bridge_token_address];

        emit BridgeTokenToggled(bridge_token_address, !bridge_tokens[bridge_token_address]);
    }

    // Adds a minter address
    function addMinter(address minter_address) external onlyByOwnGov {
        require(minter_address != address(0), "Zero address detected");

        require(minters[minter_address] == false, "Address already exists");
        minters[minter_address] = true; 
        minters_array.push(minter_address);

        emit MinterAdded(minter_address);
    }

    // Remove a minter 
    function removeMinter(address minter_address) external onlyByOwnGov {
        require(minter_address != address(0), "Zero address detected");
        require(minters[minter_address] == true, "Address nonexistant");
        
        // Delete from the mapping
        delete minters[minter_address];

        // 'Delete' from the array by setting the address to 0x0
        for (uint i = 0; i < minters_array.length; i++){ 
            if (minters_array[i] == minter_address) {
                minters_array[i] = address(0); // This will leave a null in the array and keep the indices the same
                break;
            }
        }

        emit MinterRemoved(minter_address);
    }

    function setMintCap(uint256 _mint_cap) external onlyByOwnGov {
        mint_cap = _mint_cap;

        emit MintCapSet(_mint_cap);
    }

    function setSwapFees(address bridge_token_address, uint256 _bridge_to_canonical, uint256 _canonical_to_old) external onlyByOwnGov {
        swap_fees[bridge_token_address] = [_bridge_to_canonical, _canonical_to_old];
    }

    function toggleFeesForAddress(address the_address) external onlyByOwnGov {
        fee_exempt_list[the_address] = !fee_exempt_list[the_address];
    }

    function setTimelock(address new_timelock) external onlyByOwnGov {
        require(new_timelock != address(0), "Zero address detected");
        timelock_address = new_timelock;

        emit TimelockSet(new_timelock);
    }

    function setCustodian(address _custodian_address) external onlyByOwnGov {
        require(_custodian_address != address(0), "Zero address detected");
        custodian_address = _custodian_address;

        emit CustodianSet(_custodian_address);
    }

    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
        require(!bridge_tokens[tokenAddress], "Cannot withdraw bridge tokens");
        require(tokenAddress != address(this), "Cannot withdraw these tokens");

        TransferHelper.safeTransfer(address(tokenAddress), msg.sender, tokenAmount);
    }

    // // Generic proxy
    // function execute(
    //     address _to,
    //     uint256 _value,
    //     bytes calldata _data
    // ) external onlyByOwnGov returns (bool, bytes memory) {
    //     (bool success, bytes memory result) = _to.call{value:_value}(_data);
    //     return (success, result);
    // }

    /* ========== EVENTS ========== */

    event TokenBurned(address indexed from, uint256 amount);
    event TokenMinted(address indexed from, address indexed to, uint256 amount);
    event BridgeTokenAdded(address indexed bridge_token_address);
    event BridgeTokenToggled(address indexed bridge_token_address, bool state);
    event MinterAdded(address pool_address);
    event MinterRemoved(address pool_address);
    event MintCapSet(uint256 new_mint_cap);
    event TimelockSet(address new_timelock);
    event CustodianSet(address custodian_address);
}


// File contracts/ERC20/__CROSSCHAIN/CrossChainCanonicalFRAX.sol


contract CrossChainCanonicalFRAX is CrossChainCanonical {
    constructor (
        string memory _name,
        string memory _symbol,
        address _creator_address,
        uint256 _initial_mint_amt,
        address _custodian_address,
        address[] memory _bridge_tokens
    ) 
    CrossChainCanonical(_name, _symbol, _creator_address, _initial_mint_amt, _custodian_address, _bridge_tokens)
    {}
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_creator_address","type":"address"},{"internalType":"uint256","name":"_initial_mint_amt","type":"uint256"},{"internalType":"address","name":"_custodian_address","type":"address"},{"internalType":"address[]","name":"_bridge_tokens","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"bridge_token_address","type":"address"}],"name":"BridgeTokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"bridge_token_address","type":"address"},{"indexed":false,"internalType":"bool","name":"state","type":"bool"}],"name":"BridgeTokenToggled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"custodian_address","type":"address"}],"name":"CustodianSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"new_mint_cap","type":"uint256"}],"name":"MintCapSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool_address","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool_address","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"new_timelock","type":"address"}],"name":"TimelockSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBurned","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":"amount","type":"uint256"}],"name":"TokenMinted","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":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"_brdg_to_can_fee","type":"uint256"},{"internalType":"uint256","name":"_can_to_brdg_fee","type":"uint256"}],"name":"addBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"addMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allBridgeTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"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":"amount","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":"","type":"address"}],"name":"bridge_tokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bridge_tokens_array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"custodian_address","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"token_amount","type":"uint256"}],"name":"exchangeCanonicalForOld","outputs":[{"internalType":"uint256","name":"bridge_tokens_out","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"token_amount","type":"uint256"}],"name":"exchangeOldForCanonical","outputs":[{"internalType":"uint256","name":"canonical_tokens_out","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangesPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"fee_exempt_list","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"mint_cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"minter_burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"m_address","type":"address"},{"internalType":"uint256","name":"m_amount","type":"uint256"}],"name":"minter_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minters_array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"removeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_custodian_address","type":"address"}],"name":"setCustodian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mint_cap","type":"uint256"}],"name":"setMintCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"_bridge_to_canonical","type":"uint256"},{"internalType":"uint256","name":"_canonical_to_old","type":"uint256"}],"name":"setSwapFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"new_timelock","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"swap_fees","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":"timelock_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"}],"name":"toggleBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleExchanges","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"the_address","type":"address"}],"name":"toggleFeesForAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"bridge_token_amount","type":"uint256"}],"name":"withdrawBridgeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000011978d32619cfefc2e7c75a70ef8beb077b503ca00000000000000000000000000000000000000000000d3c21bcecceda1000000000000000000000000000000e4df91c3416926568a785c69479468f4ba2339e3000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000044672617800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000446524158000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Frax
Arg [1] : _symbol (string): FRAX
Arg [2] : _creator_address (address): 0x11978D32619cFefC2E7C75A70ef8BeB077b503Ca
Arg [3] : _initial_mint_amt (uint256): 1000000000000000000000000
Arg [4] : _custodian_address (address): 0xE4DF91c3416926568a785c69479468F4bA2339e3

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 00000000000000000000000011978d32619cfefc2e7c75a70ef8beb077b503ca
Arg [3] : 00000000000000000000000000000000000000000000d3c21bcecceda1000000
Arg [4] : 000000000000000000000000e4df91c3416926568a785c69479468f4ba2339e3
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4672617800000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [9] : 4652415800000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

67447:420:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61244:256;;;;;;:::i;:::-;;:::i;:::-;;56468:27;;;;;;;;;;;;639:14:1;;632:22;614:41;;602:2;587:18;56468:27:0;;;;;;;;19492:83;;;:::i;:::-;;;;;;;:::i;65458:152::-;;;;;;:::i;:::-;;:::i;21638:169::-;;;;;;:::i;:::-;;:::i;63152:784::-;;;;;;:::i;:::-;;:::i;50896:141::-;;;;;;:::i;:::-;;:::i;20567:100::-;20647:12;;20567:100;;;1713:25:1;;;1701:2;1686:18;20567:100:0;1567:177:1;22279:321:0;;;;;;:::i;:::-;;:::i;60320:771::-;;;;;;:::i;:::-;;:::i;64365:706::-;;;;;;:::i;:::-;;:::i;48532:101::-;48609:16;48532:101;;20419:83;20485:9;;20419:83;;20485:9;;;;2406:36:1;;2394:2;2379:18;20419:83:0;2264:184:1;56050:36:0;;;;;;:::i;:::-;;:::i;:::-;;;2814:42:1;2802:55;;;2784:74;;2772:2;2757:18;56050:36:0;2638:226:1;48409:115:0;;;:::i;23009:218::-;;;;;;:::i;:::-;;:::i;65855:256::-;;;;;;:::i;:::-;;:::i;65079:139::-;;;;;;:::i;:::-;;:::i;25803:91::-;;;;;;:::i;:::-;;:::i;62315:829::-;;;;;;:::i;:::-;;:::i;50664:29::-;;;;;;;;;61630:191;;;;;;:::i;:::-;;:::i;20730:119::-;;;;;;:::i;:::-;20823:18;;20796:7;20823:18;;;;;;;;;;;;20730:119;62145:106;;;:::i;51045:271::-;;;:::i;26211:295::-;;;;;;:::i;:::-;;:::i;55825:32::-;;;;;;;;;48151:128;;;;;;:::i;:::-;;:::i;55910:47::-;;;;;;:::i;:::-;;:::i;55964:::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;66119:345;;;;;;:::i;:::-;;:::i;50637:20::-;;;;;;;;;55880:23;;;;;;59440:813;;;;;;:::i;:::-;;:::i;56555:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;19694:87;;;:::i;63974:358::-;;;;;;:::i;:::-;;:::i;23730:269::-;;;;;;:::i;:::-;;:::i;65226:224::-;;;;;;:::i;:::-;;:::i;21062:175::-;;;;;;:::i;:::-;;:::i;56093:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;65618:229;;;;;;:::i;:::-;;:::i;58575:113::-;;;:::i;:::-;;;;;;;:::i;47440:645::-;;;;;;:::i;:::-;;:::i;56207:30::-;;;;;;:::i;:::-;;:::i;55756:31::-;;;;;;;;;21300:151;;;;;;:::i;:::-;21416:18;;;;21389:7;21416:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;21300:151;56244:39;;;;;;:::i;:::-;;;;;;;;;;;;;;;;61898:155;;;;;;:::i;:::-;;:::i;61244:256::-;57144:27;57160:10;57144:15;:27::i;:::-;57136:66;;;;;;;5047:2:1;57136:66:0;;;5029:21:1;5086:2;5066:18;;;5059:30;5125:28;5105:18;;;5098:56;5171:18;;57136:66:0;;;;;;;;;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;61377:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;5402:2:1;57290:58:0::1;::::0;::::1;5384:21:1::0;5441:2;5421:18;;;5414:30;5480:19;5460:18;;;5453:47;5517:18;;57290:58:0::1;5200:341:1::0;57290:58:0::1;61410:82:::2;61438:20;61460:10;61472:19;61410:27;:82::i;:::-;57213:1:::1;61244:256:::0;;:::o;19492:83::-;19529:13;19562:5;19555:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19492:83;:::o;65458:152::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;65574:28:::1;;;::::0;;;:15:::1;:28;::::0;;;;;;65542:60;;::::1;65574:28;::::0;;::::1;65573:29;65542:60;::::0;;65458:152::o;21638:169::-;21721:4;21738:39;819:10;21761:7;21770:6;21738:8;:39::i;:::-;-1:-1:-1;21795:4:0;21638:169;;;;:::o;63152:784::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;63306:21:::1;::::0;63338:213:::1;63359:19;:26:::0;63355:30;::::1;63338:213;;;63437:20;63411:46;;:19;63431:1;63411:22;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;::::1;;:46;63407:133;;;63496:4;63477:23;;63519:5;;63407:133;63387:3:::0;::::1;::::0;::::1;:::i;:::-;;;;63338:213;;;;63569:16;63561:52;;;::::0;::::1;::::0;;7118:2:1;63561:52:0::1;::::0;::::1;7100:21:1::0;7157:2;7137:18;;;7130:30;7196:25;7176:18;;;7169:53;7239:18;;63561:52:0::1;6916:347:1::0;63561:52:0::1;63694:35;::::0;::::1;;::::0;;;:13:::1;:35;::::0;;;;;;;;;::::1;::::0;;::::1;63693:36;63655:74:::0;;;::::1;;::::0;;63803:7:::1;:29:::0;;;;;;;;;;::::1;63802:30;63770:62:::0;::::1;::::0;;;::::1;::::0;;63892:35;;;;;63850:78;;63892:35;;;::::1;63891:36;614:41:1::0;;63850:78:0::1;::::0;587:18:1;63850:78:0::1;;;;;;;63231:705;63152:784:::0;:::o;50896:141::-;51376:5;;;;51362:10;:19;51354:79;;;;;;;7470:2:1;51354:79:0;;;7452:21:1;7509:2;7489:18;;;7482:30;7548:34;7528:18;;;7521:62;7619:17;7599:18;;;7592:45;7654:19;;51354:79:0;7268:411:1;51354:79:0;50968:14:::1;:23:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;51007:22:::1;::::0;2784:74:1;;;51007:22:0::1;::::0;2772:2:1;2757:18;51007:22:0::1;;;;;;;;50896:141:::0;:::o;22279:321::-;22385:4;22402:36;22412:6;22420:9;22431:6;22402:9;:36::i;:::-;22449:121;22458:6;819:10;22480:89;22518:6;22480:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;;;819:10;22480:33;;;;;;;;;;:37;:89::i;:::-;22449:8;:121::i;:::-;-1:-1:-1;22588:4:0;22279:321;;;;;:::o;60320:771::-;60475:25;53270:1;53876:7;;:19;;53868:63;;;;;;;7886:2:1;53868:63:0;;;7868:21:1;7925:2;7905:18;;;7898:30;7964:33;7944:18;;;7937:61;8015:18;;53868:63:0;7684:355:1;53868:63:0;53270:1;54009:7;:18;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;60444:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;5402:2:1;57290:58:0::1;::::0;::::1;5384:21:1::0;5441:2;5421:18;;;5414:30;5480:19;5460:18;;;5453:47;5517:18;;57290:58:0::1;5200:341:1::0;57290:58:0::1;60522:15:::2;::::0;::::2;;60521:16;:49:::0;::::2;;;-1:-1:-1::0;60541:29:0::2;::::0;::::2;;::::0;;;:7:::2;:29;::::0;;;;;::::2;;60521:49;60513:78;;;::::0;::::2;::::0;;8246:2:1;60513:78:0::2;::::0;::::2;8228:21:1::0;8285:2;8265:18;;;8258:30;8324:18;8304;;;8297:46;8360:18;;60513:78:0::2;8044:340:1::0;60513:78:0::2;60650:37;60662:10;60674:12;60650:11;:37::i;:::-;60762:12;60742:32;;60790:24;60803:10;60790:12;:24::i;:::-;60785:155;;60874:31;::::0;::::2;;::::0;;;:9:::2;:31;::::0;;;;56424:3:::2;::::0;60906:1:::2;60874:34;::::0;60854:54:::2;::::0;:17;:54:::2;:::i;:::-;60853:74;;;;:::i;:::-;60831:97;::::0;;::::2;:::i;:::-;;;60785:155;61003:80;61031:20;61053:10;61065:17;61003:27;:80::i;:::-;-1:-1:-1::0;53226:1:0;54188:7;:22;60320:771;;-1:-1:-1;;60320:771:0:o;64365:706::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;64452:28:::1;::::0;::::1;64444:62;;;::::0;::::1;::::0;;9233:2:1;64444:62:0::1;::::0;::::1;9215:21:1::0;9272:2;9252:18;;;9245:30;9311:23;9291:18;;;9284:51;9352:18;;64444:62:0::1;9031:345:1::0;64444:62:0::1;64525:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:31;;:23:::0;:31:::1;64517:63;;;::::0;::::1;::::0;;9583:2:1;64517:63:0::1;::::0;::::1;9565:21:1::0;9622:2;9602:18;;;9595:30;9661:21;9641:18;;;9634:49;9700:18;;64517:63:0::1;9381:343:1::0;64517:63:0::1;64644:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;64637:30;;;::::1;::::0;;64746:271:::1;64767:13;:20:::0;64763:24;::::1;64746:271;;;64833:14;64813:34;;:13;64827:1;64813:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;::::1;;:34;64809:197;;;64895:1;64868:13;64882:1;64868:16;;;;;;;;:::i;:::-;;;;;;;;;:29;;;;;;;;;;;;;;;;;;64985:5;;64809:197;64789:3:::0;::::1;::::0;::::1;:::i;:::-;;;;64746:271;;;-1:-1:-1::0;65034:29:0::1;::::0;2814:42:1;2802:55;;2784:74;;65034:29:0::1;::::0;2772:2:1;2757:18;65034:29:0::1;2638:226:1::0;56050:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56050:36:0;:::o;48409:115::-;48469:7;48496:20;:18;:20::i;:::-;48489:27;;48409:115;:::o;23009:218::-;819:10;23097:4;23146:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;23097:4;;23114:83;;23137:7;;23146:50;;23185:10;23146:38;:50::i;65855:256::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;65946:32:::1;::::0;::::1;65938:66;;;::::0;::::1;::::0;;9233:2:1;65938:66:0::1;::::0;::::1;9215:21:1::0;9272:2;9252:18;;;9245:30;9311:23;9291:18;;;9284:51;9352:18;;65938:66:0::1;9031:345:1::0;65938:66:0::1;66015:17;:38:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;66071:32:::1;::::0;2784:74:1;;;66071:32:0::1;::::0;2772:2:1;2757:18;66071:32:0::1;2638:226:1::0;65079:139:0;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;65151:8:::1;:20:::0;;;65189:21:::1;::::0;1713:25:1;;;65189:21:0::1;::::0;1701:2:1;1686:18;65189:21:0::1;1567:177:1::0;25803:91:0;25859:27;819:10;25879:6;25859:5;:27::i;:::-;25803:91;:::o;62315:829::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;62514:6:::1;62509:197;62530:19;:26:::0;62526:30;::::1;62509:197;;;62608:20;62582:46;;:19;62602:1;62582:22;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;::::1;;:46;62578:117;;;62648:31;::::0;::::1;::::0;;9931:2:1;62648:31:0::1;::::0;::::1;9913:21:1::0;9970:2;9950:18;;;9943:30;10009:23;9989:18;;;9982:51;10050:18;;62648:31:0::1;9729:345:1::0;62578:117:0::1;62558:3:::0;::::1;::::0;::::1;:::i;:::-;;;;62509:197;;;-1:-1:-1::0;62748:35:0::1;::::0;::::1;;::::0;;;:13:::1;:35;::::0;;;;;;;:42;;62786:4:::1;62748:42:::0;;;::::1;::::0;::::1;::::0;;;62801:19:::1;:46:::0;;;;::::1;::::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;62889:7:::1;:29:::0;;;;;:36;;;;::::1;::::0;::::1;::::0;;62963:9:::1;:31:::0;;;;;;:53;;;63027:34;;::::1;:53:::0;;;63098:38;::::1;::::0;62748:35;63098:38:::1;62315:829:::0;;;:::o;61630:191::-;57040:10;57032:19;;;;:7;:19;;;;;;;;57024:44;;;;;;;10281:2:1;57024:44:0;;;10263:21:1;10320:2;10300:18;;;10293:30;10359:14;10339:18;;;10332:42;10391:18;;57024:44:0;10079:336:1;57024:44:0;61720:33:::1;61733:9;61744:8;61720:12;:33::i;:::-;61769:44;::::0;1713:25:1;;;61769:44:0::1;::::0;::::1;::::0;61781:10:::1;::::0;61769:44:::1;::::0;1701:2:1;1686:18;61769:44:0::1;;;;;;;;61630:191:::0;;:::o;62145:106::-;56859:16;;;;56845:10;:30;;:53;;-1:-1:-1;56893:5:0;;;;56879:10;:19;56845:53;:88;;;-1:-1:-1;56916:17:0;;;;56902:10;:31;56845:88;56837:126;;;;;;;10622:2:1;56837:126:0;;;10604:21:1;10661:2;10641:18;;;10634:30;10700:27;10680:18;;;10673:55;10745:18;;56837:126:0;10420:349:1;56837:126:0;62228:15:::1;::::0;;62209:34;;::::1;62228:15;::::0;;::::1;62227:16;62209:34;::::0;;62145:106::o;51045:271::-;51114:14;;;;51100:10;:28;51092:94;;;;;;;10976:2:1;51092:94:0;;;10958:21:1;11015:2;10995:18;;;10988:30;11054:34;11034:18;;;11027:62;11125:23;11105:18;;;11098:51;11166:19;;51092:94:0;10774:417:1;51092:94:0;51215:5;;51222:14;;51202:35;;;51215:5;;;;11431:34:1;;51222:14:0;;;;11496:2:1;11481:18;;11474:43;51202:35:0;;11343:18:1;51202:35:0;;;;;;;51256:14;;;51248:5;:22;;;;;;51256:14;;;51248:22;;;;51281:27;;;51045:271::o;26211:295::-;26288:26;26317:84;26354:6;26317:84;;;;;;;;;;;;;;;;;:32;26327:7;819:10;21300:151;:::i;26317:32::-;:36;:84;:36;:84::i;:::-;26288:113;-1:-1:-1;26414:51:0;26423:7;819:10;26446:18;26414:8;:51::i;:::-;26476:22;26482:7;26491:6;26476:5;:22::i;48151:128::-;48247:14;;;48220:7;48247:14;;;:7;:14;;;;;45619;48247:24;48240:31;48151:128;-1:-1:-1;;48151:128:0:o;55910:47::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55910:47:0;;-1:-1:-1;55910:47:0:o;66119:345::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;66226:27:::1;::::0;::::1;;::::0;;;:13:::1;:27;::::0;;;;;::::1;;66225:28;66217:70;;;::::0;::::1;::::0;;11730:2:1;66217:70:0::1;::::0;::::1;11712:21:1::0;11769:2;11749:18;;;11742:30;11808:31;11788:18;;;11781:59;11857:18;;66217:70:0::1;11528:353:1::0;66217:70:0::1;66306:29;::::0;::::1;66330:4;66306:29;;66298:70;;;::::0;::::1;::::0;;12088:2:1;66298:70:0::1;::::0;::::1;12070:21:1::0;12127:2;12107:18;;;12100:30;12166;12146:18;;;12139:58;12214:18;;66298:70:0::1;11886:352:1::0;66298:70:0::1;66381:75;66417:12;66432:10;66444:11;66381:27;:75::i;:::-;66119:345:::0;;:::o;59440:813::-;59595:28;53270:1;53876:7;;:19;;53868:63;;;;;;;7886:2:1;53868:63:0;;;7868:21:1;7925:2;7905:18;;;7898:30;7964:33;7944:18;;;7937:61;8015:18;;53868:63:0;7684:355:1;53868:63:0;53270:1;54009:7;:18;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;59564:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;5402:2:1;57290:58:0::1;::::0;::::1;5384:21:1::0;5441:2;5421:18;;;5414:30;5480:19;5460:18;;;5453:47;5517:18;;57290:58:0::1;5200:341:1::0;57290:58:0::1;59645:15:::2;::::0;::::2;;59644:16;:49:::0;::::2;;;-1:-1:-1::0;59664:29:0::2;::::0;::::2;;::::0;;;:7:::2;:29;::::0;;;;;::::2;;59644:49;59636:78;;;::::0;::::2;::::0;;8246:2:1;59636:78:0::2;::::0;::::2;8228:21:1::0;8285:2;8265:18;;;8258:30;8324:18;8304;;;8297:46;8360:18;;59636:78:0::2;8044:340:1::0;59636:78:0::2;59771:94;59803:20;59825:10;59845:4;59852:12;59771:31;:94::i;:::-;59943:12;59920:35;;59971:24;59984:10;59971:12;:24::i;:::-;59966:161;;60061:31;::::0;::::2;;::::0;;;:9:::2;:31;::::0;;;;:34;56424:3:::2;::::0;60038:57:::2;::::0;:20;:57:::2;:::i;:::-;60037:77;;;;:::i;:::-;60012:103;::::0;;::::2;:::i;:::-;;;59966:161;60199:46;60212:10;60224:20;60199:12;:46::i;19694:87::-:0;19733:13;19766:7;19759:14;;;;;:::i;63974:358::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;64058:28:::1;::::0;::::1;64050:62;;;::::0;::::1;::::0;;9233:2:1;64050:62:0::1;::::0;::::1;9215:21:1::0;9272:2;9252:18;;;9245:30;9311:23;9291:18;;;9284:51;9352:18;;64050:62:0::1;9031:345:1::0;64050:62:0::1;64133:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:32;64125:67;;;::::0;::::1;::::0;;12445:2:1;64125:67:0::1;::::0;::::1;12427:21:1::0;12484:2;12464:18;;;12457:30;12523:24;12503:18;;;12496:52;12565:18;;64125:67:0::1;12243:346:1::0;64125:67:0::1;64203:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;;;:30;;;::::1;64229:4;64203:30:::0;;::::1;::::0;;;64245:13:::1;:34:::0;;;;::::1;::::0;;;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;64297:27;;2784:74:1;;;64297:27:0::1;::::0;2757:18:1;64297:27:0::1;2638:226:1::0;23730:269:0;23823:4;23840:129;819:10;23863:7;23872:96;23911:15;23872:96;;;;;;;;;;;;;;;;;819:10;23872:25;;;;:11;:25;;;;;;;;;:34;;;;;;;;;;;;:38;:96::i;65226:224::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;65367:75:::1;::::0;;;;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;;:31:::1;::::0;::::1;-1:-1:-1::0;65367:31:0;;;:9:::1;:31:::0;;;;;;;:75:::1;::::0;::::1;;:::i;:::-;;65226:224:::0;;;:::o;21062:175::-;21148:4;21165:42;819:10;21189:9;21200:6;21165:9;:42::i;65618:229::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;6190:2:1;56683:87:0;;;6172:21:1;6229:2;6209:18;;;6202:30;6268:23;6248:18;;;6241:51;6309:18;;56683:87:0;5988:345:1;56683:87:0;65702:26:::1;::::0;::::1;65694:60;;;::::0;::::1;::::0;;9233:2:1;65694:60:0::1;::::0;::::1;9215:21:1::0;9272:2;9252:18;;;9245:30;9311:23;9291:18;;;9284:51;9352:18;;65694:60:0::1;9031:345:1::0;65694:60:0::1;65765:16;:31:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;65814:25:::1;::::0;2784:74:1;;;65814:25:0::1;::::0;2772:2:1;2757:18;65814:25:0::1;2638:226:1::0;58575:113:0;58625:16;58661:19;58654:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58575:113;:::o;47440:645::-;47684:8;47665:15;:27;;47657:69;;;;;;;12796:2:1;47657:69:0;;;12778:21:1;12835:2;12815:18;;;12808:30;12874:31;12854:18;;;12847:59;12923:18;;47657:69:0;12594:353:1;47657:69:0;47739:18;47781:16;47799:5;47806:7;47815:5;47822:16;47832:5;47822:9;:16::i;:::-;47770:79;;;;;;13239:25:1;;;;13283:42;13361:15;;;13341:18;;;13334:43;13413:15;;;;13393:18;;;13386:43;13445:18;;;13438:34;13488:19;;;13481:35;13532:19;;;13525:35;;;13211:19;;47770:79:0;;;;;;;;;;;;47760:90;;;;;;47739:111;;47863:12;47878:28;47895:10;47878:16;:28::i;:::-;47863:43;;47919:14;47936:28;47950:4;47956:1;47959;47962;47936:13;:28::i;:::-;47919:45;;47993:5;47983:15;;:6;:15;;;47975:58;;;;;;;13773:2:1;47975:58:0;;;13755:21:1;13812:2;13792:18;;;13785:30;13851:32;13831:18;;;13824:60;13901:18;;47975:58:0;13571:354:1;47975:58:0;48046:31;48055:5;48062:7;48071:5;48046:8;:31::i;:::-;47646:439;;;47440:645;;;;;;;:::o;56207:30::-;;;;;;;;;;;;61898:155;57040:10;57032:19;;;;:7;:19;;;;;;;;57024:44;;;;;;;10281:2:1;57024:44:0;;;10263:21:1;10320:2;10300:18;;;10293:30;10359:14;10339:18;;;10332:42;10391:18;;57024:44:0;10079:336:1;57024:44:0;61967:31:::1;61979:10;61991:6;61967:11;:31::i;:::-;62014;::::0;1713:25:1;;;62026:10:0::1;::::0;62014:31:::1;::::0;1701:2:1;1686:18;62014:31:0::1;;;;;;;61898:155:::0;:::o;25309:378::-;25393:21;;;25385:65;;;;;;;14132:2:1;25385:65:0;;;14114:21:1;14171:2;14151:18;;;14144:30;14210:33;14190:18;;;14183:61;14261:18;;25385:65:0;13930:355:1;25385:65:0;25540:12;;:24;;25557:6;25540:16;:24::i;:::-;25525:12;:39;25596:18;;;:9;:18;;;;;;;;;;;:30;;25619:6;25596:22;:30::i;:::-;25575:18;;;:9;:18;;;;;;;;;;;:51;;;;25642:37;;1713:25:1;;;25575:18:0;;:9;;25642:37;;1686:18:1;25642:37:0;1567:177:1;1961:181:0;2019:7;;2051:5;2055:1;2051;:5;:::i;:::-;2039:17;;2080:1;2075;:6;;2067:46;;;;;;;14625:2:1;2067:46:0;;;14607:21:1;14664:2;14644:18;;;14637:30;14703:29;14683:18;;;14676:57;14750:18;;2067:46:0;14423:351:1;2067:46:0;2133:1;1961:181;-1:-1:-1;;;1961:181:0:o;58696:182::-;58805:16;;58765:4;;58805:16;58790:31;;;58805:16;;58790:31;;:55;;-1:-1:-1;58840:5:0;;;58825:20;;;58840:5;;58825:20;58790:55;:79;;;-1:-1:-1;;58849:20:0;;;;;;:7;:20;;;;;;;;;58696:182::o;49545:361::-;49740:45;;;49729:10;14971:55:1;;;49740:45:0;;;14953:74:1;15043:18;;;;15036:34;;;49740:45:0;;;;;;;;;;14926:18:1;;;;49740:45:0;;;;;;;;;;;;;49729:57;;-1:-1:-1;;;;49729:10:0;;;;:57;;49740:45;49729:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49693:93;;;;49805:7;:57;;;;-1:-1:-1;49817:11:0;;:16;;:44;;;49848:4;49837:24;;;;;;;;;;;;:::i;:::-;49797:101;;;;;;;15844:2:1;49797:101:0;;;15826:21:1;15883:2;15863:18;;;15856:30;15922:33;15902:18;;;15895:61;15973:18;;49797:101:0;15642:355:1;49797:101:0;49615:291;;49545:361;;;:::o;27698:346::-;27800:19;;;27792:68;;;;;;;16204:2:1;27792:68:0;;;16186:21:1;16243:2;16223:18;;;16216:30;16282:34;16262:18;;;16255:62;16353:6;16333:18;;;16326:34;16377:19;;27792:68:0;16002:400:1;27792:68:0;27879:21;;;27871:68;;;;;;;16609:2:1;27871:68:0;;;16591:21:1;16648:2;16628:18;;;16621:30;16687:34;16667:18;;;16660:62;16758:4;16738:18;;;16731:32;16780:19;;27871:68:0;16407:398:1;27871:68:0;27952:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;28004:32;;1713:25:1;;;28004:32:0;;1686:18:1;28004:32:0;;;;;;;;27698:346;;;:::o;24489:539::-;24595:20;;;24587:70;;;;;;;17012:2:1;24587:70:0;;;16994:21:1;17051:2;17031:18;;;17024:30;17090:34;17070:18;;;17063:62;17161:7;17141:18;;;17134:35;17186:19;;24587:70:0;16810:401:1;24587:70:0;24676:23;;;24668:71;;;;;;;17418:2:1;24668:71:0;;;17400:21:1;17457:2;17437:18;;;17430:30;17496:34;17476:18;;;17469:62;17567:5;17547:18;;;17540:33;17590:19;;24668:71:0;17216:399:1;24668:71:0;24832;24854:6;24832:71;;;;;;;;;;;;;;;;;:17;;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;24812:17;;;;:9;:17;;;;;;;;;;;:91;;;;24937:20;;;;;;;:32;;24962:6;24937:24;:32::i;:::-;24914:20;;;;:9;:20;;;;;;;;;;;;:55;;;;24985:35;1713:25:1;;;24914:20:0;;24985:35;;;;;;1686:18:1;24985:35:0;1567:177:1;2890:192:0;2976:7;3012:12;3004:6;;;;2996:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3036:9:0;3048:5;3052:1;3048;:5;:::i;:::-;3036:17;2890:192;-1:-1:-1;;;;;2890:192:0:o;26840:418::-;26924:21;;;26916:67;;;;;;;17822:2:1;26916:67:0;;;17804:21:1;17861:2;17841:18;;;17834:30;17900:34;17880:18;;;17873:62;17971:3;17951:18;;;17944:31;17992:19;;26916:67:0;17620:397:1;26916:67:0;27079:68;27102:6;27079:68;;;;;;;;;;;;;;;;;:18;;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;27058:18;;;:9;:18;;;;;;;;;;:89;27173:12;;:24;;27190:6;27173:16;:24::i;:::-;27158:12;:39;27213:37;;1713:25:1;;;27239:1:0;;27213:37;;;;;;1701:2:1;1686:18;27213:37:0;1567:177:1;58886:160:0;58952:4;58977:28;58993:11;58977:15;:28::i;:::-;:60;;;-1:-1:-1;;59009:28:0;;;;;;:15;:28;;;;;;;;;58886:160::o;43370:281::-;43423:7;43464:16;43447:13;:33;43443:201;;;-1:-1:-1;43504:24:0;;43370:281::o;43443:201::-;-1:-1:-1;43840:73:0;;;43590:10;43840:73;;;;19425:25:1;;;;43602:12:0;19466:18:1;;;19459:34;43616:15:0;19509:18:1;;;19502:34;43884:13:0;19552:18:1;;;19545:34;43907:4:0;19595:19:1;;;;19588:84;;;;43840:73:0;;;;;;;;;;19397:19:1;;;;43840:73:0;;;43830:84;;;;;;48409:115::o;59138:177::-;59247:8;;59237:6;59221:13;20647:12;;;20567:100;59221:13;:22;;;;:::i;:::-;:34;;59213:55;;;;;;;18224:2:1;59213:55:0;;;18206:21:1;18263:1;18243:18;;;18236:29;18301:10;18281:18;;;18274:38;18329:18;;59213:55:0;18022:331:1;59213:55:0;59279:28;59291:7;59300:6;59279:11;:28::i;49914:402::-;50139:51;;;50128:10;18639:15:1;;;50139:51:0;;;18621:34:1;18691:15;;;18671:18;;;18664:43;18723:18;;;;18716:34;;;50139:51:0;;;;;;;;;;18533:18:1;;;;50139:51:0;;;;;;;;;;;;;50128:63;;-1:-1:-1;;;;50128:10:0;;;;:63;;50139:51;50128:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50092:99;;;;50210:7;:57;;;;-1:-1:-1;50222:11:0;;:16;;:44;;;50253:4;50242:24;;;;;;;;;;;;:::i;:::-;50202:106;;;;;;;18963:2:1;50202:106:0;;;18945:21:1;19002:2;18982:18;;;18975:30;19041:34;19021:18;;;19014:62;19112:6;19092:18;;;19085:34;19136:19;;50202:106:0;18761:400:1;50202:106:0;50002:314;;49914:402;;;;:::o;48771:207::-;48892:14;;;48831:15;48892:14;;;:7;:14;;;;;45619;;45756:1;45738:19;;;;45619:14;48953:17;48848:130;48771:207;;;:::o;44564:167::-;44641:7;44668:55;44690:20;:18;:20::i;:::-;44712:10;40272:57;;19953:66:1;40272:57:0;;;19941:79:1;20036:11;;;20029:27;;;20072:12;;;20065:28;;;40235:7:0;;20109:12:1;;40272:57:0;;;;;;;;;;;;40262:68;;;;;;40255:75;;40142:196;;;;;38944:279;39072:7;39093:17;39112:18;39134:25;39145:4;39151:1;39154;39157;39134:10;:25::i;:::-;39092:67;;;;39170:18;39182:5;39170:11;:18::i;:::-;-1:-1:-1;39206:9:0;38944:279;-1:-1:-1;;;;;38944:279:0:o;2417:136::-;2475:7;2502:43;2506:1;2509;2502:43;;;;;;;;;;;;;;;;;:3;:43::i;37173:1632::-;37304:7;;38238:66;38225:79;;38221:163;;;-1:-1:-1;38337:1:0;;-1:-1:-1;38341:30:0;38321:51;;38221:163;38398:1;:7;;38403:2;38398:7;;:18;;;;;38409:1;:7;;38414:2;38409:7;;38398:18;38394:102;;;-1:-1:-1;38449:1:0;;-1:-1:-1;38453:30:0;38433:51;;38394:102;38610:24;;;38593:14;38610:24;;;;;;;;;20359:25:1;;;20432:4;20420:17;;20400:18;;;20393:45;;;;20454:18;;;20447:34;;;20497:18;;;20490:34;;;38610:24:0;;20331:19:1;;38610:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;38610:24:0;;;;;;-1:-1:-1;;38649:20:0;;;38645:103;;38702:1;38706:29;38686:50;;;;;;;38645:103;38768:6;-1:-1:-1;38776:20:0;;-1:-1:-1;37173:1632:0;;;;;;;;:::o;31835:643::-;31913:20;31904:5;:29;;;;;;;;:::i;:::-;;31900:571;;;31835:643;:::o;31900:571::-;32011:29;32002:5;:38;;;;;;;;:::i;:::-;;31998:473;;;32057:34;;;;;20926:2:1;32057:34:0;;;20908:21:1;20965:2;20945:18;;;20938:30;21004:26;20984:18;;;20977:54;21048:18;;32057:34:0;20724:348:1;31998:473:0;32122:35;32113:5;:44;;;;;;;;:::i;:::-;;32109:362;;;32174:41;;;;;21279:2:1;32174:41:0;;;21261:21:1;21318:2;21298:18;;;21291:30;21357:33;21337:18;;;21330:61;21408:18;;32174:41:0;21077:355:1;32109:362:0;32246:30;32237:5;:39;;;;;;;;:::i;:::-;;32233:238;;;32293:44;;;;;21639:2:1;32293:44:0;;;21621:21:1;21678:2;21658:18;;;21651:30;21717:34;21697:18;;;21690:62;21788:4;21768:18;;;21761:32;21810:19;;32293:44:0;21437:398:1;32233:238:0;32368:30;32359:5;:39;;;;;;;;:::i;:::-;;32355:116;;;32415:44;;;;;22042:2:1;32415:44:0;;;22024:21:1;22081:2;22061:18;;;22054:30;22120:34;22100:18;;;22093:62;22191:4;22171:18;;;22164:32;22213:19;;32415:44:0;21840:398:1;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:254::-;283:6;291;344:2;332:9;323:7;319:23;315:32;312:52;;;360:1;357;350:12;312:52;383:29;402:9;383:29;:::i;:::-;373:39;459:2;444:18;;;;431:32;;-1:-1:-1;;;215:254:1:o;666:258::-;738:1;748:113;762:6;759:1;756:13;748:113;;;838:11;;;832:18;819:11;;;812:39;784:2;777:10;748:113;;;879:6;876:1;873:13;870:48;;;-1:-1:-1;;914:1:1;896:16;;889:27;666:258::o;929:442::-;1078:2;1067:9;1060:21;1041:4;1110:6;1104:13;1153:6;1148:2;1137:9;1133:18;1126:34;1169:66;1228:6;1223:2;1212:9;1208:18;1203:2;1195:6;1191:15;1169:66;:::i;:::-;1287:2;1275:15;1292:66;1271:88;1256:104;;;;1362:2;1252:113;;929:442;-1:-1:-1;;929:442:1:o;1376:186::-;1435:6;1488:2;1476:9;1467:7;1463:23;1459:32;1456:52;;;1504:1;1501;1494:12;1456:52;1527:29;1546:9;1527:29;:::i;1749:328::-;1826:6;1834;1842;1895:2;1883:9;1874:7;1870:23;1866:32;1863:52;;;1911:1;1908;1901:12;1863:52;1934:29;1953:9;1934:29;:::i;:::-;1924:39;;1982:38;2016:2;2005:9;2001:18;1982:38;:::i;:::-;1972:48;;2067:2;2056:9;2052:18;2039:32;2029:42;;1749:328;;;;;:::o;2453:180::-;2512:6;2565:2;2553:9;2544:7;2540:23;2536:32;2533:52;;;2581:1;2578;2571:12;2533:52;-1:-1:-1;2604:23:1;;2453:180;-1:-1:-1;2453:180:1:o;2869:322::-;2946:6;2954;2962;3015:2;3003:9;2994:7;2990:23;2986:32;2983:52;;;3031:1;3028;3021:12;2983:52;3054:29;3073:9;3054:29;:::i;:::-;3044:39;3130:2;3115:18;;3102:32;;-1:-1:-1;3181:2:1;3166:18;;;3153:32;;2869:322;-1:-1:-1;;;2869:322:1:o;3196:681::-;3367:2;3419:21;;;3489:13;;3392:18;;;3511:22;;;3338:4;;3367:2;3590:15;;;;3564:2;3549:18;;;3338:4;3633:218;3647:6;3644:1;3641:13;3633:218;;;3712:13;;3727:42;3708:62;3696:75;;3826:15;;;;3791:12;;;;3669:1;3662:9;3633:218;;;-1:-1:-1;3868:3:1;;3196:681;-1:-1:-1;;;;;;3196:681:1:o;3882:693::-;3993:6;4001;4009;4017;4025;4033;4041;4094:3;4082:9;4073:7;4069:23;4065:33;4062:53;;;4111:1;4108;4101:12;4062:53;4134:29;4153:9;4134:29;:::i;:::-;4124:39;;4182:38;4216:2;4205:9;4201:18;4182:38;:::i;:::-;4172:48;;4267:2;4256:9;4252:18;4239:32;4229:42;;4318:2;4307:9;4303:18;4290:32;4280:42;;4372:3;4361:9;4357:19;4344:33;4417:4;4410:5;4406:16;4399:5;4396:27;4386:55;;4437:1;4434;4427:12;4386:55;3882:693;;;;-1:-1:-1;3882:693:1;;;;4460:5;4512:3;4497:19;;4484:33;;-1:-1:-1;4564:3:1;4549:19;;;4536:33;;3882:693;-1:-1:-1;;3882:693:1:o;4580:260::-;4648:6;4656;4709:2;4697:9;4688:7;4684:23;4680:32;4677:52;;;4725:1;4722;4715:12;4677:52;4748:29;4767:9;4748:29;:::i;:::-;4738:39;;4796:38;4830:2;4819:9;4815:18;4796:38;:::i;:::-;4786:48;;4580:260;;;;;:::o;5546:437::-;5625:1;5621:12;;;;5668;;;5689:61;;5743:4;5735:6;5731:17;5721:27;;5689:61;5796:2;5788:6;5785:14;5765:18;5762:38;5759:218;;;5833:77;5830:1;5823:88;5934:4;5931:1;5924:15;5962:4;5959:1;5952:15;6338:184;6390:77;6387:1;6380:88;6487:4;6484:1;6477:15;6511:4;6508:1;6501:15;6527:184;6579:77;6576:1;6569:88;6676:4;6673:1;6666:15;6700:4;6697:1;6690:15;6716:195;6755:3;6786:66;6779:5;6776:77;6773:103;;;6856:18;;:::i;:::-;-1:-1:-1;6903:1:1;6892:13;;6716:195::o;8389:228::-;8429:7;8555:1;8487:66;8483:74;8480:1;8477:81;8472:1;8465:9;8458:17;8454:105;8451:131;;;8562:18;;:::i;:::-;-1:-1:-1;8602:9:1;;8389:228::o;8622:274::-;8662:1;8688;8678:189;;8723:77;8720:1;8713:88;8824:4;8821:1;8814:15;8852:4;8849:1;8842:15;8678:189;-1:-1:-1;8881:9:1;;8622:274::o;8901:125::-;8941:4;8969:1;8966;8963:8;8960:34;;;8974:18;;:::i;:::-;-1:-1:-1;9011:9:1;;8901:125::o;14290:128::-;14330:3;14361:1;14357:6;14354:1;14351:13;14348:39;;;14367:18;;:::i;:::-;-1:-1:-1;14403:9:1;;14290:128::o;15081:274::-;15210:3;15248:6;15242:13;15264:53;15310:6;15305:3;15298:4;15290:6;15286:17;15264:53;:::i;:::-;15333:16;;;;;15081:274;-1:-1:-1;;15081:274:1:o;15360:277::-;15427:6;15480:2;15468:9;15459:7;15455:23;15451:32;15448:52;;;15496:1;15493;15486:12;15448:52;15528:9;15522:16;15581:5;15574:13;15567:21;15560:5;15557:32;15547:60;;15603:1;15600;15593:12;20535:184;20587:77;20584:1;20577:88;20684:4;20681:1;20674:15;20708:4;20705:1;20698:15

Swarm Source

ipfs://9d56d9056020fabf41c7aff578b63bba4014e6b4f384025db2d53cef9cfb5b64

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services