Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at basescan.org on 2024-07-20
*/

// SPDX-License-Identifier: MIT

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @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}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead 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.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 default value returned by this function, unless
     * it's overridden.
     *
     * 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 virtual returns (uint8) {
        return 18;
    }

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This 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.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: OptimismMintableERC20/contracts/universal/IOptimismMintableERC20.sol


pragma solidity ^0.8.0;


/**
 * @title IOptimismMintableERC20
 * @notice This interface is available on the OptimismMintableERC20 contract. We declare it as a
 *         separate interface so that it can be used in custom implementations of
 *         OptimismMintableERC20.
 */
interface IOptimismMintableERC20 is IERC165 {
    function remoteToken() external returns (address);

    function bridge() external returns (address);

    function mint(address _to, uint256 _amount) external;

    function burn(address _from, uint256 _amount) external;
}

/**
 * @custom:legacy
 * @title ILegacyMintableERC20
 * @notice This interface was available on the legacy L2StandardERC20 contract. It remains available
 *         on the OptimismMintableERC20 contract for backwards compatibility.
 */
interface ILegacyMintableERC20 is IERC165 {
    function l1Token() external returns (address);

    function mint(address _to, uint256 _amount) external;

    function burn(address _from, uint256 _amount) external;
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: OptimismMintableERC20/contracts/universal/Semver.sol


pragma solidity ^0.8.0;


/**
 * @title Semver
 * @notice Semver is a simple contract for managing contract versions.
 */
contract Semver {
    /**
     * @notice Contract version number (major).
     */
    uint256 private immutable MAJOR_VERSION;

    /**
     * @notice Contract version number (minor).
     */
    uint256 private immutable MINOR_VERSION;

    /**
     * @notice Contract version number (patch).
     */
    uint256 private immutable PATCH_VERSION;

    /**
     * @param _major Version number (major).
     * @param _minor Version number (minor).
     * @param _patch Version number (patch).
     */
    constructor(
        uint256 _major,
        uint256 _minor,
        uint256 _patch
    ) {
        MAJOR_VERSION = _major;
        MINOR_VERSION = _minor;
        PATCH_VERSION = _patch;
    }

    /**
     * @notice Returns the full semver contract version.
     *
     * @return Semver contract version as a string.
     */
    function version() public view returns (string memory) {
        return
            string(
                abi.encodePacked(
                    Strings.toString(MAJOR_VERSION),
                    ".",
                    Strings.toString(MINOR_VERSION),
                    ".",
                    Strings.toString(PATCH_VERSION)
                )
            );
    }
}

// File: OptimismMintableERC20/contracts/universal/OptimismMintableERC20.sol


pragma solidity 0.8.20;





/**
 * @title OptimismMintableERC20
 * @notice OptimismMintableERC20 is a standard extension of the base ERC20 token contract designed
 *         to allow the StandardBridge contracts to mint and burn tokens. This makes it possible to
 *         use an OptimismMintablERC20 as the L2 representation of an L1 token, or vice-versa.
 *         Designed to be backwards compatible with the older StandardL2ERC20 token which was only
 *         meant for use on L2.
 */
contract OptimismMintableERC20 is IOptimismMintableERC20, ILegacyMintableERC20, ERC20, Semver {
    /**
     * @notice Address of the corresponding version of this token on the remote chain.
     */
    address public immutable REMOTE_TOKEN;

    /**
     * @notice Address of the StandardBridge on this network.
     */
    address public immutable BRIDGE;

    /**
     * @notice Emitted whenever tokens are minted for an account.
     *
     * @param account Address of the account tokens are being minted for.
     * @param amount  Amount of tokens minted.
     */
    event Mint(address indexed account, uint256 amount);

    /**
     * @notice Emitted whenever tokens are burned from an account.
     *
     * @param account Address of the account tokens are being burned from.
     * @param amount  Amount of tokens burned.
     */
    event Burn(address indexed account, uint256 amount);

    /**
     * @notice A modifier that only allows the bridge to call
     */
    modifier onlyBridge() {
        require(msg.sender == BRIDGE, "OptimismMintableERC20: only bridge can mint and burn");
        _;
    }

    /**
     * @custom:semver 1.0.0
     *
     * @param _bridge      Address of the L2 standard bridge.
     * @param _remoteToken Address of the corresponding L1 token.
     * @param _name        ERC20 name.
     * @param _symbol      ERC20 symbol.
     */
    constructor(
        address _bridge,
        address _remoteToken,
        string memory _name,
        string memory _symbol
    ) ERC20(_name, _symbol) Semver(1, 0, 0) {
        REMOTE_TOKEN = _remoteToken;
        BRIDGE = _bridge;
    }

    /**
     * @notice Allows the StandardBridge on this network to mint tokens.
     *
     * @param _to     Address to mint tokens to.
     * @param _amount Amount of tokens to mint.
     */
    function mint(address _to, uint256 _amount)
        external
        virtual
        override(IOptimismMintableERC20, ILegacyMintableERC20)
        onlyBridge
    {
        _mint(_to, _amount);
        emit Mint(_to, _amount);
    }

    /**
     * @notice Allows the StandardBridge on this network to burn tokens.
     *
     * @param _from   Address to burn tokens from.
     * @param _amount Amount of tokens to burn.
     */
    function burn(address _from, uint256 _amount)
        external
        virtual
        override(IOptimismMintableERC20, ILegacyMintableERC20)
        onlyBridge
    {
        _burn(_from, _amount);
        emit Burn(_from, _amount);
    }

    /**
     * @notice ERC165 interface check function.
     *
     * @param _interfaceId Interface ID to check.
     *
     * @return Whether or not the interface is supported by this contract.
     */
    function supportsInterface(bytes4 _interfaceId) external pure returns (bool) {
        bytes4 iface1 = type(IERC165).interfaceId;
        // Interface corresponding to the legacy L2StandardERC20.
        bytes4 iface2 = type(ILegacyMintableERC20).interfaceId;
        // Interface corresponding to the updated OptimismMintableERC20 (this contract).
        bytes4 iface3 = type(IOptimismMintableERC20).interfaceId;
        return _interfaceId == iface1 || _interfaceId == iface2 || _interfaceId == iface3;
    }

    /**
     * @custom:legacy
     * @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.
     */
    function l1Token() public view returns (address) {
        return REMOTE_TOKEN;
    }

    /**
     * @custom:legacy
     * @notice Legacy getter for the bridge. Use BRIDGE going forward.
     */
    function l2Bridge() public view returns (address) {
        return BRIDGE;
    }

    /**
     * @custom:legacy
     * @notice Legacy getter for REMOTE_TOKEN.
     */
    function remoteToken() public view returns (address) {
        return REMOTE_TOKEN;
    }

    /**
     * @custom:legacy
     * @notice Legacy getter for BRIDGE.
     */
    function bridge() public view returns (address) {
        return BRIDGE;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_bridge","type":"address"},{"internalType":"address","name":"_remoteToken","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"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":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","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":"BRIDGE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REMOTE_TOKEN","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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remoteToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000004200000000000000000000000000000000000010000000000000000000000000ab814ce69e15f6b9660a3b184c0b0c97b9394a6b000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000012436572656272756d2044414f20546f6b656e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064e4555524f4e0000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _bridge (address): 0x4200000000000000000000000000000000000010
Arg [1] : _remoteToken (address): 0xab814ce69E15F6B9660A3B184c0B0C97B9394A6b
Arg [2] : _name (string): Cerebrum DAO Token
Arg [3] : _symbol (string): NEURON

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000004200000000000000000000000000000000000010
Arg [1] : 000000000000000000000000ab814ce69e15f6b9660a3b184c0b0c97b9394a6b
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [5] : 436572656272756d2044414f20546f6b656e0000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [7] : 4e4555524f4e0000000000000000000000000000000000000000000000000000

46796:4094:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49587:518;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47003:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13332:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15625:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14434:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16393:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14285:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48674:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45816:383;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14596:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13542:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49123:246;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;14919:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50446:82;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50238:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50625:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15164:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50807:80;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47130:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49587:518;49658:4;49675:13;49691:25;49675:41;;49794:13;49810:38;49794:54;;49949:13;49965:40;49949:56;;50039:6;50023:22;;;:12;:22;;;;:48;;;;50065:6;50049:22;;;:12;:22;;;;50023:48;:74;;;;50091:6;50075:22;;;:12;:22;;;;50023:74;50016:81;;;;;49587:518;;;:::o;47003:37::-;;;:::o;13332:91::-;13377:13;13410:5;13403:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13332:91;:::o;15625:190::-;15698:4;15715:13;15731:12;:10;:12::i;:::-;15715:28;;15754:31;15763:5;15770:7;15779:5;15754:8;:31::i;:::-;15803:4;15796:11;;;15625:190;;;;:::o;14434:99::-;14486:7;14513:12;;14506:19;;14434:99;:::o;16393:249::-;16480:4;16497:15;16515:12;:10;:12::i;:::-;16497:30;;16538:37;16554:4;16560:7;16569:5;16538:15;:37::i;:::-;16586:26;16596:4;16602:2;16606:5;16586:9;:26::i;:::-;16630:4;16623:11;;;16393:249;;;;;:::o;14285:84::-;14334:5;14359:2;14352:9;;14285:84;:::o;48674:240::-;47860:6;47846:20;;:10;:20;;;47838:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;48853:19:::1;48859:3;48864:7;48853:5;:19::i;:::-;48893:3;48888:18;;;48898:7;48888:18;;;;;;:::i;:::-;;;;;;;;48674:240:::0;;:::o;45816:383::-;45856:13;45966:31;45983:13;45966:16;:31::i;:::-;46046;46063:13;46046:16;:31::i;:::-;46126;46143:13;46126:16;:31::i;:::-;45927:249;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45882:309;;45816:383;:::o;14596:118::-;14661:7;14688:9;:18;14698:7;14688:18;;;;;;;;;;;;;;;;14681:25;;14596:118;;;:::o;13542:95::-;13589:13;13622:7;13615:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13542:95;:::o;49123:246::-;47860:6;47846:20;;:10;:20;;;47838:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;49304:21:::1;49310:5;49317:7;49304:5;:21::i;:::-;49346:5;49341:20;;;49353:7;49341:20;;;;;;:::i;:::-;;;;;;;;49123:246:::0;;:::o;14919:182::-;14988:4;15005:13;15021:12;:10;:12::i;:::-;15005:28;;15044:27;15054:5;15061:2;15065:5;15044:9;:27::i;:::-;15089:4;15082:11;;;14919:182;;;;:::o;50446:82::-;50487:7;50514:6;50507:13;;50446:82;:::o;50238:87::-;50278:7;50305:12;50298:19;;50238:87;:::o;50625:91::-;50669:7;50696:12;50689:19;;50625:91;:::o;15164:142::-;15244:7;15271:11;:18;15283:5;15271:18;;;;;;;;;;;;;;;:27;15290:7;15271:27;;;;;;;;;;;;;;;;15264:34;;15164:142;;;;:::o;50807:80::-;50846:7;50873:6;50866:13;;50807:80;:::o;47130:31::-;;;:::o;4337:98::-;4390:7;4417:10;4410:17;;4337:98;:::o;20452:130::-;20537:37;20546:5;20553:7;20562:5;20569:4;20537:8;:37::i;:::-;20452:130;;;:::o;22168:487::-;22268:24;22295:25;22305:5;22312:7;22295:9;:25::i;:::-;22268:52;;22355:17;22335:16;:37;22331:317;;22412:5;22393:16;:24;22389:132;;;22472:7;22481:16;22499:5;22445:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;22389:132;22564:57;22573:5;22580:7;22608:5;22589:16;:24;22615:5;22564:8;:57::i;:::-;22331:317;22257:398;22168:487;;;:::o;17027:308::-;17127:1;17111:18;;:4;:18;;;17107:88;;17180:1;17153:30;;;;;;;;;;;:::i;:::-;;;;;;;;17107:88;17223:1;17209:16;;:2;:16;;;17205:88;;17278:1;17249:32;;;;;;;;;;;:::i;:::-;;;;;;;;17205:88;17303:24;17311:4;17317:2;17321:5;17303:7;:24::i;:::-;17027:308;;;:::o;19147:213::-;19237:1;19218:21;;:7;:21;;;19214:93;;19292:1;19263:32;;;;;;;;;;;:::i;:::-;;;;;;;;19214:93;19317:35;19333:1;19337:7;19346:5;19317:7;:35::i;:::-;19147:213;;:::o;42215:718::-;42271:13;42322:14;42359:1;42339:17;42350:5;42339:10;:17::i;:::-;:21;42322:38;;42375:20;42409:6;42398:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42375:41;;42431:11;42560:6;42556:2;42552:15;42544:6;42540:28;42533:35;;42597:290;42604:4;42597:290;;;42629:5;;;;;;;;42771:10;42766:2;42759:5;42755:14;42750:32;42745:3;42737:46;42829:2;42820:11;;;;;;:::i;:::-;;;;;42863:1;42854:5;:10;42597:290;42850:21;42597:290;42908:6;42901:13;;;;;42215:718;;;:::o;19688:211::-;19778:1;19759:21;;:7;:21;;;19755:91;;19831:1;19804:30;;;;;;;;;;;:::i;:::-;;;;;;;;19755:91;19856:35;19864:7;19881:1;19885:5;19856:7;:35::i;:::-;19688:211;;:::o;21433:443::-;21563:1;21546:19;;:5;:19;;;21542:91;;21618:1;21589:32;;;;;;;;;;;:::i;:::-;;;;;;;;21542:91;21666:1;21647:21;;:7;:21;;;21643:92;;21720:1;21692:31;;;;;;;;;;;:::i;:::-;;;;;;;;21643:92;21775:5;21745:11;:18;21757:5;21745:18;;;;;;;;;;;;;;;:27;21764:7;21745:27;;;;;;;;;;;;;;;:35;;;;21795:9;21791:78;;;21842:7;21826:31;;21835:5;21826:31;;;21851:5;21826:31;;;;;;:::i;:::-;;;;;;;;21791:78;21433:443;;;;:::o;17659:1135::-;17765:1;17749:18;;:4;:18;;;17745:552;;17903:5;17887:12;;:21;;;;;;;:::i;:::-;;;;;;;;17745:552;;;17941:19;17963:9;:15;17973:4;17963:15;;;;;;;;;;;;;;;;17941:37;;18011:5;17997:11;:19;17993:117;;;18069:4;18075:11;18088:5;18044:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;17993:117;18265:5;18251:11;:19;18233:9;:15;18243:4;18233:15;;;;;;;;;;;;;;;:37;;;;17926:371;17745:552;18327:1;18313:16;;:2;:16;;;18309:435;;18495:5;18479:12;;:21;;;;;;;;;;;18309:435;;;18712:5;18695:9;:13;18705:2;18695:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;18309:435;18776:2;18761:25;;18770:4;18761:25;;;18780:5;18761:25;;;;;;:::i;:::-;;;;;;;;17659:1135;;;:::o;37279:948::-;37332:7;37352:14;37369:1;37352:18;;37419:8;37410:5;:17;37406:106;;37457:8;37448:17;;;;;;:::i;:::-;;;;;37494:2;37484:12;;;;37406:106;37539:8;37530:5;:17;37526:106;;37577:8;37568:17;;;;;;:::i;:::-;;;;;37614:2;37604:12;;;;37526:106;37659:8;37650:5;:17;37646:106;;37697:8;37688:17;;;;;;:::i;:::-;;;;;37734:2;37724:12;;;;37646:106;37779:7;37770:5;:16;37766:103;;37816:7;37807:16;;;;;;:::i;:::-;;;;;37852:1;37842:11;;;;37766:103;37896:7;37887:5;:16;37883:103;;37933:7;37924:16;;;;;;:::i;:::-;;;;;37969:1;37959:11;;;;37883:103;38013:7;38004:5;:16;38000:103;;38050:7;38041:16;;;;;;:::i;:::-;;;;;38086:1;38076:11;;;;38000:103;38130:7;38121:5;:16;38117:68;;38168:1;38158:11;;;;38117:68;38213:6;38206:13;;;37279:948;;;:::o;88:117:1:-;197:1;194;187:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:126::-;1555:7;1595:42;1588:5;1584:54;1573:65;;1518:126;;;:::o;1650:96::-;1687:7;1716:24;1734:5;1716:24;:::i;:::-;1705:35;;1650:96;;;:::o;1752:118::-;1839:24;1857:5;1839:24;:::i;:::-;1834:3;1827:37;1752:118;;:::o;1876:222::-;1969:4;2007:2;1996:9;1992:18;1984:26;;2020:71;2088:1;2077:9;2073:17;2064:6;2020:71;:::i;:::-;1876:222;;;;:::o;2104:99::-;2156:6;2190:5;2184:12;2174:22;;2104:99;;;:::o;2209:169::-;2293:11;2327:6;2322:3;2315:19;2367:4;2362:3;2358:14;2343:29;;2209:169;;;;:::o;2384:246::-;2465:1;2475:113;2489:6;2486:1;2483:13;2475:113;;;2574:1;2569:3;2565:11;2559:18;2555:1;2550:3;2546:11;2539:39;2511:2;2508:1;2504:10;2499:15;;2475:113;;;2622:1;2613:6;2608:3;2604:16;2597:27;2446:184;2384:246;;;:::o;2636:102::-;2677:6;2728:2;2724:7;2719:2;2712:5;2708:14;2704:28;2694:38;;2636:102;;;:::o;2744:377::-;2832:3;2860:39;2893:5;2860:39;:::i;:::-;2915:71;2979:6;2974:3;2915:71;:::i;:::-;2908:78;;2995:65;3053:6;3048:3;3041:4;3034:5;3030:16;2995:65;:::i;:::-;3085:29;3107:6;3085:29;:::i;:::-;3080:3;3076:39;3069:46;;2836:285;2744:377;;;;:::o;3127:313::-;3240:4;3278:2;3267:9;3263:18;3255:26;;3327:9;3321:4;3317:20;3313:1;3302:9;3298:17;3291:47;3355:78;3428:4;3419:6;3355:78;:::i;:::-;3347:86;;3127:313;;;;:::o;3446:122::-;3519:24;3537:5;3519:24;:::i;:::-;3512:5;3509:35;3499:63;;3558:1;3555;3548:12;3499:63;3446:122;:::o;3574:139::-;3620:5;3658:6;3645:20;3636:29;;3674:33;3701:5;3674:33;:::i;:::-;3574:139;;;;:::o;3719:77::-;3756:7;3785:5;3774:16;;3719:77;;;:::o;3802:122::-;3875:24;3893:5;3875:24;:::i;:::-;3868:5;3865:35;3855:63;;3914:1;3911;3904:12;3855:63;3802:122;:::o;3930:139::-;3976:5;4014:6;4001:20;3992:29;;4030:33;4057:5;4030:33;:::i;:::-;3930:139;;;;:::o;4075:474::-;4143:6;4151;4200:2;4188:9;4179:7;4175:23;4171:32;4168:119;;;4206:79;;:::i;:::-;4168:119;4326:1;4351:53;4396:7;4387:6;4376:9;4372:22;4351:53;:::i;:::-;4341:63;;4297:117;4453:2;4479:53;4524:7;4515:6;4504:9;4500:22;4479:53;:::i;:::-;4469:63;;4424:118;4075:474;;;;;:::o;4555:118::-;4642:24;4660:5;4642:24;:::i;:::-;4637:3;4630:37;4555:118;;:::o;4679:222::-;4772:4;4810:2;4799:9;4795:18;4787:26;;4823:71;4891:1;4880:9;4876:17;4867:6;4823:71;:::i;:::-;4679:222;;;;:::o;4907:619::-;4984:6;4992;5000;5049:2;5037:9;5028:7;5024:23;5020:32;5017:119;;;5055:79;;:::i;:::-;5017:119;5175:1;5200:53;5245:7;5236:6;5225:9;5221:22;5200:53;:::i;:::-;5190:63;;5146:117;5302:2;5328:53;5373:7;5364:6;5353:9;5349:22;5328:53;:::i;:::-;5318:63;;5273:118;5430:2;5456:53;5501:7;5492:6;5481:9;5477:22;5456:53;:::i;:::-;5446:63;;5401:118;4907:619;;;;;:::o;5532:86::-;5567:7;5607:4;5600:5;5596:16;5585:27;;5532:86;;;:::o;5624:112::-;5707:22;5723:5;5707:22;:::i;:::-;5702:3;5695:35;5624:112;;:::o;5742:214::-;5831:4;5869:2;5858:9;5854:18;5846:26;;5882:67;5946:1;5935:9;5931:17;5922:6;5882:67;:::i;:::-;5742:214;;;;:::o;5962:329::-;6021:6;6070:2;6058:9;6049:7;6045:23;6041:32;6038:119;;;6076:79;;:::i;:::-;6038:119;6196:1;6221:53;6266:7;6257:6;6246:9;6242:22;6221:53;:::i;:::-;6211:63;;6167:117;5962:329;;;;:::o;6297:474::-;6365:6;6373;6422:2;6410:9;6401:7;6397:23;6393:32;6390:119;;;6428:79;;:::i;:::-;6390:119;6548:1;6573:53;6618:7;6609:6;6598:9;6594:22;6573:53;:::i;:::-;6563:63;;6519:117;6675:2;6701:53;6746:7;6737:6;6726:9;6722:22;6701:53;:::i;:::-;6691:63;;6646:118;6297:474;;;;;:::o;6777:180::-;6825:77;6822:1;6815:88;6922:4;6919:1;6912:15;6946:4;6943:1;6936:15;6963:320;7007:6;7044:1;7038:4;7034:12;7024:22;;7091:1;7085:4;7081:12;7112:18;7102:81;;7168:4;7160:6;7156:17;7146:27;;7102:81;7230:2;7222:6;7219:14;7199:18;7196:38;7193:84;;7249:18;;:::i;:::-;7193:84;7014:269;6963:320;;;:::o;7289:239::-;7429:34;7425:1;7417:6;7413:14;7406:58;7498:22;7493:2;7485:6;7481:15;7474:47;7289:239;:::o;7534:366::-;7676:3;7697:67;7761:2;7756:3;7697:67;:::i;:::-;7690:74;;7773:93;7862:3;7773:93;:::i;:::-;7891:2;7886:3;7882:12;7875:19;;7534:366;;;:::o;7906:419::-;8072:4;8110:2;8099:9;8095:18;8087:26;;8159:9;8153:4;8149:20;8145:1;8134:9;8130:17;8123:47;8187:131;8313:4;8187:131;:::i;:::-;8179:139;;7906:419;;;:::o;8331:148::-;8433:11;8470:3;8455:18;;8331:148;;;;:::o;8485:390::-;8591:3;8619:39;8652:5;8619:39;:::i;:::-;8674:89;8756:6;8751:3;8674:89;:::i;:::-;8667:96;;8772:65;8830:6;8825:3;8818:4;8811:5;8807:16;8772:65;:::i;:::-;8862:6;8857:3;8853:16;8846:23;;8595:280;8485:390;;;;:::o;8881:151::-;9021:3;9017:1;9009:6;9005:14;8998:27;8881:151;:::o;9038:400::-;9198:3;9219:84;9301:1;9296:3;9219:84;:::i;:::-;9212:91;;9312:93;9401:3;9312:93;:::i;:::-;9430:1;9425:3;9421:11;9414:18;;9038:400;;;:::o;9444:1127::-;9874:3;9896:95;9987:3;9978:6;9896:95;:::i;:::-;9889:102;;10008:148;10152:3;10008:148;:::i;:::-;10001:155;;10173:95;10264:3;10255:6;10173:95;:::i;:::-;10166:102;;10285:148;10429:3;10285:148;:::i;:::-;10278:155;;10450:95;10541:3;10532:6;10450:95;:::i;:::-;10443:102;;10562:3;10555:10;;9444:1127;;;;;;:::o;10577:442::-;10726:4;10764:2;10753:9;10749:18;10741:26;;10777:71;10845:1;10834:9;10830:17;10821:6;10777:71;:::i;:::-;10858:72;10926:2;10915:9;10911:18;10902:6;10858:72;:::i;:::-;10940;11008:2;10997:9;10993:18;10984:6;10940:72;:::i;:::-;10577:442;;;;;;:::o;11025:180::-;11073:77;11070:1;11063:88;11170:4;11167:1;11160:15;11194:4;11191:1;11184:15;11211:180;11259:77;11256:1;11249:88;11356:4;11353:1;11346:15;11380:4;11377:1;11370:15;11397:180;11445:77;11442:1;11435:88;11542:4;11539:1;11532:15;11566:4;11563:1;11556:15;11583:191;11623:3;11642:20;11660:1;11642:20;:::i;:::-;11637:25;;11676:20;11694:1;11676:20;:::i;:::-;11671:25;;11719:1;11716;11712:9;11705:16;;11740:3;11737:1;11734:10;11731:36;;;11747:18;;:::i;:::-;11731:36;11583:191;;;;:::o

ipfs://038c84efa2574052ae9ed8a99fbee200dd9cc9ba3c559da35e8e3d601003200a