Token USDC

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";
import "./SafeMath.sol";

contract ChildERC20 is ERC20 {
    using SafeMath for uint256;

    address public childChainManagerProxy;
    address deployer;

    constructor (
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        address _childChainManagerProxy
    ) ERC20(name_, symbol_, decimals_) {
        childChainManagerProxy = _childChainManagerProxy;
        deployer = msg.sender;
    }

    function updateChildChainManager(address newChildChainManagerProxy) external {
        require(newChildChainManagerProxy != address(0), "Bad ChildChainManagerProxy address");
        require(msg.sender == deployer, "You're not allowed");

        childChainManagerProxy = newChildChainManagerProxy;
    }

    function deposit(address user, bytes calldata depositData) external {
        require(msg.sender == childChainManagerProxy, "You're not allowed to deposit");

        uint256 amount = abi.decode(depositData, (uint256));

        // `amount` token getting minted here & equal amount got locked in RootChainManager
        _totalSupply = _totalSupply.add(amount);
        _balances[user] = _balances[user].add(amount);

        emit Transfer(address(0), user, amount);
    }

    function withdraw(uint256 amount) external {
        _balances[msg.sender] = _balances[msg.sender].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);

        emit Transfer(msg.sender, address(0), amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Context.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 {ERC20PresetMinterPauser}.
 *
 * 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 {
    mapping (address => uint256) public _balances;

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

    uint256 public _totalSupply;

    string public _name;
    string public _symbol;
    uint8 public _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_, uint8 decimals_) {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }

    /**
     * @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 value {ERC20} uses, unless this function is
     * overloaded;
     *
     * 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 _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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.
     */
    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);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - amount);

        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] + 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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

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

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += 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 += amount;
        _balances[account] += amount;
        emit Transfer(address(0), 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);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    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 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:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"address","name":"_childChainManagerProxy","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"_allowances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":[],"name":"childChainManagerProxy","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":"user","type":"address"},{"internalType":"bytes","name":"depositData","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":"newChildChainManagerProxy","type":"address"}],"name":"updateChildChainManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

106:1464:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1361:68:2;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2082:89;;;:::i;:::-;;;;;;;:::i;4159:166::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3150:106::-;;;:::i;4792:414::-;;;;;;:::i;:::-;;:::i;1308:260:0:-;;;;;;:::i;:::-;;:::i;:::-;;3001:89:2;;;:::i;:::-;;;;;;;:::i;1522:22::-;;;:::i;5601:212::-;;;;;;:::i;:::-;;:::i;1436:27::-;;;:::i;520:304:0:-;;;;;;:::i;:::-;;:::i;174:37::-;;;:::i;:::-;;;;;;;:::i;1309:45:2:-;;;;;;:::i;:::-;;:::i;3314:125::-;;;;;;:::i;:::-;;:::i;2284:93::-;;;:::i;6300:371::-;;;;;;:::i;:::-;;:::i;3642:172::-;;;;;;:::i;:::-;;:::i;1495:21::-;;;:::i;830:472:0:-;;;;;;:::i;:::-;;:::i;1470:19:2:-;;;:::i;3872:149::-;;;;;;:::i;:::-;;:::i;1361:68::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;2082:89::-;2127:13;2159:5;2152:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2082:89;:::o;4159:166::-;4242:4;4258:39;4267:12;:10;:12::i;:::-;4281:7;4290:6;4258:8;:39::i;:::-;-1:-1:-1;4314:4:2;4159:166;;;;:::o;3150:106::-;3237:12;;3150:106;:::o;4792:414::-;4898:4;4914:36;4924:6;4932:9;4943:6;4914:9;:36::i;:::-;-1:-1:-1;;;;;4988:19:2;;4961:24;4988:19;;;:11;:19;;;;;4961:24;5008:12;:10;:12::i;:::-;-1:-1:-1;;;;;4988:33:2;-1:-1:-1;;;;;4988:33:2;;;;;;;;;;;;;4961:60;;5059:6;5039:16;:26;;5031:79;;;;-1:-1:-1;;;5031:79:2;;;;;;;:::i;:::-;;;;;;;;;5120:57;5129:6;5137:12;:10;:12::i;:::-;5151:25;5170:6;5151:16;:25;:::i;:::-;5120:8;:57::i;:::-;-1:-1:-1;5195:4:2;;4792:414;-1:-1:-1;;;;4792:414:2:o;1308:260:0:-;1385:71;1411:6;1385:71;;;;;;;;;;;;;;;;;1395:10;1385:9;:21;;;;;;;;;;;;:71;:25;:71::i;:::-;1371:10;1361:9;:21;;;;;;;;;;:95;1481:12;;:24;;1498:6;1481:16;:24::i;:::-;1466:12;:39;1521:40;;1550:1;;1530:10;;1521:40;;;;1554:6;;1521:40;:::i;:::-;;;;;;;;1308:260;:::o;3001:89:2:-;3074:9;;;;3001:89;:::o;1522:22::-;;;;;;:::o;5601:212::-;5689:4;5705:80;5714:12;:10;:12::i;:::-;5728:7;5774:10;5737:11;:25;5749:12;:10;:12::i;:::-;-1:-1:-1;;;;;5737:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;5737:25:2;;;:34;;;;;;;;;;:47;;;;:::i;1436:27::-;;;;:::o;520:304:0:-;-1:-1:-1;;;;;615:39:0;;607:86;;;;-1:-1:-1;;;607:86:0;;;;;;;:::i;:::-;725:8;;-1:-1:-1;;;;;725:8:0;711:10;:22;703:53;;;;-1:-1:-1;;;703:53:0;;;;;;;:::i;:::-;767:22;:50;;-1:-1:-1;;;;;767:50:0;;;;;-1:-1:-1;;;;;;767:50:0;;;;;;;;;520:304::o;174:37::-;;;;;;-1:-1:-1;;;;;174:37:0;;:::o;1309:45:2:-;;;;;;;;;;;;;;:::o;3314:125::-;-1:-1:-1;;;;;3414:18:2;;3388:7;3414:18;;;;;;;;;;;3314:125;;;;:::o;2284:93::-;2331:13;2363:7;2356:14;;;;;:::i;6300:371::-;6393:4;6409:24;6436:11;:25;6448:12;:10;:12::i;:::-;-1:-1:-1;;;;;6436:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;6436:25:2;;;:34;;;;;;;;;;;-1:-1:-1;6488:35:2;;;;6480:85;;;;-1:-1:-1;;;6480:85:2;;;;;;;:::i;:::-;6575:67;6584:12;:10;:12::i;:::-;6598:7;6607:34;6626:15;6607:16;:34;:::i;6575:67::-;-1:-1:-1;6660:4:2;;6300:371;-1:-1:-1;;;6300:371:2:o;3642:172::-;3728:4;3744:42;3754:12;:10;:12::i;:::-;3768:9;3779:6;3744:9;:42::i;1495:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;830:472:0:-;930:22;;;;;-1:-1:-1;;;;;930:22:0;916:10;:36;908:78;;;;-1:-1:-1;;;908:78:0;;;;;;;:::i;:::-;997:14;1014:34;;;;1025:11;1014:34;:::i;:::-;1166:12;;997:51;;-1:-1:-1;1166:24:0;;997:51;1166:16;:24::i;:::-;1151:12;:39;-1:-1:-1;;;;;1218:15:0;;:9;:15;;;;;;;;;;;:27;;1238:6;1218:19;:27::i;:::-;-1:-1:-1;;;;;1200:15:0;;:9;:15;;;;;;;;;;;:45;;;;1261:34;;1200:15;;:9;1261:34;;;;1288:6;;1261:34;:::i;:::-;;;;;;;;830:472;;;;:::o;1470:19:2:-;;;;;;;:::i;3872:149::-;-1:-1:-1;;;;;3987:18:2;;;3961:7;3987:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3872:149::o;586:96:1:-;665:10;586:96;:::o;9564:340:2:-;-1:-1:-1;;;;;9665:19:2;;9657:68;;;;-1:-1:-1;;;9657:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;9743:21:2;;9735:68;;;;-1:-1:-1;;;9735:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;9814:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;9865:32;;;;;9844:6;;9865:32;:::i;:::-;;;;;;;;9564:340;;;:::o;7145:592::-;-1:-1:-1;;;;;7250:20:2;;7242:70;;;;-1:-1:-1;;;7242:70:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7330:23:2;;7322:71;;;;-1:-1:-1;;;7322:71:2;;;;;;;:::i;:::-;7404:47;7425:6;7433:9;7444:6;7404:20;:47::i;:::-;-1:-1:-1;;;;;7486:17:2;;7462:21;7486:17;;;;;;;;;;;7521:23;;;;7513:74;;;;-1:-1:-1;;;7513:74:2;;;;;;;:::i;:::-;7617:22;7633:6;7617:13;:22;:::i;:::-;-1:-1:-1;;;;;7597:17:2;;;:9;:17;;;;;;;;;;;:42;;;;7649:20;;;;;;;;:30;;7673:6;;7597:9;7649:30;;7673:6;;7649:30;:::i;:::-;;;;;;;;7712:9;-1:-1:-1;;;;;7695:35:2;7704:6;-1:-1:-1;;;;;7695:35:2;;7723:6;7695:35;;;;;;:::i;4876:201:4:-;4962:7;5021:12;5013:6;;;;5005:29;;;;-1:-1:-1;;;5005:29:4;;;;;;;;:::i;:::-;-1:-1:-1;;;5055:5:4;;;4876:201::o;3039:96::-;3097:7;3123:5;3127:1;3123;:5;:::i;:::-;3116:12;3039:96;-1:-1:-1;;;3039:96:4:o;2672:::-;2730:7;2756:5;2760:1;2756;:5;:::i;10491:92:2:-;;;;:::o;14:175:5:-;84:20;;-1:-1:-1;;;;;133:31:5;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:717::-;;;;1171:2;1159:9;1150:7;1146:23;1142:32;1139:2;;;1192:6;1184;1177:22;1139:2;1220:31;1241:9;1220:31;:::i;:::-;1210:41;;1302:2;1291:9;1287:18;1274:32;1325:18;1366:2;1358:6;1355:14;1352:2;;;1387:6;1379;1372:22;1352:2;1430:6;1419:9;1415:22;1405:32;;1475:7;1468:4;1464:2;1460:13;1456:27;1446:2;;1502:6;1494;1487:22;1446:2;1547;1534:16;1573:2;1565:6;1562:14;1559:2;;;1594:6;1586;1579:22;1559:2;1644:7;1639:2;1630:6;1626:2;1622:15;1618:24;1615:37;1612:2;;;1670:6;1662;1655:22;1612:2;1706;1702;1698:11;1688:21;;1728:6;1718:16;;;;;1129:611;;;;;:::o;1745:266::-;;;1874:2;1862:9;1853:7;1849:23;1845:32;1842:2;;;1895:6;1887;1880:22;1842:2;1923:31;1944:9;1923:31;:::i;:::-;1913:41;2001:2;1986:18;;;;1973:32;;-1:-1:-1;;;1832:179:5:o;2016:190::-;;2128:2;2116:9;2107:7;2103:23;2099:32;2096:2;;;2149:6;2141;2134:22;2096:2;-1:-1:-1;2177:23:5;;2086:120;-1:-1:-1;2086:120:5:o;2211:203::-;-1:-1:-1;;;;;2375:32:5;;;;2357:51;;2345:2;2330:18;;2312:102::o;2419:187::-;2584:14;;2577:22;2559:41;;2547:2;2532:18;;2514:92::o;2611:603::-;;2752:2;2781;2770:9;2763:21;2813:6;2807:13;2856:6;2851:2;2840:9;2836:18;2829:34;2881:4;2894:140;2908:6;2905:1;2902:13;2894:140;;;3003:14;;;2999:23;;2993:30;2969:17;;;2988:2;2965:26;2958:66;2923:10;;2894:140;;;3052:6;3049:1;3046:13;3043:2;;;3122:4;3117:2;3108:6;3097:9;3093:22;3089:31;3082:45;3043:2;-1:-1:-1;3198:2:5;3177:15;-1:-1:-1;;3173:29:5;3158:45;;;;3205:2;3154:54;;2732:482;-1:-1:-1;;;2732:482:5:o;3219:399::-;3421:2;3403:21;;;3460:2;3440:18;;;3433:30;3499:34;3494:2;3479:18;;3472:62;-1:-1:-1;;;3565:2:5;3550:18;;3543:33;3608:3;3593:19;;3393:225::o;3623:398::-;3825:2;3807:21;;;3864:2;3844:18;;;3837:30;3903:34;3898:2;3883:18;;3876:62;-1:-1:-1;;;3969:2:5;3954:18;;3947:32;4011:3;3996:19;;3797:224::o;4026:353::-;4228:2;4210:21;;;4267:2;4247:18;;;4240:30;4306:31;4301:2;4286:18;;4279:59;4370:2;4355:18;;4200:179::o;4384:398::-;4586:2;4568:21;;;4625:2;4605:18;;;4598:30;4664:34;4659:2;4644:18;;4637:62;-1:-1:-1;;;4730:2:5;4715:18;;4708:32;4772:3;4757:19;;4558:224::o;4787:342::-;4989:2;4971:21;;;5028:2;5008:18;;;5001:30;-1:-1:-1;;;5062:2:5;5047:18;;5040:48;5120:2;5105:18;;4961:168::o;5134:402::-;5336:2;5318:21;;;5375:2;5355:18;;;5348:30;5414:34;5409:2;5394:18;;5387:62;-1:-1:-1;;;5480:2:5;5465:18;;5458:36;5526:3;5511:19;;5308:228::o;5541:404::-;5743:2;5725:21;;;5782:2;5762:18;;;5755:30;5821:34;5816:2;5801:18;;5794:62;-1:-1:-1;;;5887:2:5;5872:18;;5865:38;5935:3;5920:19;;5715:230::o;5950:401::-;6152:2;6134:21;;;6191:2;6171:18;;;6164:30;6230:34;6225:2;6210:18;;6203:62;-1:-1:-1;;;6296:2:5;6281:18;;6274:35;6341:3;6326:19;;6124:227::o;6356:400::-;6558:2;6540:21;;;6597:2;6577:18;;;6570:30;6636:34;6631:2;6616:18;;6609:62;-1:-1:-1;;;6702:2:5;6687:18;;6680:34;6746:3;6731:19;;6530:226::o;6761:401::-;6963:2;6945:21;;;7002:2;6982:18;;;6975:30;7041:34;7036:2;7021:18;;7014:62;-1:-1:-1;;;7107:2:5;7092:18;;7085:35;7152:3;7137:19;;6935:227::o;7167:177::-;7313:25;;;7301:2;7286:18;;7268:76::o;7349:184::-;7521:4;7509:17;;;;7491:36;;7479:2;7464:18;;7446:87::o;7538:128::-;;7609:1;7605:6;7602:1;7599:13;7596:2;;;7615:18;;:::i;:::-;-1:-1:-1;7651:9:5;;7586:80::o;7671:125::-;;7739:1;7736;7733:8;7730:2;;;7744:18;;:::i;:::-;-1:-1:-1;7781:9:5;;7720:76::o;7801:380::-;7886:1;7876:12;;7933:1;7923:12;;;7944:2;;7998:4;7990:6;7986:17;7976:27;;7944:2;8051;8043:6;8040:14;8020:18;8017:38;8014:2;;;8097:10;8092:3;8088:20;8085:1;8078:31;8132:4;8129:1;8122:15;8160:4;8157:1;8150:15;8014:2;;7856:325;;;:::o;8186:127::-;8247:10;8242:3;8238:20;8235:1;8228:31;8278:4;8275:1;8268:15;8302:4;8299:1;8292:15

ipfs://af388a3e940856fd96af80344170fa8ed717ab431a5e26bfd805e12e8d32f5c6