Source Code
Overview
ETH Balance
0.0951 ETH
Token Holdings
More Info
ContractCreator
Multichain Info
N/A
Latest 25 from a total of 94 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Deposit ERC20To | 6460749 | 182 days ago | IN | 0 ETH | 0.00246103 | ||||
Deposit Native T... | 6460743 | 182 days ago | IN | 0.02 ETH | 0.00096858 | ||||
Deposit Native T... | 6459761 | 182 days ago | IN | 0.01 ETH | 0.00042053 | ||||
Deposit Native T... | 6459159 | 182 days ago | IN | 0.001 ETH | 0.00018487 | ||||
Deposit Native T... | 6454260 | 183 days ago | IN | 0.0001 ETH | 0.00110712 | ||||
Deposit Native T... | 6454247 | 183 days ago | IN | 0.001 ETH | 0.0013923 | ||||
Deposit Native T... | 6454151 | 183 days ago | IN | 0.01 ETH | 0.00274342 | ||||
Deposit Native T... | 6454106 | 183 days ago | IN | 0.01 ETH | 0.00368039 | ||||
Deposit ERC20To | 6453983 | 183 days ago | IN | 0 ETH | 0.00168697 | ||||
With Draw Native | 6453835 | 183 days ago | IN | 0 ETH | 0.00101906 | ||||
Deposit Native T... | 6453828 | 183 days ago | IN | 0.02 ETH | 0.00076162 | ||||
With Draw Native | 6453810 | 183 days ago | IN | 0 ETH | 0.00106215 | ||||
Deposit Native T... | 6453801 | 183 days ago | IN | 0.01 ETH | 0.00079236 | ||||
With Draw Native | 6453739 | 183 days ago | IN | 0 ETH | 0.0021132 | ||||
Deposit Native T... | 6453733 | 183 days ago | IN | 0.01 ETH | 0.00134404 | ||||
With Draw Native | 6453680 | 183 days ago | IN | 0 ETH | 0.00095011 | ||||
With Draw Native | 6453618 | 183 days ago | IN | 0 ETH | 0.00101754 | ||||
Deposit Native T... | 6453610 | 183 days ago | IN | 0.01 ETH | 0.00070001 | ||||
Deposit Native T... | 6453545 | 183 days ago | IN | 0.01 ETH | 0.00097453 | ||||
With Draw Native | 6453273 | 183 days ago | IN | 0 ETH | 0.00172337 | ||||
Deposit Native T... | 6453041 | 183 days ago | IN | 0.01 ETH | 0.0005326 | ||||
Deposit ERC20To | 6452815 | 183 days ago | IN | 0 ETH | 0.00141947 | ||||
Deposit Native T... | 6452495 | 183 days ago | IN | 0.001 ETH | 0.00032825 | ||||
Deposit Native T... | 6452349 | 183 days ago | IN | 0.01 ETH | 0.00052706 | ||||
Deposit Native T... | 6448606 | 183 days ago | IN | 0.01 ETH | 0.00052507 |
Latest 12 internal transactions
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
6453835 | 183 days ago | 0.02 ETH | ||||
6453810 | 183 days ago | 0.02 ETH | ||||
6453739 | 183 days ago | 0.02 ETH | ||||
6453680 | 183 days ago | 0.01 ETH | ||||
6453618 | 183 days ago | 0.03 ETH | ||||
6453273 | 183 days ago | 0.01 ETH | ||||
6448256 | 184 days ago | 0.01 ETH | ||||
6446084 | 184 days ago | 0.01 ETH | ||||
6446064 | 184 days ago | 0.01 ETH | ||||
6441800 | 185 days ago | 0.001 ETH | ||||
6441370 | 185 days ago | 0.01 ETH | ||||
6377607 | 195 days ago | 0.01 ETH |
Loading...
Loading
Contract Name:
L1StandardBridge
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-08-01 */ // SPDX-License-Identifier: MIT // File: Bridge/IERC20.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.19; /** * @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: * * 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: Bridge/IERC20Metadata.sol pragma solidity ^0.8.19; /** * @dev Interface for the optional metadata functions from the ERC-20 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: Bridge/Context.sol // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) pragma solidity ^0.8.15; /** * @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: Bridge/draft-IERC6093.sol // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.15; 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 ERC-721 Errors */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-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 ERC-1155 Errors */ 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: Bridge/ERC20.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.19; /** * @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}. * * 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 => uint256) private _balances; mapping(address => mapping(address => 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); } } } } contract L1Token is ERC20{ constructor(string memory _name, string memory _symbol) ERC20(_name,_symbol) { } function mint(address to, uint amount) public { _mint(to, amount); } } // File: Bridge/IERC165.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.19; /** * @dev Interface of the ERC165 standard * 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 * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: Bridge/ICatenaMintableERC20.sol pragma solidity ^0.8.0; /// @title ICatenaMintableERC20 /// @notice This interface is available on the ICatenaMintableERC20 contract. /// We declare it as a separate interface so that it can be used in /// custom implementations of ICatenaMintableERC20. interface ICatenaMintableERC20 is IERC165 { function bridge() external returns (address); function mint(address _to, uint256 _amount) external; function burn(address _from, uint256 _amount) external; } // File: Bridge/CatenaMintableERC20.sol pragma solidity ^0.8.19; /// @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 CatenaMintableERC20 is ICatenaMintableERC20, ERC20 { address public OWNER; /// @notice Address of the StandardBridge on this network. address private BRIDGE; /// @notice Decimals of the token uint8 private immutable DECIMALS; /// @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, "CatenaMintableERC20: only bridge can mint and burn"); _; } modifier onlyOwner(){ require(msg.sender == OWNER, " Only Owner Can Do This"); _; } // modifier onlyBridgeOwner() { // require(msg.sender == BRIDGE.owner, "Only Bridge Owner Can Call This Function."); // _; // } constructor( string memory _name, string memory _symbol, uint8 _decimals ) ERC20(_name, _symbol) { DECIMALS = _decimals; OWNER = msg.sender; } /// @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(ICatenaMintableERC20) 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(ICatenaMintableERC20) onlyBridge { _burn(_from, _amount); emit Burn(_from, _amount); } function setBridge(address _bridge) public onlyOwner { BRIDGE = _bridge; } /// @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 view virtual returns (bool) { bytes4 iface1 = type(IERC165).interfaceId; // Interface corresponding to the legacy L2StandardERC20. // Interface corresponding to the updated OptimismMintableERC20 (this contract). bytes4 iface3 = type(ICatenaMintableERC20).interfaceId; return _interfaceId == iface1 || _interfaceId == iface3; } /// @custom:legacy /// @notice Legacy getter for BRIDGE. function bridge() public view returns (address) { return BRIDGE; } /// @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`). /// 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 override returns (uint8) { return DECIMALS; } } // File: Bridge/ERC165Checker.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165Checker.sol) pragma solidity ^0.8.15; /** * @dev Library used to query support of an interface declared via {IERC165}. * * Note that these functions return the actual result of the query: they do not * `revert` if an interface is not supported. It is up to the caller to decide * what to do in these cases. */ library ERC165Checker { // As per the EIP-165 spec, no interface should ever match 0xffffffff bytes4 private constant INTERFACE_ID_INVALID = 0xffffffff; /** * @dev Returns true if `account` supports the {IERC165} interface. */ function supportsERC165(address account) internal view returns (bool) { // Any contract that implements ERC165 must explicitly indicate support of // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid return supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) && !supportsERC165InterfaceUnchecked(account, INTERFACE_ID_INVALID); } /** * @dev Returns true if `account` supports the interface defined by * `interfaceId`. Support for {IERC165} itself is queried automatically. * * See {IERC165-supportsInterface}. */ function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) { // query support of both ERC165 as per the spec and support of _interfaceId return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId); } /** * @dev Returns a boolean array where each value corresponds to the * interfaces passed in and whether they're supported or not. This allows * you to batch check interfaces for a contract where your expectation * is that some interfaces may not be supported. * * See {IERC165-supportsInterface}. */ function getSupportedInterfaces( address account, bytes4[] memory interfaceIds ) internal view returns (bool[] memory) { // an array of booleans corresponding to interfaceIds and whether they're supported or not bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length); // query support of ERC165 itself if (supportsERC165(account)) { // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]); } } return interfaceIdsSupported; } /** * @dev Returns true if `account` supports all the interfaces defined in * `interfaceIds`. Support for {IERC165} itself is queried automatically. * * Batch-querying can lead to gas savings by skipping repeated checks for * {IERC165} support. * * See {IERC165-supportsInterface}. */ function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) { // query support of ERC165 itself if (!supportsERC165(account)) { return false; } // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) { return false; } } // all interfaces supported return true; } /** * @notice Query if a contract implements an interface, does not check ERC165 support * @param account The address of the contract to query for support of an interface * @param interfaceId The interface identifier, as specified in ERC-165 * @return true if the contract at account indicates support of the interface with * identifier interfaceId, false otherwise * @dev Assumes that account contains a contract that supports ERC165, otherwise * the behavior of this method is undefined. This precondition can be checked * with {supportsERC165}. * * Some precompiled contracts will falsely indicate support for a given interface, so caution * should be exercised when using this function. * * Interface identification is specified in ERC-165. */ function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) { // prepare call bytes memory encodedParams = abi.encodeCall(IERC165.supportsInterface, (interfaceId)); // perform static call bool success; uint256 returnSize; uint256 returnValue; assembly { success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20) returnSize := returndatasize() returnValue := mload(0x00) } return success && returnSize >= 0x20 && returnValue > 0; } } // File: Bridge/IERC20Permit.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.19; /** * * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * ==== Security Considerations * * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be * considered as an intention to spend the allowance in any specific way. The second is that because permits have * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be * generally recommended is: * * ```solidity * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public { * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {} * doThing(..., value); * } * * function doThing(..., uint256 value) public { * token.safeTransferFrom(msg.sender, address(this), value); * ... * } * ``` * * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also * {SafeERC20-safeTransferFrom}). * * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so * contracts should have entry points that don't rely on permit. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * CAUTION: See Security Considerations above. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: Bridge/Address.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: Bridge/SafeERC20.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.19; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev An operation with an ERC20 token failed. */ error SafeERC20FailedOperation(address token); /** * @dev Indicates a failed `decreaseAllowance` request. */ error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease); /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value))); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value))); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); forceApprove(token, spender, oldAllowance + value); } /** * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no * value, non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal { unchecked { uint256 currentAllowance = token.allowance(address(this), spender); if (currentAllowance < requestedDecrease) { revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease); } forceApprove(token, spender, currentAllowance - requestedDecrease); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval * to be set to zero before setting it to a non-zero value, such as USDT. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value)); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0))); _callOptionalReturn(token, approvalCall); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data); if (returndata.length != 0 && !abi.decode(returndata, (bool))) { revert SafeERC20FailedOperation(address(token)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0; } } // File: Bridge/StandardBridge.sol pragma solidity ^0.8.19; error StandardBridge__TokenAlreadHavePair(); error StandardBridge__ZeroAddressNotAllowed(); error OwnableInvalidOwner(address owner); error AlreadyOwner(); abstract contract StandardBridge { struct TokenPair{ address localToken; address remoteToken; bool isActive; } using SafeERC20 for IERC20; address public owner; mapping(address localToken => address remoteToken) internal localToRemote; mapping(address remoteToken => address localToken) internal remoteToLocal; mapping(address token => mapping(address remoteToken => bool)) internal initializedPair; mapping(address localToken => TokenPair) internal isPairActive; TokenPair[] internal tokenPairs; event NativeBridgeInitiated( address indexed from, address indexed to, uint256 amount ); event NativeBridgeFinalized( address indexed from, address indexed to, uint256 amount ); event ERC20BridgeInitiated( address indexed localToken, address indexed remoteToken, address indexed from, address to, uint256 amount ); event ERC20BridgeFinalized( address indexed localToken, address indexed remoteToken, address indexed from, address to, uint256 amount ); event ERC20TokenPairSet( address indexed localToken, address indexed remoteToken, bool indexed active ); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); mapping(address => mapping(address => uint256)) private deposits; modifier onlyOwner() { require(msg.sender == owner, "Only Owner Can Call this Function"); _; } modifier onlyPairs(address _localToken,address _remoteToken){ require(initializedPair[_localToken][_remoteToken] , "Token Pair Does'nt exist"); _; } function setPairs(address _localToken, address _remoteToken) public virtual onlyOwner { require(_localToken != _remoteToken , "LocalToken == RemoteToken"); require(localToRemote[_localToken] == address(0) && remoteToLocal[_remoteToken] == address(0), "Local Token is paired already"); require(remoteToLocal[_localToken] == address(0) && localToRemote[_remoteToken] == address(0), "Remote Token is paired already"); // Set the pairs localToRemote[_localToken] = _remoteToken; remoteToLocal[_remoteToken] = _localToken; initializedPair[_localToken][_remoteToken] = true; TokenPair storage tp = isPairActive[_localToken]; tp.localToken = _localToken; tp.remoteToken = _remoteToken; tp.isActive = true; tokenPairs.push(tp); emit ERC20TokenPairSet(_localToken,_remoteToken,tp.isActive); } function finalizeBridgeERC20( address _localToken, address _remoteToken, address _from, address _to, uint256 _amount ) internal { if (_isCatenaMintableERC20(_localToken)) { require( _isCorrectTokenPair(_localToken, _remoteToken), "StandardBridge: wrong remote token for Catena Mintable ERC20 local token" ); CatenaMintableERC20(_localToken).mint(_to, _amount); } else { deposits[_localToken][_remoteToken] = deposits[_localToken][_remoteToken] - _amount; IERC20(_localToken).safeTransfer(_to, _amount); } _emitERC20BridgeFinalized(_localToken, _remoteToken, _from, _to, _amount); } function finalizeBridgeNative( address _localToken, address _from, address _to, uint256 _amount ) internal { require(_to != address(this), "StandardBridge: cannot send to self"); if (_isCatenaMintableERC20(_localToken)) { require( _isCorrectTokenPair(_localToken, address(0)), "StandardBridge: wrong remote token for Catena Mintable ERC20 local token" ); CatenaMintableERC20(_localToken).mint(_to, _amount); } else { require(address(this).balance >= _amount, "Contract Cannot Have Enough Balance"); (bool success,) = _to.call{ value: _amount}(""); require(success, "Native withdraw Failed"); } _emitNativeBridgeFinalized(_from, _to, _amount); } function _initiateBridgeERC20L1( address _localToken, address _remoteToken, address _from, address _to, uint256 _amount ) internal { IERC20(_localToken).safeTransferFrom(_from, address(this), _amount); deposits[_localToken][_remoteToken] = deposits[_localToken][_remoteToken] + _amount; _emitERC20BridgeInitiated(_localToken, _remoteToken, _from, _to, _amount); } function _initiateBridgeERC20L2( address _localToken, address _remoteToken, address _from, address _to, uint256 _amount ) internal { CatenaMintableERC20(_localToken).burn(_from, _amount); _emitERC20BridgeInitiated(_localToken, _remoteToken, _from, _to, _amount); } function _initiateBridgeNative( address _from, address _to, uint256 _amount ) internal { _emitNativeBridgeInitiated(_from, _to, _amount); } function _isCatenaMintableERC20(address _token) internal view returns (bool) { return ERC165Checker.supportsInterface(_token, type(ICatenaMintableERC20).interfaceId); } function _isCorrectTokenPair(address _mintableToken, address _otherToken) internal view returns (bool) { if (ERC165Checker.supportsInterface(_mintableToken, type(ICatenaMintableERC20).interfaceId)) { return _otherToken == localToRemote[_mintableToken]; }else { return false; } } function _emitNativeBridgeInitiated( address _from, address _to, uint256 _amount ) internal virtual { emit NativeBridgeInitiated(_from, _to, _amount); } function _emitNativeBridgeFinalized( address _from, address _to, uint256 _amount ) internal virtual { emit NativeBridgeFinalized(_from, _to, _amount); } function _emitERC20BridgeInitiated( address _localToken, address _remoteToken, address _from, address _to, uint256 _amount ) internal virtual { emit ERC20BridgeInitiated(_localToken, _remoteToken, _from, _to, _amount); } function _emitERC20BridgeFinalized( address _localToken, address _remoteToken, address _from, address _to, uint256 _amount ) internal virtual { emit ERC20BridgeFinalized(_localToken, _remoteToken, _from, _to, _amount); } function getAllTokenPairs() external view returns(TokenPair[] memory ){ return tokenPairs; } function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } else if(newOwner == owner){ revert AlreadyOwner(); } _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal virtual { address oldOwner = owner; owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: Bridge/L1/L1StandardBridge.sol pragma solidity ^0.8.19; error L1StandardBridge__NativeTokenExistAlready(); contract L1StandardBridge is StandardBridge { address public remoteToken; event NativePairSet( address indexed localToken, address indexed remoteToken, bool indexed active ); constructor(){ owner = msg.sender; } function setRemoteToken(address _remoteToken) public onlyOwner { require(remoteToken == address(0) , "Remote Token Already Exist"); remoteToken = _remoteToken; super.setPairs(address(0), _remoteToken); emit NativePairSet(address(0), _remoteToken, true); } function setPairs(address _localToken, address _remoteToken) public override onlyOwner { require(_localToken != remoteToken && _remoteToken != remoteToken, "Native is Already Paired"); require(_localToken != address(0) && _remoteToken != address(0), "Zero Address Not Allowed"); super.setPairs(_localToken, _remoteToken); } function depositNative() external payable onlyPairs(address(0),localToRemote[address(0)]) { require(msg.value > 0 , "More Than Zero"); _initiateNativeDeposit(msg.sender, msg.sender); } function depositNativeTo( address _to ) external payable onlyPairs(address(0),localToRemote[address(0)]) { require(msg.value > 0 , "More Than Zero"); _initiateNativeDeposit(msg.sender, _to); } function depositERC20( address _l1Token, uint256 _amount ) external onlyPairs(_l1Token,localToRemote[_l1Token]) { require(IERC20(_l1Token).balanceOf(msg.sender) >= _amount, "User Don't Have Enough Balance"); require(IERC20(_l1Token).allowance(msg.sender, address(this)) >= _amount, "Approval not sufficient for bridge operation"); _initiateERC20Deposit(_l1Token, localToRemote[_l1Token], msg.sender, msg.sender, _amount); } function depositERC20To( address _l1Token, address _to, uint256 _amount ) external onlyPairs(_l1Token,localToRemote[_l1Token]) { require(IERC20(_l1Token).balanceOf(msg.sender) >= _amount, "User Don't Have Enough Balance"); require(IERC20(_l1Token).allowance(msg.sender, address(this)) >= _amount, "Approval not sufficient for bridge operation"); _initiateERC20Deposit(_l1Token, localToRemote[_l1Token], msg.sender, _to, _amount); } function _initiateERC20Deposit( address _l1Token, address _l2Token, address _from, address _to, uint256 _amount ) internal { _initiateBridgeERC20L1(_l1Token, _l2Token, _from, _to, _amount); } function _initiateNativeDeposit( address _from, address _to ) internal { _initiateBridgeNative(_from, _to, msg.value); } function withDrawNative(address _from, address _to, uint _amount) public onlyOwner onlyPairs(remoteToLocal[remoteToken],remoteToken){ finalizeBridgeNative(address(0), _from, _to, _amount); } function finalizeERC20Withdrawal( address _l1Token, address _l2Token, address _from, address _to, uint256 _amount ) public onlyOwner onlyPairs(_l1Token,_l2Token) { finalizeBridgeERC20(_l1Token, _l2Token, _from, _to, _amount); } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"localToken","type":"address"},{"indexed":true,"internalType":"address","name":"remoteToken","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20BridgeFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"localToken","type":"address"},{"indexed":true,"internalType":"address","name":"remoteToken","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20BridgeInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"localToken","type":"address"},{"indexed":true,"internalType":"address","name":"remoteToken","type":"address"},{"indexed":true,"internalType":"bool","name":"active","type":"bool"}],"name":"ERC20TokenPairSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"NativeBridgeFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"NativeBridgeInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"localToken","type":"address"},{"indexed":true,"internalType":"address","name":"remoteToken","type":"address"},{"indexed":true,"internalType":"bool","name":"active","type":"bool"}],"name":"NativePairSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"_l1Token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"depositERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_l1Token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"depositERC20To","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositNative","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"depositNativeTo","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_l1Token","type":"address"},{"internalType":"address","name":"_l2Token","type":"address"},{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"finalizeERC20Withdrawal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllTokenPairs","outputs":[{"components":[{"internalType":"address","name":"localToken","type":"address"},{"internalType":"address","name":"remoteToken","type":"address"},{"internalType":"bool","name":"isActive","type":"bool"}],"internalType":"struct StandardBridge.TokenPair[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remoteToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_localToken","type":"address"},{"internalType":"address","name":"_remoteToken","type":"address"}],"name":"setPairs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_remoteToken","type":"address"}],"name":"setRemoteToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withDrawNative","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
59753:3477:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62902:323;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59009:106;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60041:298;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61712:525;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62690:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60957:229;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52019:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61197:506;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60347:355;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59806:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60710:239;;;:::i;:::-;;59123:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62902:323;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63122:8:::1;63131;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;63157:60:::2;63177:8;63187;63197:5;63204:3;63209:7;63157:19;:60::i;:::-;53519:1:::1;;62902:323:::0;;;;;:::o;59009:106::-;59059:18;59097:10;59090:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59009:106;:::o;60041:298::-;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;60146:1:::1;60123:25;;:11;;;;;;;;;;;:25;;;60115:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;60205:12;60191:11;;:26;;;;;;;;;;;;;;;;;;60228:40;60251:1;60255:12;60228:14;:40::i;:::-;60324:4;60284:45;;60310:12;60284:45;;60306:1;60284:45;;;;;;;;;;;;60041:298:::0;:::o;61712:525::-;61855:8;61864:13;:23;61878:8;61864:23;;;;;;;;;;;;;;;;;;;;;;;;;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;61962:7:::1;61927:8;61920:26;;;61947:10;61920:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;61912:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;62080:7;62030:8;62023:26;;;62050:10;62070:4;62023:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:64;;62015:121;;;;;;;;;;;;:::i;:::-;;;;;;;;;62147:82;62169:8;62179:13;:23;62193:8;62179:23;;;;;;;;;;;;;;;;;;;;;;;;;62204:10;62216:3;62221:7;62147:21;:82::i;:::-;61712:525:::0;;;;;:::o;62690:204::-;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;62783:13:::1;:26;62797:11;;;;;;;;;;;62783:26;;;;;;;;;;;;;;;;;;;;;;;;;62810:11;;;;;;;;;;;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;62833:53:::2;62862:1;62866:5;62873:3;62878:7;62833:20;:53::i;:::-;53519:1:::1;;62690:204:::0;;;:::o;60957:229::-;61046:1;61049:13;:25;61071:1;61049:25;;;;;;;;;;;;;;;;;;;;;;;;;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;61107:1:::1;61095:9;:13;61087:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;61139:39;61162:10;61174:3;61139:22;:39::i;:::-;60957:229:::0;;;:::o;52019:20::-;;;;;;;;;;;;:::o;61197:506::-;61318:8;61327:13;:23;61341:8;61327:23;;;;;;;;;;;;;;;;;;;;;;;;;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;61421:7:::1;61386:8;61379:26;;;61406:10;61379:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;61371:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;61539:7;61489:8;61482:26;;;61509:10;61529:4;61482:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:64;;61474:121;;;;;;;;;;;;:::i;:::-;;;;;;;;;61606:89;61628:8;61638:13;:23;61652:8;61638:23;;;;;;;;;;;;;;;;;;;;;;;;;61663:10;61675;61687:7;61606:21;:89::i;:::-;61197:506:::0;;;;:::o;60347:355::-;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;60468:11:::1;;;;;;;;;;;60453:26;;:11;:26;;;;:57;;;;;60499:11;;;;;;;;;;;60483:27;;:12;:27;;;;60453:57;60445:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;60581:1;60558:25;;:11;:25;;;;:55;;;;;60611:1;60587:26;;:12;:26;;;;60558:55;60550:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;60653:41;60668:11;60681:12;60653:14;:41::i;:::-;60347:355:::0;;:::o;59806:26::-;;;;;;;;;;;;;:::o;60710:239::-;60797:1;60800:13;:25;60822:1;60800:25;;;;;;;;;;;;;;;;;;;;;;;;;53615:15;:28;53631:11;53615:28;;;;;;;;;;;;;;;:42;53644:12;53615:42;;;;;;;;;;;;;;;;;;;;;;;;;53607:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;60863:1:::1;60851:9;:13;60843:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;60895:46;60918:10;60930;60895:22;:46::i;:::-;60710:239:::0;;:::o;59123:295::-;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;59228:1:::1;59208:22;;:8;:22;;::::0;59204:168:::1;;59282:1;59254:31;;;;;;;;;;;:::i;:::-;;;;;;;;59204:168;59318:5;::::0;::::1;;;;;;;;59306:17;;:8;:17;;::::0;59303:69:::1;;59346:14;;;;;;;;;;;;;;59303:69;59382:28;59401:8;59382:18;:28::i;:::-;59123:295:::0;:::o;54652:809::-;54869:35;54892:11;54869:22;:35::i;:::-;54865:493;;;54947:46;54967:11;54980:12;54947:19;:46::i;:::-;54921:180;;;;;;;;;;;;:::i;:::-;;;;;;;;;55138:11;55118:37;;;55156:3;55161:7;55118:51;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54865:493;;;55278:7;55240:8;:21;55249:11;55240:21;;;;;;;;;;;;;;;:35;55262:12;55240:35;;;;;;;;;;;;;;;;:45;;;;:::i;:::-;55202:8;:21;55211:11;55202:21;;;;;;;;;;;;;;;:35;55224:12;55202:35;;;;;;;;;;;;;;;:83;;;;55300:46;55333:3;55338:7;55307:11;55300:32;;;;:46;;;;;:::i;:::-;54865:493;55370:73;55396:11;55409:12;55423:5;55430:3;55435:7;55370:25;:73::i;:::-;54652:809;;;;;:::o;53717:926::-;53465:5;;;;;;;;;;53451:19;;:10;:19;;;53443:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53837:12:::1;53822:27;;:11;:27;;::::0;53814:66:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;53937:1;53899:40;;:13;:26;53913:11;53899:26;;;;;;;;;;;;;;;;;;;;;;;;;:40;;;:85;;;;;53982:1;53943:41;;:13;:27;53957:12;53943:27;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;53899:85;53891:127;;;;;;;;;;;;:::i;:::-;;;;;;;;;54075:1;54037:40;;:13;:26;54051:11;54037:26;;;;;;;;;;;;;;;;;;;;;;;;;:40;;;:85;;;;;54120:1;54081:41;;:13;:27;54095:12;54081:27;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;54037:85;54029:128;;;;;;;;;;;;:::i;:::-;;;;;;;;;54225:12;54196:13;:26;54210:11;54196:26;;;;;;;;;;;;;;;;:41;;;;;;;;;;;;;;;;;;54278:11;54248:13;:27;54262:12;54248:27;;;;;;;;;;;;;;;;:41;;;;;;;;;;;;;;;;;;54345:4;54300:15;:28;54316:11;54300:28;;;;;;;;;;;;;;;:42;54329:12;54300:42;;;;;;;;;;;;;;;;:49;;;;;;;;;;;;;;;;;;54370:20;54393:12;:25;54406:11;54393:25;;;;;;;;;;;;;;;54370:48;;54445:11;54429:2;:13;;;:27;;;;;;;;;;;;;;;;;;54484:12;54467:2;:14;;;:29;;;;;;;;;;;;;;;;;;54521:4;54507:2;:11;;;:18;;;;;;;;;;;;;;;;;;54543:10;54559:2;54543:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54621:2;:11;;;;;;;;;;;;54578:55;;54608:12;54578:55;;54596:11;54578:55;;;;;;;;;;;;53803:840;53717:926:::0;;:::o;62245:269::-;62443:63;62466:8;62476;62486:5;62493:3;62498:7;62443:22;:63::i;:::-;62245:269;;;;;:::o;55469:869::-;55667:4;55652:20;;:3;:20;;;55644:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55729:35;55752:11;55729:22;:35::i;:::-;55725:546;;;55807:44;55827:11;55848:1;55807:19;:44::i;:::-;55781:178;;;;;;;;;;;;:::i;:::-;;;;;;;;;55996:11;55976:37;;;56014:3;56019:7;55976:51;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55725:546;;;56093:7;56068:21;:32;;56060:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;56156:12;56173:3;:8;;56190:7;56173:29;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56155:47;;;56225:7;56217:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;56045:226;55725:546;56281:47;56308:5;56315:3;56320:7;56281:26;:47::i;:::-;55469:869;;;;:::o;62522:158::-;62628:44;62650:5;62657:3;62662:9;62628:21;:44::i;:::-;62522:158;;:::o;59426:189::-;59500:16;59519:5;;;;;;;;;;;59500:24;;59543:8;59535:5;;:16;;;;;;;;;;;;;;;;;;59598:8;59567:40;;59588:8;59567:40;;;;;;;;;;;;59489:126;59426:189;:::o;57422:182::-;57493:4;57517:79;57549:6;57557:38;57517:31;:79::i;:::-;57510:86;;57422:182;;;:::o;57614:337::-;57711:4;57732:87;57764:14;57780:38;57732:31;:87::i;:::-;57728:216;;;57859:13;:29;57873:14;57859:29;;;;;;;;;;;;;;;;;;;;;;;;;57844:44;;:11;:44;;;57837:51;;;;57728:216;57927:5;57920:12;;57614:337;;;;;:::o;47031:162::-;47114:71;47134:5;47156;:14;;;47173:2;47177:5;47141:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47114:19;:71::i;:::-;47031:162;;;:::o;58692:307::-;58971:5;58923:68;;58957:12;58923:68;;58944:11;58923:68;;;58978:3;58983:7;58923:68;;;;;;;:::i;:::-;;;;;;;;58692:307;;;;;:::o;56346:471::-;56562:67;56599:5;56614:4;56621:7;56569:11;56562:36;;;;:67;;;;;;:::i;:::-;56716:7;56678:8;:21;56687:11;56678:21;;;;;;;;;;;;;;;:35;56700:12;56678:35;;;;;;;;;;;;;;;;:45;;;;:::i;:::-;56640:8;:21;56649:11;56640:21;;;;;;;;;;;;;;;:35;56662:12;56640:35;;;;;;;;;;;;;;;:83;;;;56734:73;56760:11;56773:12;56787:5;56794:3;56799:7;56734:25;:73::i;:::-;56346:471;;;;;:::o;58169:198::-;58346:3;58317:42;;58339:5;58317:42;;;58351:7;58317:42;;;;;;:::i;:::-;;;;;;;;58169:198;;;:::o;57198:216::-;57351:47;57378:5;57385:3;57390:7;57351:26;:47::i;:::-;57198:216;;;:::o;28907:285::-;28994:4;29103:23;29118:7;29103:14;:23::i;:::-;:81;;;;;29130:54;29163:7;29172:11;29130:32;:54::i;:::-;29103:81;29096:88;;28907:285;;;;:::o;49842:638::-;50266:23;50292:33;50320:4;50300:5;50292:27;;;;:33;;;;:::i;:::-;50266:59;;50361:1;50340:10;:17;:22;;:57;;;;;50378:10;50367:30;;;;;;;;;;;;:::i;:::-;50366:31;50340:57;50336:137;;;50454:5;50421:40;;;;;;;;;;;:::i;:::-;;;;;;;;50336:137;49912:568;49842:638;;:::o;47438:190::-;47539:81;47559:5;47581;:18;;;47602:4;47608:2;47612:5;47566:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47539:19;:81::i;:::-;47438:190;;;;:::o;58377:307::-;58656:5;58608:68;;58642:12;58608:68;;58629:11;58608:68;;;58663:3;58668:7;58608:68;;;;;;;:::i;:::-;;;;;;;;58377:307;;;;;:::o;57961:198::-;58138:3;58109:42;;58131:5;58109:42;;;58143:7;58109:42;;;;;;:::i;:::-;;;;;;;;57961:198;;;:::o;28249:432::-;28313:4;28524:68;28557:7;28566:25;28524:32;:68::i;:::-;:149;;;;;28610:63;28643:7;28139:10;28652:20;;28610:32;:63::i;:::-;28609:64;28524:149;28504:169;;28249:432;;;:::o;32013:647::-;32115:4;32157:26;32229:11;32186:56;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32157:85;;32287:12;32310:18;32339:19;32485:4;32479;32463:13;32457:20;32450:4;32435:13;32431:24;32422:7;32415:5;32404:86;32393:97;;32518:16;32504:30;;32569:4;32563:11;32548:26;;32604:7;:29;;;;;32629:4;32615:10;:18;;32604:29;:48;;;;;32651:1;32637:11;:15;32604:48;32597:55;;;;;;32013:647;;;;:::o;40022:187::-;40097:12;40129:72;40151:6;40159:4;40165:1;40129:72;;;;;;;;;;;;;;;;;:21;:72::i;:::-;40122:79;;40022:187;;;;:::o;41525:455::-;41695:12;41753:5;41728:21;:30;;41720:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;41813:12;41827:23;41854:6;:11;;41873:5;41880:4;41854:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41812:73;;;;41903:69;41930:6;41938:7;41947:10;41959:12;41903:26;:69::i;:::-;41896:76;;;;41525:455;;;;;;:::o;44098:644::-;44283:12;44312:7;44308:427;;;44361:1;44340:10;:17;:22;44336:290;;44558:18;44569:6;44558:10;:18::i;:::-;44550:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;44336:290;44647:10;44640:17;;;;44308:427;44690:33;44698:10;44710:12;44690:7;:33::i;:::-;44098:644;;;;;;;:::o;37684:326::-;37744:4;38001:1;37979:7;:19;;;:23;37972:30;;37684:326;;;:::o;45284:552::-;45465:1;45445:10;:17;:21;45441:388;;;45677:10;45671:17;45734:15;45721:10;45717:2;45713:19;45706:44;45441:388;45804:12;45797:20;;;;;;;;;;;:::i;:::-;;;;;;;;88:117:1;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:911::-;1292:6;1300;1308;1316;1324;1373:3;1361:9;1352:7;1348:23;1344:33;1341:120;;;1380:79;;:::i;:::-;1341:120;1500:1;1525:53;1570:7;1561:6;1550:9;1546:22;1525:53;:::i;:::-;1515:63;;1471:117;1627:2;1653:53;1698:7;1689:6;1678:9;1674:22;1653:53;:::i;:::-;1643:63;;1598:118;1755:2;1781:53;1826:7;1817:6;1806:9;1802:22;1781:53;:::i;:::-;1771:63;;1726:118;1883:2;1909:53;1954:7;1945:6;1934:9;1930:22;1909:53;:::i;:::-;1899:63;;1854:118;2011:3;2038:53;2083:7;2074:6;2063:9;2059:22;2038:53;:::i;:::-;2028:63;;1982:119;1197:911;;;;;;;;:::o;2114:141::-;2208:6;2242:5;2236:12;2226:22;;2114:141;;;:::o;2261:211::-;2387:11;2421:6;2416:3;2409:19;2461:4;2456:3;2452:14;2437:29;;2261:211;;;;:::o;2478:159::-;2572:4;2595:3;2587:11;;2625:4;2620:3;2616:14;2608:22;;2478:159;;;:::o;2643:108::-;2720:24;2738:5;2720:24;:::i;:::-;2715:3;2708:37;2643:108;;:::o;2757:90::-;2791:7;2834:5;2827:13;2820:21;2809:32;;2757:90;;;:::o;2853:99::-;2924:21;2939:5;2924:21;:::i;:::-;2919:3;2912:34;2853:99;;:::o;3032:686::-;3173:4;3168:3;3164:14;3266:4;3259:5;3255:16;3249:23;3285:63;3342:4;3337:3;3333:14;3319:12;3285:63;:::i;:::-;3188:170;3447:4;3440:5;3436:16;3430:23;3466:63;3523:4;3518:3;3514:14;3500:12;3466:63;:::i;:::-;3368:171;3625:4;3618:5;3614:16;3608:23;3644:57;3695:4;3690:3;3686:14;3672:12;3644:57;:::i;:::-;3549:162;3142:576;3032:686;;:::o;3724:287::-;3847:10;3868:100;3964:3;3956:6;3868:100;:::i;:::-;4000:4;3995:3;3991:14;3977:28;;3724:287;;;;:::o;4017:140::-;4114:4;4146;4141:3;4137:14;4129:22;;4017:140;;;:::o;4241:948::-;4414:3;4443:81;4518:5;4443:81;:::i;:::-;4540:113;4646:6;4641:3;4540:113;:::i;:::-;4533:120;;4677:83;4754:5;4677:83;:::i;:::-;4783:7;4814:1;4799:365;4824:6;4821:1;4818:13;4799:365;;;4900:6;4894:13;4927:117;5040:3;5025:13;4927:117;:::i;:::-;4920:124;;5067:87;5147:6;5067:87;:::i;:::-;5057:97;;4859:305;4846:1;4843;4839:9;4834:14;;4799:365;;;4803:14;5180:3;5173:10;;4419:770;;;4241:948;;;;:::o;5195:481::-;5392:4;5430:2;5419:9;5415:18;5407:26;;5479:9;5473:4;5469:20;5465:1;5454:9;5450:17;5443:47;5507:162;5664:4;5655:6;5507:162;:::i;:::-;5499:170;;5195:481;;;;:::o;5682:329::-;5741:6;5790:2;5778:9;5769:7;5765:23;5761:32;5758:119;;;5796:79;;:::i;:::-;5758:119;5916:1;5941:53;5986:7;5977:6;5966:9;5962:22;5941:53;:::i;:::-;5931:63;;5887:117;5682:329;;;;:::o;6017:619::-;6094:6;6102;6110;6159:2;6147:9;6138:7;6134:23;6130:32;6127:119;;;6165:79;;:::i;:::-;6127:119;6285:1;6310:53;6355:7;6346:6;6335:9;6331:22;6310:53;:::i;:::-;6300:63;;6256:117;6412:2;6438:53;6483:7;6474:6;6463:9;6459:22;6438:53;:::i;:::-;6428:63;;6383:118;6540:2;6566:53;6611:7;6602:6;6591:9;6587:22;6566:53;:::i;:::-;6556:63;;6511:118;6017:619;;;;;:::o;6642:118::-;6729:24;6747:5;6729:24;:::i;:::-;6724:3;6717:37;6642:118;;:::o;6766:222::-;6859:4;6897:2;6886:9;6882:18;6874:26;;6910:71;6978:1;6967:9;6963:17;6954:6;6910:71;:::i;:::-;6766:222;;;;:::o;6994:474::-;7062:6;7070;7119:2;7107:9;7098:7;7094:23;7090:32;7087:119;;;7125:79;;:::i;:::-;7087:119;7245:1;7270:53;7315:7;7306:6;7295:9;7291:22;7270:53;:::i;:::-;7260:63;;7216:117;7372:2;7398:53;7443:7;7434:6;7423:9;7419:22;7398:53;:::i;:::-;7388:63;;7343:118;6994:474;;;;;:::o;7474:::-;7542:6;7550;7599:2;7587:9;7578:7;7574:23;7570:32;7567:119;;;7605:79;;:::i;:::-;7567:119;7725:1;7750:53;7795:7;7786:6;7775:9;7771:22;7750:53;:::i;:::-;7740:63;;7696:117;7852:2;7878:53;7923:7;7914:6;7903:9;7899:22;7878:53;:::i;:::-;7868:63;;7823:118;7474:474;;;;;:::o;7954:169::-;8038:11;8072:6;8067:3;8060:19;8112:4;8107:3;8103:14;8088:29;;7954:169;;;;:::o;8129:220::-;8269:34;8265:1;8257:6;8253:14;8246:58;8338:3;8333:2;8325:6;8321:15;8314:28;8129:220;:::o;8355:366::-;8497:3;8518:67;8582:2;8577:3;8518:67;:::i;:::-;8511:74;;8594:93;8683:3;8594:93;:::i;:::-;8712:2;8707:3;8703:12;8696:19;;8355:366;;;:::o;8727:419::-;8893:4;8931:2;8920:9;8916:18;8908:26;;8980:9;8974:4;8970:20;8966:1;8955:9;8951:17;8944:47;9008:131;9134:4;9008:131;:::i;:::-;9000:139;;8727:419;;;:::o;9152:174::-;9292:26;9288:1;9280:6;9276:14;9269:50;9152:174;:::o;9332:366::-;9474:3;9495:67;9559:2;9554:3;9495:67;:::i;:::-;9488:74;;9571:93;9660:3;9571:93;:::i;:::-;9689:2;9684:3;9680:12;9673:19;;9332:366;;;:::o;9704:419::-;9870:4;9908:2;9897:9;9893:18;9885:26;;9957:9;9951:4;9947:20;9943:1;9932:9;9928:17;9921:47;9985:131;10111:4;9985:131;:::i;:::-;9977:139;;9704:419;;;:::o;10129:176::-;10269:28;10265:1;10257:6;10253:14;10246:52;10129:176;:::o;10311:366::-;10453:3;10474:67;10538:2;10533:3;10474:67;:::i;:::-;10467:74;;10550:93;10639:3;10550:93;:::i;:::-;10668:2;10663:3;10659:12;10652:19;;10311:366;;;:::o;10683:419::-;10849:4;10887:2;10876:9;10872:18;10864:26;;10936:9;10930:4;10926:20;10922:1;10911:9;10907:17;10900:47;10964:131;11090:4;10964:131;:::i;:::-;10956:139;;10683:419;;;:::o;11108:143::-;11165:5;11196:6;11190:13;11181:22;;11212:33;11239:5;11212:33;:::i;:::-;11108:143;;;;:::o;11257:351::-;11327:6;11376:2;11364:9;11355:7;11351:23;11347:32;11344:119;;;11382:79;;:::i;:::-;11344:119;11502:1;11527:64;11583:7;11574:6;11563:9;11559:22;11527:64;:::i;:::-;11517:74;;11473:128;11257:351;;;;:::o;11614:180::-;11754:32;11750:1;11742:6;11738:14;11731:56;11614:180;:::o;11800:366::-;11942:3;11963:67;12027:2;12022:3;11963:67;:::i;:::-;11956:74;;12039:93;12128:3;12039:93;:::i;:::-;12157:2;12152:3;12148:12;12141:19;;11800:366;;;:::o;12172:419::-;12338:4;12376:2;12365:9;12361:18;12353:26;;12425:9;12419:4;12415:20;12411:1;12400:9;12396:17;12389:47;12453:131;12579:4;12453:131;:::i;:::-;12445:139;;12172:419;;;:::o;12597:332::-;12718:4;12756:2;12745:9;12741:18;12733:26;;12769:71;12837:1;12826:9;12822:17;12813:6;12769:71;:::i;:::-;12850:72;12918:2;12907:9;12903:18;12894:6;12850:72;:::i;:::-;12597:332;;;;;:::o;12935:231::-;13075:34;13071:1;13063:6;13059:14;13052:58;13144:14;13139:2;13131:6;13127:15;13120:39;12935:231;:::o;13172:366::-;13314:3;13335:67;13399:2;13394:3;13335:67;:::i;:::-;13328:74;;13411:93;13500:3;13411:93;:::i;:::-;13529:2;13524:3;13520:12;13513:19;;13172:366;;;:::o;13544:419::-;13710:4;13748:2;13737:9;13733:18;13725:26;;13797:9;13791:4;13787:20;13783:1;13772:9;13768:17;13761:47;13825:131;13951:4;13825:131;:::i;:::-;13817:139;;13544:419;;;:::o;13969:164::-;14109:16;14105:1;14097:6;14093:14;14086:40;13969:164;:::o;14139:366::-;14281:3;14302:67;14366:2;14361:3;14302:67;:::i;:::-;14295:74;;14378:93;14467:3;14378:93;:::i;:::-;14496:2;14491:3;14487:12;14480:19;;14139:366;;;:::o;14511:419::-;14677:4;14715:2;14704:9;14700:18;14692:26;;14764:9;14758:4;14754:20;14750:1;14739:9;14735:17;14728:47;14792:131;14918:4;14792:131;:::i;:::-;14784:139;;14511:419;;;:::o;14936:174::-;15076:26;15072:1;15064:6;15060:14;15053:50;14936:174;:::o;15116:366::-;15258:3;15279:67;15343:2;15338:3;15279:67;:::i;:::-;15272:74;;15355:93;15444:3;15355:93;:::i;:::-;15473:2;15468:3;15464:12;15457:19;;15116:366;;;:::o;15488:419::-;15654:4;15692:2;15681:9;15677:18;15669:26;;15741:9;15735:4;15731:20;15727:1;15716:9;15712:17;15705:47;15769:131;15895:4;15769:131;:::i;:::-;15761:139;;15488:419;;;:::o;15913:174::-;16053:26;16049:1;16041:6;16037:14;16030:50;15913:174;:::o;16093:366::-;16235:3;16256:67;16320:2;16315:3;16256:67;:::i;:::-;16249:74;;16332:93;16421:3;16332:93;:::i;:::-;16450:2;16445:3;16441:12;16434:19;;16093:366;;;:::o;16465:419::-;16631:4;16669:2;16658:9;16654:18;16646:26;;16718:9;16712:4;16708:20;16704:1;16693:9;16689:17;16682:47;16746:131;16872:4;16746:131;:::i;:::-;16738:139;;16465:419;;;:::o;16890:296::-;17030:34;17026:1;17018:6;17014:14;17007:58;17099:34;17094:2;17086:6;17082:15;17075:59;17168:10;17163:2;17155:6;17151:15;17144:35;16890:296;:::o;17192:366::-;17334:3;17355:67;17419:2;17414:3;17355:67;:::i;:::-;17348:74;;17431:93;17520:3;17431:93;:::i;:::-;17549:2;17544:3;17540:12;17533:19;;17192:366;;;:::o;17564:419::-;17730:4;17768:2;17757:9;17753:18;17745:26;;17817:9;17811:4;17807:20;17803:1;17792:9;17788:17;17781:47;17845:131;17971:4;17845:131;:::i;:::-;17837:139;;17564:419;;;:::o;17989:118::-;18076:24;18094:5;18076:24;:::i;:::-;18071:3;18064:37;17989:118;;:::o;18113:332::-;18234:4;18272:2;18261:9;18257:18;18249:26;;18285:71;18353:1;18342:9;18338:17;18329:6;18285:71;:::i;:::-;18366:72;18434:2;18423:9;18419:18;18410:6;18366:72;:::i;:::-;18113:332;;;;;:::o;18451:180::-;18499:77;18496:1;18489:88;18596:4;18593:1;18586:15;18620:4;18617:1;18610:15;18637:194;18677:4;18697:20;18715:1;18697:20;:::i;:::-;18692:25;;18731:20;18749:1;18731:20;:::i;:::-;18726:25;;18775:1;18772;18768:9;18760:17;;18799:1;18793:4;18790:11;18787:37;;;18804:18;;:::i;:::-;18787:37;18637:194;;;;:::o;18837:175::-;18977:27;18973:1;18965:6;18961:14;18954:51;18837:175;:::o;19018:366::-;19160:3;19181:67;19245:2;19240:3;19181:67;:::i;:::-;19174:74;;19257:93;19346:3;19257:93;:::i;:::-;19375:2;19370:3;19366:12;19359:19;;19018:366;;;:::o;19390:419::-;19556:4;19594:2;19583:9;19579:18;19571:26;;19643:9;19637:4;19633:20;19629:1;19618:9;19614:17;19607:47;19671:131;19797:4;19671:131;:::i;:::-;19663:139;;19390:419;;;:::o;19815:179::-;19955:31;19951:1;19943:6;19939:14;19932:55;19815:179;:::o;20000:366::-;20142:3;20163:67;20227:2;20222:3;20163:67;:::i;:::-;20156:74;;20239:93;20328:3;20239:93;:::i;:::-;20357:2;20352:3;20348:12;20341:19;;20000:366;;;:::o;20372:419::-;20538:4;20576:2;20565:9;20561:18;20553:26;;20625:9;20619:4;20615:20;20611:1;20600:9;20596:17;20589:47;20653:131;20779:4;20653:131;:::i;:::-;20645:139;;20372:419;;;:::o;20797:180::-;20937:32;20933:1;20925:6;20921:14;20914:56;20797:180;:::o;20983:366::-;21125:3;21146:67;21210:2;21205:3;21146:67;:::i;:::-;21139:74;;21222:93;21311:3;21222:93;:::i;:::-;21340:2;21335:3;21331:12;21324:19;;20983:366;;;:::o;21355:419::-;21521:4;21559:2;21548:9;21544:18;21536:26;;21608:9;21602:4;21598:20;21594:1;21583:9;21579:17;21572:47;21636:131;21762:4;21636:131;:::i;:::-;21628:139;;21355:419;;;:::o;21780:222::-;21920:34;21916:1;21908:6;21904:14;21897:58;21989:5;21984:2;21976:6;21972:15;21965:30;21780:222;:::o;22008:366::-;22150:3;22171:67;22235:2;22230:3;22171:67;:::i;:::-;22164:74;;22247:93;22336:3;22247:93;:::i;:::-;22365:2;22360:3;22356:12;22349:19;;22008:366;;;:::o;22380:419::-;22546:4;22584:2;22573:9;22569:18;22561:26;;22633:9;22627:4;22623:20;22619:1;22608:9;22604:17;22597:47;22661:131;22787:4;22661:131;:::i;:::-;22653:139;;22380:419;;;:::o;22805:222::-;22945:34;22941:1;22933:6;22929:14;22922:58;23014:5;23009:2;23001:6;22997:15;22990:30;22805:222;:::o;23033:366::-;23175:3;23196:67;23260:2;23255:3;23196:67;:::i;:::-;23189:74;;23272:93;23361:3;23272:93;:::i;:::-;23390:2;23385:3;23381:12;23374:19;;23033:366;;;:::o;23405:419::-;23571:4;23609:2;23598:9;23594:18;23586:26;;23658:9;23652:4;23648:20;23644:1;23633:9;23629:17;23622:47;23686:131;23812:4;23686:131;:::i;:::-;23678:139;;23405:419;;;:::o;23830:147::-;23931:11;23968:3;23953:18;;23830:147;;;;:::o;23983:114::-;;:::o;24103:398::-;24262:3;24283:83;24364:1;24359:3;24283:83;:::i;:::-;24276:90;;24375:93;24464:3;24375:93;:::i;:::-;24493:1;24488:3;24484:11;24477:18;;24103:398;;;:::o;24507:379::-;24691:3;24713:147;24856:3;24713:147;:::i;:::-;24706:154;;24877:3;24870:10;;24507:379;;;:::o;24892:172::-;25032:24;25028:1;25020:6;25016:14;25009:48;24892:172;:::o;25070:366::-;25212:3;25233:67;25297:2;25292:3;25233:67;:::i;:::-;25226:74;;25309:93;25398:3;25309:93;:::i;:::-;25427:2;25422:3;25418:12;25411:19;;25070:366;;;:::o;25442:419::-;25608:4;25646:2;25635:9;25631:18;25623:26;;25695:9;25689:4;25685:20;25681:1;25670:9;25666:17;25659:47;25723:131;25849:4;25723:131;:::i;:::-;25715:139;;25442:419;;;:::o;25867:191::-;25907:3;25926:20;25944:1;25926:20;:::i;:::-;25921:25;;25960:20;25978:1;25960:20;:::i;:::-;25955:25;;26003:1;26000;25996:9;25989:16;;26024:3;26021:1;26018:10;26015:36;;;26031:18;;:::i;:::-;26015:36;25867:191;;;;:::o;26064:222::-;26157:4;26195:2;26184:9;26180:18;26172:26;;26208:71;26276:1;26265:9;26261:17;26252:6;26208:71;:::i;:::-;26064:222;;;;:::o;26292:116::-;26362:21;26377:5;26362:21;:::i;:::-;26355:5;26352:32;26342:60;;26398:1;26395;26388:12;26342:60;26292:116;:::o;26414:137::-;26468:5;26499:6;26493:13;26484:22;;26515:30;26539:5;26515:30;:::i;:::-;26414:137;;;;:::o;26557:345::-;26624:6;26673:2;26661:9;26652:7;26648:23;26644:32;26641:119;;;26679:79;;:::i;:::-;26641:119;26799:1;26824:61;26877:7;26868:6;26857:9;26853:22;26824:61;:::i;:::-;26814:71;;26770:125;26557:345;;;;:::o;26908:442::-;27057:4;27095:2;27084:9;27080:18;27072:26;;27108:71;27176:1;27165:9;27161:17;27152:6;27108:71;:::i;:::-;27189:72;27257:2;27246:9;27242:18;27233:6;27189:72;:::i;:::-;27271;27339:2;27328:9;27324:18;27315:6;27271:72;:::i;:::-;26908:442;;;;;;:::o;27356:149::-;27392:7;27432:66;27425:5;27421:78;27410:89;;27356:149;;;:::o;27511:115::-;27596:23;27613:5;27596:23;:::i;:::-;27591:3;27584:36;27511:115;;:::o;27632:218::-;27723:4;27761:2;27750:9;27746:18;27738:26;;27774:69;27840:1;27829:9;27825:17;27816:6;27774:69;:::i;:::-;27632:218;;;;:::o;27856:225::-;27996:34;27992:1;27984:6;27980:14;27973:58;28065:8;28060:2;28052:6;28048:15;28041:33;27856:225;:::o;28087:366::-;28229:3;28250:67;28314:2;28309:3;28250:67;:::i;:::-;28243:74;;28326:93;28415:3;28326:93;:::i;:::-;28444:2;28439:3;28435:12;28428:19;;28087:366;;;:::o;28459:419::-;28625:4;28663:2;28652:9;28648:18;28640:26;;28712:9;28706:4;28702:20;28698:1;28687:9;28683:17;28676:47;28740:131;28866:4;28740:131;:::i;:::-;28732:139;;28459:419;;;:::o;28884:98::-;28935:6;28969:5;28963:12;28953:22;;28884:98;;;:::o;28988:246::-;29069:1;29079:113;29093:6;29090:1;29087:13;29079:113;;;29178:1;29173:3;29169:11;29163:18;29159:1;29154:3;29150:11;29143:39;29115:2;29112:1;29108:10;29103:15;;29079:113;;;29226:1;29217:6;29212:3;29208:16;29201:27;29050:184;28988:246;;;:::o;29240:386::-;29344:3;29372:38;29404:5;29372:38;:::i;:::-;29426:88;29507:6;29502:3;29426:88;:::i;:::-;29419:95;;29523:65;29581:6;29576:3;29569:4;29562:5;29558:16;29523:65;:::i;:::-;29613:6;29608:3;29604:16;29597:23;;29348:278;29240:386;;;;:::o;29632:271::-;29762:3;29784:93;29873:3;29864:6;29784:93;:::i;:::-;29777:100;;29894:3;29887:10;;29632:271;;;;:::o;29909:179::-;30049:31;30045:1;30037:6;30033:14;30026:55;29909:179;:::o;30094:366::-;30236:3;30257:67;30321:2;30316:3;30257:67;:::i;:::-;30250:74;;30333:93;30422:3;30333:93;:::i;:::-;30451:2;30446:3;30442:12;30435:19;;30094:366;;;:::o;30466:419::-;30632:4;30670:2;30659:9;30655:18;30647:26;;30719:9;30713:4;30709:20;30705:1;30694:9;30690:17;30683:47;30747:131;30873:4;30747:131;:::i;:::-;30739:139;;30466:419;;;:::o;30891:99::-;30943:6;30977:5;30971:12;30961:22;;30891:99;;;:::o;30996:102::-;31037:6;31088:2;31084:7;31079:2;31072:5;31068:14;31064:28;31054:38;;30996:102;;;:::o;31104:377::-;31192:3;31220:39;31253:5;31220:39;:::i;:::-;31275:71;31339:6;31334:3;31275:71;:::i;:::-;31268:78;;31355:65;31413:6;31408:3;31401:4;31394:5;31390:16;31355:65;:::i;:::-;31445:29;31467:6;31445:29;:::i;:::-;31440:3;31436:39;31429:46;;31196:285;31104:377;;;;:::o;31487:313::-;31600:4;31638:2;31627:9;31623:18;31615:26;;31687:9;31681:4;31677:20;31673:1;31662:9;31658:17;31651:47;31715:78;31788:4;31779:6;31715:78;:::i;:::-;31707:86;;31487:313;;;;:::o
Swarm Source
ipfs://e6b8de6e8ba9cdf78ef114a85011bfb4a6ac571c5a09b4f9f71db3d9d3df6e05
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.