Latest 25 from a total of 3,552 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Approve | 132008080 | 1 hr ago | IN | 0 ETH | 0.000000053424 | ||||
Approve | 131969509 | 22 hrs ago | IN | 0 ETH | 0.000000699206 | ||||
Approve | 131960365 | 27 hrs ago | IN | 0 ETH | 0.000000188795 | ||||
Approve | 131833339 | 4 days ago | IN | 0 ETH | 0.000000194904 | ||||
Approve | 131767172 | 5 days ago | IN | 0 ETH | 0.000000055115 | ||||
Approve | 131584252 | 9 days ago | IN | 0 ETH | 0.00000279873 | ||||
Approve | 131444997 | 13 days ago | IN | 0 ETH | 0.00000007515 | ||||
Approve | 131407149 | 13 days ago | IN | 0 ETH | 0.000000018569 | ||||
Approve | 131393164 | 14 days ago | IN | 0 ETH | 0.000000085976 | ||||
Approve | 131282412 | 16 days ago | IN | 0 ETH | 0.000001158241 | ||||
Approve | 131264538 | 17 days ago | IN | 0 ETH | 0.00000001313 | ||||
Approve | 131256132 | 17 days ago | IN | 0 ETH | 0.000000717205 | ||||
Approve | 131251502 | 17 days ago | IN | 0 ETH | 0.000000692092 | ||||
Approve | 131174421 | 19 days ago | IN | 0 ETH | 0.000000105644 | ||||
Approve | 131171812 | 19 days ago | IN | 0 ETH | 0.00000005407 | ||||
Approve | 131157253 | 19 days ago | IN | 0 ETH | 0.000000163272 | ||||
Transfer | 131157158 | 19 days ago | IN | 0 ETH | 0.000000172302 | ||||
Approve | 131157084 | 19 days ago | IN | 0 ETH | 0.000000167472 | ||||
Approve | 131110172 | 20 days ago | IN | 0 ETH | 0.000000068338 | ||||
Approve | 131110170 | 20 days ago | IN | 0 ETH | 0.000000080757 | ||||
Approve | 131110168 | 20 days ago | IN | 0 ETH | 0.000000082372 | ||||
Approve | 131019398 | 22 days ago | IN | 0 ETH | 0.00000022679 | ||||
Approve | 130739141 | 29 days ago | IN | 0 ETH | 0.000001440055 | ||||
Transfer | 130731497 | 29 days ago | IN | 0 ETH | 0.000000584838 | ||||
Approve | 130707901 | 30 days ago | IN | 0 ETH | 0.00000172647 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
107547843 | 566 days ago | 0 ETH | ||||
107547843 | 566 days ago | 0 ETH | ||||
107547843 | 566 days ago | 0 ETH | ||||
107547843 | 566 days ago | 0 ETH | ||||
107544857 | 566 days ago | 0 ETH | ||||
107544857 | 566 days ago | 0 ETH | ||||
107544857 | 566 days ago | 0 ETH | ||||
107544857 | 566 days ago | 0 ETH | ||||
107544790 | 566 days ago | 0 ETH | ||||
107544790 | 566 days ago | 0 ETH | ||||
107544790 | 566 days ago | 0 ETH | ||||
107544790 | 566 days ago | 0 ETH | ||||
107453924 | 568 days ago | 0 ETH | ||||
107453924 | 568 days ago | 0 ETH | ||||
107453924 | 568 days ago | 0 ETH | ||||
107448333 | 568 days ago | 0 ETH | ||||
107448333 | 568 days ago | 0 ETH | ||||
107448333 | 568 days ago | 0 ETH | ||||
107431399 | 568 days ago | 0 ETH | ||||
107431399 | 568 days ago | 0 ETH | ||||
107431399 | 568 days ago | 0 ETH | ||||
107427409 | 569 days ago | 0 ETH | ||||
107427409 | 569 days ago | 0 ETH | ||||
107427409 | 569 days ago | 0 ETH | ||||
107427409 | 569 days ago | 0 ETH |
Loading...
Loading
Contract Name:
BitANTOptimism
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at optimistic.etherscan.io on 2021-11-26 */ pragma solidity ^0.8.0; // SPDX-License-Identifier: MIT /** * @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); } /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ 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); } /** * @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; } } /** * @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 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. * * 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, IERC20Metadata { 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}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * 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 override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override 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 * 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 override returns (uint8) { return 18; } /** * @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"); unchecked { _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"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * 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. * * 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"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(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: * * - `account` 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); _afterTokenTransfer(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"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(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 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 {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 currentAllowance = allowance(account, _msgSender()); require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance"); unchecked { _approve(account, _msgSender(), currentAllowance - amount); } _burn(account, amount); } } /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } else if (error == RecoverError.InvalidSignatureV) { revert("ECDSA: invalid signature 'v' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { // Check the signature length // - case 65: r,s,v signature (standard) // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._ if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else if (signature.length == 64) { bytes32 r; bytes32 vs; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) vs := mload(add(signature, 0x40)) } return tryRecover(hash, r, vs); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s; uint8 v; assembly { s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) v := add(shr(255, vs), 27) } return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } if (v != 27 && v != 28) { return (address(0), RecoverError.InvalidSignatureV); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (block.chainid == _CACHED_CHAIN_ID) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 nameHash, bytes32 versionHash ) private view returns (bytes32) { return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } } /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= deadline, "ERC20Permit: expired deadline"); bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. * * _Available since v4.1._ */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } } /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } } /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits. */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128) { require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits"); return int128(value); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64) { require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits"); return int64(value); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32) { require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits"); return int32(value); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16) { require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits"); return int16(value); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits. * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8) { require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits"); return int8(value); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } } /** * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's, * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1. * * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module. * * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting * power can be queried through the public accessors {getVotes} and {getPastVotes}. * * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked. * Enabling self-delegation can easily be done by overriding the {delegates} function. Keep in mind however that this * will significantly increase the base gas cost of transfers. * * _Available since v4.2._ */ abstract contract ERC20Votes is ERC20Permit { struct Checkpoint { uint32 fromBlock; uint224 votes; } bytes32 private constant _DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); mapping(address => address) private _delegates; mapping(address => Checkpoint[]) private _checkpoints; Checkpoint[] private _totalSupplyCheckpoints; /** * @dev Emitted when an account changes their delegate. */ event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /** * @dev Emitted when a token transfer or delegate change results in changes to an account's voting power. */ event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance); /** * @dev Get the `pos`-th checkpoint for `account`. */ function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) { return _checkpoints[account][pos]; } /** * @dev Get number of checkpoints for `account`. */ function numCheckpoints(address account) public view virtual returns (uint32) { return SafeCast.toUint32(_checkpoints[account].length); } /** * @dev Get the address `account` is currently delegating to. */ function delegates(address account) public view virtual returns (address) { return _delegates[account]; } /** * @dev Gets the current votes balance for `account` */ function getVotes(address account) public view returns (uint256) { uint256 pos = _checkpoints[account].length; return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes; } /** * @dev Retrieve the number of votes for `account` at the end of `blockNumber`. * * Requirements: * * - `blockNumber` must have been already mined */ function getPastVotes(address account, uint256 blockNumber) public view returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_checkpoints[account], blockNumber); } /** * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances. * It is but NOT the sum of all the delegated votes! * * Requirements: * * - `blockNumber` must have been already mined */ function getPastTotalSupply(uint256 blockNumber) public view returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber); } /** * @dev Lookup a value in a list of (sorted) checkpoints. */ function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) { // We run a binary search to look for the earliest checkpoint taken after `blockNumber`. // // During the loop, the index of the wanted checkpoint remains in the range [low-1, high). // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant. // - If the middle checkpoint is after `blockNumber`, we look in [low, mid) // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high) // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not // out of bounds (in which case we're looking too far in the past and the result is 0). // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out // the same. uint256 high = ckpts.length; uint256 low = 0; while (low < high) { uint256 mid = Math.average(low, high); if (ckpts[mid].fromBlock > blockNumber) { high = mid; } else { low = mid + 1; } } return high == 0 ? 0 : ckpts[high - 1].votes; } /** * @dev Delegate votes from the sender to `delegatee`. */ function delegate(address delegatee) public virtual { return _delegate(_msgSender(), delegatee); } /** * @dev Delegates votes from signer to `delegatee` */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) public virtual { require(block.timestamp <= expiry, "ERC20Votes: signature expired"); address signer = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))), v, r, s ); require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce"); return _delegate(signer, delegatee); } /** * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1). */ function _maxSupply() internal view virtual returns (uint224) { return type(uint224).max; } /** * @dev Snapshots the totalSupply after it has been increased. */ function _mint(address account, uint256 amount) internal virtual override { super._mint(account, amount); require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes"); _writeCheckpoint(_totalSupplyCheckpoints, _add, amount); } /** * @dev Snapshots the totalSupply after it has been decreased. */ function _burn(address account, uint256 amount) internal virtual override { super._burn(account, amount); _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount); } /** * @dev Move voting power when tokens are transferred. * * Emits a {DelegateVotesChanged} event. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._afterTokenTransfer(from, to, amount); _moveVotingPower(delegates(from), delegates(to), amount); } /** * @dev Change delegation for `delegator` to `delegatee`. * * Emits events {DelegateChanged} and {DelegateVotesChanged}. */ function _delegate(address delegator, address delegatee) internal virtual { address currentDelegate = delegates(delegator); uint256 delegatorBalance = balanceOf(delegator); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveVotingPower(currentDelegate, delegatee, delegatorBalance); } function _moveVotingPower( address src, address dst, uint256 amount ) private { if (src != dst && amount > 0) { if (src != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount); emit DelegateVotesChanged(src, oldWeight, newWeight); } if (dst != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount); emit DelegateVotesChanged(dst, oldWeight, newWeight); } } } function _writeCheckpoint( Checkpoint[] storage ckpts, function(uint256, uint256) view returns (uint256) op, uint256 delta ) private returns (uint256 oldWeight, uint256 newWeight) { uint256 pos = ckpts.length; oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes; newWeight = op(oldWeight, delta); if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) { ckpts[pos - 1].votes = SafeCast.toUint224(newWeight); } else { ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)})); } } function _add(uint256 a, uint256 b) private pure returns (uint256) { return a + b; } function _subtract(uint256 a, uint256 b) private pure returns (uint256) { return a - b; } } /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } interface IL2StandardERC20 is IERC20, IERC165 { function l1Token() external returns (address); function mint(address _to, uint256 _amount) external; function burn(address _from, uint256 _amount) external; event Mint(address indexed _account, uint256 _amount); event Burn(address indexed _account, uint256 _amount); } contract BitANTOptimism is ERC20, ERC20Burnable, ERC20Votes, IL2StandardERC20 { address private _l2Bridge = 0x4200000000000000000000000000000000000010; address private _l1Token; modifier onlyBridge() { require(msg.sender == _l2Bridge, "BitANT: only bridge"); _; } constructor(address l1Token_) ERC20("BitANT", "BitANT") ERC20Permit("BitANT") { _l1Token = l1Token_; } function mint(address to, uint256 amount) external override onlyBridge { _mint(to, amount); emit Mint(to, amount); } function burn(address from, uint256 amount) external override onlyBridge { _burn(from, amount); emit Burn(from, amount); } function supportsInterface(bytes4 interfaceId) external override pure returns (bool) { bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^ IL2StandardERC20.mint.selector ^ IL2StandardERC20.burn.selector; return interfaceId == firstSupportedInterface || interfaceId == secondSupportedInterface; } function l1Token() external override view returns (address) { return _l1Token; } function l2Bridge() external view returns (address) { return _l2Bridge; } function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) { super._burn(account, amount); } function _mint(address account, uint256 amount) internal override(ERC20, ERC20Votes) { super._mint(account, amount); } function _afterTokenTransfer(address from, address to, uint256 amount) internal override(ERC20, ERC20Votes) { super._afterTokenTransfer(from, to, amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"l1Token_","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":"_account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"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":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"l1Token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000015ee120fd69bec86c1d38502299af7366a41d1a6
-----Decoded View---------------
Arg [0] : l1Token_ (address): 0x15Ee120fD69BEc86C1d38502299af7366a41D1a6
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000015ee120fd69bec86c1d38502299af7366a41d1a6
Deployed Bytecode Sourcemap
56582:1737:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57271:430;;;;;;:::i;:::-;;:::i;:::-;;;4259:14:1;;4252:22;4234:41;;4222:2;4207:18;57271:430:0;;;;;;;;6103:100;;;:::i;:::-;;;;;;;:::i;8270:169::-;;;;;;:::i;:::-;;:::i;7223:108::-;7311:12;;7223:108;;;4432:25:1;;;4420:2;4405:18;7223:108:0;4387:76:1;8921:492:0;;;;;;:::i;:::-;;:::i;7065:93::-;;;7148:2;17414:36:1;;17402:2;17387:18;7065:93:0;17369:87:1;36222:115:0;;;:::i;9822:215::-;;;;;;:::i;:::-;;:::i;48888:251::-;;;;;;:::i;:::-;;:::i;56991:131::-;;;;;;:::i;:::-;;:::i;:::-;;16447:91;;;;;;:::i;:::-;;:::i;48288:119::-;;;;;;:::i;:::-;-1:-1:-1;;;;;48380:19:0;;;48353:7;48380:19;;;:10;:19;;;;;;;;48288:119;;;;-1:-1:-1;;;;;4050:32:1;;;4032:51;;4020:2;4005:18;48288:119:0;3987:102:1;51327:112:0;;;;;;:::i;:::-;;:::i;48044:151::-;;;;;;:::i;:::-;;:::i;:::-;;;17249:10:1;17237:23;;;17219:42;;17207:2;17192:18;48044:151:0;17174:93:1;7394:127:0;;;;;;:::i;:::-;-1:-1:-1;;;;;7495:18:0;7468:7;7495:18;;;;;;;;;;;;7394:127;16857:368;;;;;;:::i;:::-;;:::i;35964:128::-;;;;;;:::i;:::-;;:::i;49428:242::-;;;;;;:::i;:::-;;:::i;6322:104::-;;;:::i;48491:195::-;;;;;;:::i;:::-;;:::i;57128:137::-;;;;;;:::i;:::-;;:::i;10540:413::-;;;;;;:::i;:::-;;:::i;7734:175::-;;;;;;:::i;:::-;;:::i;57801:81::-;57867:9;;-1:-1:-1;;;;;57867:9:0;57801:81;;57707:88;57781:8;;-1:-1:-1;;;;;57781:8:0;57707:88;;51521:589;;;;;;:::i;:::-;;:::i;35253:645::-;;;;;;:::i;:::-;;:::i;7972:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;8088:18:0;;;8061:7;8088:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;7972:151;47814:150;;;;;;:::i;:::-;;:::i;:::-;;;;16513:13:1;;16528:10;16509:30;16491:49;;16600:4;16588:17;;;16582:24;-1:-1:-1;;;;;16578:50:1;16556:20;;;16549:80;;;;16464:18;47814:150:0;16446:189:1;57271:430:0;57350:4;57403:38;-1:-1:-1;;;;;;;;;57614:38:0;;-1:-1:-1;;;57614:38:0;;:81;;-1:-1:-1;;;;;;;57656:39:0;;;;;;;57614:81;57607:88;57271:430;-1:-1:-1;;;;57271:430:0:o;6103:100::-;6157:13;6190:5;6183:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6103:100;:::o;8270:169::-;8353:4;8370:39;3991:10;8393:7;8402:6;8370:8;:39::i;:::-;-1:-1:-1;8427:4:0;8270:169;;;;:::o;8921:492::-;9061:4;9078:36;9088:6;9096:9;9107:6;9078:9;:36::i;:::-;-1:-1:-1;;;;;9154:19:0;;9127:24;9154:19;;;:11;:19;;;;;;;;3991:10;9154:33;;;;;;;;9206:26;;;;9198:79;;;;-1:-1:-1;;;9198:79:0;;12466:2:1;9198:79:0;;;12448:21:1;12505:2;12485:18;;;12478:30;12544:34;12524:18;;;12517:62;-1:-1:-1;;;12595:18:1;;;12588:38;12643:19;;9198:79:0;;;;;;;;;9313:57;9322:6;3991:10;9363:6;9344:16;:25;9313:8;:57::i;:::-;-1:-1:-1;9401:4:0;;8921:492;-1:-1:-1;;;;8921:492:0:o;36222:115::-;36282:7;36309:20;:18;:20::i;:::-;36302:27;;36222:115;:::o;9822:215::-;3991:10;9910:4;9959:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;9959:34:0;;;;;;;;;;9910:4;;9927:80;;9950:7;;9959:47;;9996:10;;9959:47;:::i;:::-;9927:8;:80::i;48888:251::-;48969:7;49011:12;48997:11;:26;48989:70;;;;-1:-1:-1;;;48989:70:0;;7950:2:1;48989:70:0;;;7932:21:1;7989:2;7969:18;;;7962:30;8028:33;8008:18;;;8001:61;8079:18;;48989:70:0;7922:181:1;48989:70:0;-1:-1:-1;;;;;49096:21:0;;;;;;:12;:21;;;;;49077:54;;49119:11;49077:18;:54::i;:::-;49070:61;48888:251;-1:-1:-1;;;48888:251:0:o;56991:131::-;56822:9;;-1:-1:-1;;;;;56822:9:0;56808:10;:23;56800:55;;;;-1:-1:-1;;;56800:55:0;;9431:2:1;56800:55:0;;;9413:21:1;9470:2;9450:18;;;9443:30;-1:-1:-1;;;9489:18:1;;;9482:49;9548:18;;56800:55:0;9403:169:1;56800:55:0;57069:17:::1;57075:2;57079:6;57069:5;:17::i;:::-;57105:2;-1:-1:-1::0;;;;;57100:16:0::1;;57109:6;57100:16;;;;4432:25:1::0;;4420:2;4405:18;;4387:76;57100:16:0::1;;;;;;;;56991:131:::0;;:::o;16447:91::-;16503:27;3991:10;16523:6;16503:5;:27::i;:::-;16447:91;:::o;51327:112::-;51397:34;3991:10;51421:9;51397;:34::i;48044:151::-;-1:-1:-1;;;;;48158:21:0;;48114:6;48158:21;;;:12;:21;;;;;:28;48140:47;;:17;:47::i;:::-;48133:54;48044:151;-1:-1:-1;;48044:151:0:o;16857:368::-;16934:24;16961:32;16971:7;3991:10;7972:151;:::i;16961:32::-;16934:59;;17032:6;17012:16;:26;;17004:75;;;;-1:-1:-1;;;17004:75:0;;13700:2:1;17004:75:0;;;13682:21:1;13739:2;13719:18;;;13712:30;13778:34;13758:18;;;13751:62;-1:-1:-1;;;13829:18:1;;;13822:34;13873:19;;17004:75:0;13672:226:1;17004:75:0;17115:58;17124:7;3991:10;17166:6;17147:16;:25;17115:8;:58::i;:::-;17195:22;17201:7;17210:6;17195:5;:22::i;:::-;16857:368;;;:::o;35964:128::-;-1:-1:-1;;;;;36060:14:0;;36033:7;36060:14;;;:7;:14;;;;;33492;36060:24;33400:114;49428:242;49498:7;49540:12;49526:11;:26;49518:70;;;;-1:-1:-1;;;49518:70:0;;7950:2:1;49518:70:0;;;7932:21:1;7989:2;7969:18;;;7962:30;8028:33;8008:18;;;8001:61;8079:18;;49518:70:0;7922:181:1;49518:70:0;49606:56;49625:23;49650:11;49606:18;:56::i;6322:104::-;6378:13;6411:7;6404:14;;;;;:::i;48491:195::-;-1:-1:-1;;;;;48581:21:0;;48547:7;48581:21;;;:12;:21;;;;;:28;48627:8;;:51;;-1:-1:-1;;;;;48642:21:0;;;;;;:12;:21;;;;;48664:7;48670:1;48664:3;:7;:::i;:::-;48642:30;;;;;;-1:-1:-1;;;48642:30:0;;;;;;;;;;;;;;;;;;:36;;;;-1:-1:-1;;;;;48642:36:0;48627:51;;;48638:1;48627:51;-1:-1:-1;;;;;48620:58:0;;48491:195;-1:-1:-1;;;48491:195:0:o;57128:137::-;56822:9;;-1:-1:-1;;;;;56822:9:0;56808:10;:23;56800:55;;;;-1:-1:-1;;;56800:55:0;;9431:2:1;56800:55:0;;;9413:21:1;9470:2;9450:18;;;9443:30;-1:-1:-1;;;9489:18:1;;;9482:49;9548:18;;56800:55:0;9403:169:1;56800:55:0;57208:19:::1;57214:4;57220:6;57208:5;:19::i;:::-;57246:4;-1:-1:-1::0;;;;;57241:18:0::1;;57252:6;57241:18;;;;4432:25:1::0;;4420:2;4405:18;;4387:76;10540:413:0;3991:10;10633:4;10677:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10677:34:0;;;;;;;;;;10730:35;;;;10722:85;;;;-1:-1:-1;;;10722:85:0;;15725:2:1;10722:85:0;;;15707:21:1;15764:2;15744:18;;;15737:30;15803:34;15783:18;;;15776:62;-1:-1:-1;;;15854:18:1;;;15847:35;15899:19;;10722:85:0;15697:227:1;10722:85:0;10843:67;3991:10;10866:7;10894:15;10875:16;:34;10843:8;:67::i;:::-;-1:-1:-1;10941:4:0;;10540:413;-1:-1:-1;;;10540:413:0:o;7734:175::-;7820:4;7837:42;3991:10;7861:9;7872:6;7837:9;:42::i;51521:589::-;51739:6;51720:15;:25;;51712:67;;;;-1:-1:-1;;;51712:67:0;;8310:2:1;51712:67:0;;;8292:21:1;8349:2;8329:18;;;8322:30;8388:31;8368:18;;;8361:59;8437:18;;51712:67:0;8282:179:1;51712:67:0;51862:58;;;47065:71;51862:58;;;5295:25:1;-1:-1:-1;;;;;5356:32:1;;5336:18;;;5329:60;;;;5405:18;;;5398:34;;;5448:18;;;5441:34;;;51790:14:0;;51807:174;;51835:87;;5267:19:1;;51862:58:0;;;;;;;;;;;;51852:69;;;;;;51835:16;:87::i;:::-;51937:1;51953;51969;51807:13;:174::i;:::-;51790:191;;52009:17;52019:6;52009:9;:17::i;:::-;52000:5;:26;51992:64;;;;-1:-1:-1;;;51992:64:0;;9779:2:1;51992:64:0;;;9761:21:1;9818:2;9798:18;;;9791:30;9857:27;9837:18;;;9830:55;9902:18;;51992:64:0;9751:175:1;51992:64:0;52074:28;52084:6;52092:9;52074;:28::i;:::-;52067:35;51521:589;;;;;;:::o;35253:645::-;35497:8;35478:15;:27;;35470:69;;;;-1:-1:-1;;;35470:69:0;;10536:2:1;35470:69:0;;;10518:21:1;10575:2;10555:18;;;10548:30;10614:31;10594:18;;;10587:59;10663:18;;35470:69:0;10508:179:1;35470:69:0;35552:18;35594:16;35612:5;35619:7;35628:5;35635:16;35645:5;35635:9;:16::i;:::-;35583:79;;;;;;4755:25:1;;;;-1:-1:-1;;;;;4854:15:1;;;4834:18;;;4827:43;4906:15;;;;4886:18;;;4879:43;4938:18;;;4931:34;4981:19;;;4974:35;5025:19;;;5018:35;;;4727:19;;35583:79:0;;;;;;;;;;;;35573:90;;;;;;35552:111;;35676:12;35691:28;35708:10;35691:16;:28::i;:::-;35676:43;;35732:14;35749:28;35763:4;35769:1;35772;35775;35749:13;:28::i;:::-;35732:45;;35806:5;-1:-1:-1;;;;;35796:15:0;:6;-1:-1:-1;;;;;35796:15:0;;35788:58;;;;-1:-1:-1;;;35788:58:0;;12107:2:1;35788:58:0;;;12089:21:1;12146:2;12126:18;;;12119:30;12185:32;12165:18;;;12158:60;12235:18;;35788:58:0;12079:180:1;35788:58:0;35859:31;35868:5;35875:7;35884:5;35859:8;:31::i;:::-;35253:645;;;;;;;;;;:::o;47814:150::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;47930:21:0;;;;;;:12;:21;;;;;:26;;;;;;;;;;-1:-1:-1;;;47930:26:0;;;;;;;;;;;;;;;;;;47923:33;;;;;;;;;47930:26;;47923:33;;;;;;;;;-1:-1:-1;;;;;47923:33:0;;;;;;;;;47814:150;-1:-1:-1;;;47814:150:0:o;14224:380::-;-1:-1:-1;;;;;14360:19:0;;14352:68;;;;-1:-1:-1;;;14352:68:0;;15320:2:1;14352:68:0;;;15302:21:1;15359:2;15339:18;;;15332:30;15398:34;15378:18;;;15371:62;-1:-1:-1;;;15449:18:1;;;15442:34;15493:19;;14352:68:0;15292:226:1;14352:68:0;-1:-1:-1;;;;;14439:21:0;;14431:68;;;;-1:-1:-1;;;14431:68:0;;10133:2:1;14431:68:0;;;10115:21:1;10172:2;10152:18;;;10145:30;10211:34;10191:18;;;10184:62;-1:-1:-1;;;10262:18:1;;;10255:32;10304:19;;14431:68:0;10105:224:1;14431:68:0;-1:-1:-1;;;;;14512:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;14564:32;;4432:25:1;;;14564:32:0;;4405:18:1;14564:32:0;;;;;;;14224:380;;;:::o;11443:733::-;-1:-1:-1;;;;;11583:20:0;;11575:70;;;;-1:-1:-1;;;11575:70:0;;14507:2:1;11575:70:0;;;14489:21:1;14546:2;14526:18;;;14519:30;14585:34;14565:18;;;14558:62;-1:-1:-1;;;14636:18:1;;;14629:35;14681:19;;11575:70:0;14479:227:1;11575:70:0;-1:-1:-1;;;;;11664:23:0;;11656:71;;;;-1:-1:-1;;;11656:71:0;;7546:2:1;11656:71:0;;;7528:21:1;7585:2;7565:18;;;7558:30;7624:34;7604:18;;;7597:62;-1:-1:-1;;;7675:18:1;;;7668:33;7718:19;;11656:71:0;7518:225:1;11656:71:0;-1:-1:-1;;;;;11824:17:0;;11800:21;11824:17;;;;;;;;;;;11860:23;;;;11852:74;;;;-1:-1:-1;;;11852:74:0;;10894:2:1;11852:74:0;;;10876:21:1;10933:2;10913:18;;;10906:30;10972:34;10952:18;;;10945:62;-1:-1:-1;;;11023:18:1;;;11016:36;11069:19;;11852:74:0;10866:228:1;11852:74:0;-1:-1:-1;;;;;11962:17:0;;;:9;:17;;;;;;;;;;;11982:22;;;11962:42;;12026:20;;;;;;;;:30;;11998:6;;11962:9;12026:30;;11998:6;;12026:30;:::i;:::-;;;;;;;;12091:9;-1:-1:-1;;;;;12074:35:0;12083:6;-1:-1:-1;;;;;12074:35:0;;12102:6;12074:35;;;;4432:25:1;;4420:2;4405:18;;4387:76;12074:35:0;;;;;;;;12122:46;12142:6;12150:9;12161:6;12122:19;:46::i;:::-;11443:733;;;;:::o;31297:281::-;31350:7;31391:16;31374:13;:33;31370:201;;;-1:-1:-1;31431:24:0;;31297:281::o;31370:201::-;-1:-1:-1;31767:73:0;;;31517:10;31767:73;;;;5745:25:1;;;;31529:12:0;5786:18:1;;;5779:34;31543:15:0;5829:18:1;;;5822:34;31811:13:0;5872:18:1;;;5865:34;31834:4:0;5915:19:1;;;;5908:61;;;;31767:73:0;;;;;;;;;;5717:19:1;;;;31767:73:0;;;31757:84;;;;;;36222:115::o;49759:1482::-;50892:12;;49858:7;;;50941:236;50954:4;50948:3;:10;50941:236;;;50975:11;50989:23;51002:3;51007:4;50989:12;:23::i;:::-;50975:37;;51054:11;51031:5;51037:3;51031:10;;;;;;-1:-1:-1;;;51031:10:0;;;;;;;;;;;;;;;;;;:20;;;:34;51027:139;;;51093:3;51086:10;;51027:139;;;51143:7;:3;51149:1;51143:7;:::i;:::-;51137:13;;51027:139;50941:236;;;;51196:9;;:37;;51212:5;51218:8;51225:1;51218:4;:8;:::i;:::-;51212:15;;;;;;-1:-1:-1;;;51212:15:0;;;;;;;;;;;;;;;;;;:21;;;;-1:-1:-1;;;;;51212:21:0;51196:37;;;51208:1;51196:37;-1:-1:-1;;;;;51189:44:0;;49759:1482;-1:-1:-1;;;;;49759:1482:0:o;58020:126::-;58112:28;58124:7;58133:6;58112:11;:28::i;:::-;58020:126;;:::o;57888:::-;57980:28;57992:7;58001:6;57980:11;:28::i;53560:388::-;-1:-1:-1;;;;;48380:19:0;;;53645:23;48380:19;;;:10;:19;;;;;;;;;;7495:18;;;;;;;53760:21;;;;:33;;;-1:-1:-1;;;;;;53760:33:0;;;;;;;53811:54;;48380:19;;;;;7495:18;;53760:33;;48380:19;;;53811:54;;53645:23;53811:54;53878:62;53895:15;53912:9;53923:16;53878;:62::i;40854:190::-;40910:6;40946:16;40937:25;;;40929:76;;;;-1:-1:-1;;;40929:76:0;;14913:2:1;40929:76:0;;;14895:21:1;14952:2;14932:18;;;14925:30;14991:34;14971:18;;;14964:62;-1:-1:-1;;;15042:18:1;;;15035:36;15088:19;;40929:76:0;14885:228:1;40929:76:0;-1:-1:-1;41030:5:0;40854:190::o;32491:167::-;32568:7;32595:55;32617:20;:18;:20::i;:::-;32639:10;28255:57;;-1:-1:-1;;;28255:57:0;;;3747:27:1;3790:11;;;3783:27;;;3826:12;;;3819:28;;;28218:7:0;;3863:12:1;;28255:57:0;;;;;;;;;;;;28245:68;;;;;;28238:75;;28125:196;;;;;26927:279;27055:7;27076:17;27095:18;27117:25;27128:4;27134:1;27137;27140;27117:10;:25::i;:::-;27075:67;;;;27153:18;27165:5;27153:11;:18::i;:::-;-1:-1:-1;27189:9:0;26927:279;-1:-1:-1;;;;;26927:279:0:o;36475:207::-;-1:-1:-1;;;;;36596:14:0;;36535:15;36596:14;;;:7;:14;;;;;33492;;33629:1;33611:19;;;;33492:14;36657:17;36475:207;;;;:::o;58152:164::-;58267:43;58293:4;58299:2;58303:6;58267:25;:43::i;37269:156::-;37331:7;37406:11;37416:1;37407:5;;;37406:11;:::i;:::-;37396:21;;37397:5;;;37396:21;:::i;52416:290::-;52501:28;52513:7;52522:6;52501:11;:28::i;:::-;7311:12;;-1:-1:-1;;;;;;52548:29:0;52540:90;;;;-1:-1:-1;;;52540:90:0;;12875:2:1;52540:90:0;;;12857:21:1;12914:2;12894:18;;;12887:30;12953:34;12933:18;;;12926:62;-1:-1:-1;;;13004:18:1;;;12997:46;13060:19;;52540:90:0;12847:238:1;52540:90:0;52643:55;52660:23;52685:4;52691:6;52643:16;:55::i;52800:194::-;52885:28;52897:7;52906:6;52885:11;:28::i;:::-;52926:60;52943:23;52968:9;52979:6;52926:16;:60::i;53956:643::-;54088:3;-1:-1:-1;;;;;54081:10:0;:3;-1:-1:-1;;;;;54081:10:0;;;:24;;;;;54104:1;54095:6;:10;54081:24;54077:515;;;-1:-1:-1;;;;;54126:17:0;;;54122:224;;-1:-1:-1;;;;;54222:17:0;;54165;54222;;;:12;:17;;;;;54165;;54205:54;;54241:9;54252:6;54205:16;:54::i;:::-;54164:95;;;;54304:3;-1:-1:-1;;;;;54283:47:0;;54309:9;54320;54283:47;;;;;;16996:25:1;;;17052:2;17037:18;;17030:34;16984:2;16969:18;;16951:119;54283:47:0;;;;;;;;54122:224;;;-1:-1:-1;;;;;54366:17:0;;;54362:219;;-1:-1:-1;;;;;54462:17:0;;54405;54462;;;:12;:17;;;;;54405;;54445:49;;54481:4;54487:6;54445:16;:49::i;:::-;54404:90;;;;54539:3;-1:-1:-1;;;;;54518:47:0;;54544:9;54555;54518:47;;;;;;16996:25:1;;;17052:2;17037:18;;17030:34;16984:2;16969:18;;16951:119;54518:47:0;;;;;;;;54362:219;;53956:643;;;:::o;25156:1632::-;25287:7;;26221:66;26208:79;;26204:163;;;-1:-1:-1;26320:1:0;;-1:-1:-1;26324:30:0;26304:51;;26204:163;26381:1;:7;;26386:2;26381:7;;:18;;;;;26392:1;:7;;26397:2;26392:7;;26381:18;26377:102;;;-1:-1:-1;26432:1:0;;-1:-1:-1;26436:30:0;26416:51;;26377:102;26593:24;;;26576:14;26593:24;;;;;;;;;6207:25:1;;;6280:4;6268:17;;6248:18;;;6241:45;;;;6302:18;;;6295:34;;;6345:18;;;6338:34;;;26593:24:0;;6179:19:1;;26593:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;26593:24:0;;-1:-1:-1;;26593:24:0;;;-1:-1:-1;;;;;;;26632:20:0;;26628:103;;26685:1;26689:29;26669:50;;;;;;;26628:103;26751:6;-1:-1:-1;26759:20:0;;-1:-1:-1;25156:1632:0;;;;;;;;:::o;19818:643::-;19896:20;19887:5;:29;;;;;;-1:-1:-1;;;19887:29:0;;;;;;;;;;19883:571;;;19818:643;:::o;19883:571::-;19994:29;19985:5;:38;;;;;;-1:-1:-1;;;19985:38:0;;;;;;;;;;19981:473;;;20040:34;;-1:-1:-1;;;20040:34:0;;7193:2:1;20040:34:0;;;7175:21:1;7232:2;7212:18;;;7205:30;7271:26;7251:18;;;7244:54;7315:18;;20040:34:0;7165:174:1;19981:473:0;20105:35;20096:5;:44;;;;;;-1:-1:-1;;;20096:44:0;;;;;;;;;;20092:362;;;20157:41;;-1:-1:-1;;;20157:41:0;;9071:2:1;20157:41:0;;;9053:21:1;9110:2;9090:18;;;9083:30;9149:33;9129:18;;;9122:61;9200:18;;20157:41:0;9043:181:1;20092:362:0;20229:30;20220:5;:39;;;;;;-1:-1:-1;;;20220:39:0;;;;;;;;;;20216:238;;;20276:44;;-1:-1:-1;;;20276:44:0;;11301:2:1;20276:44:0;;;11283:21:1;11340:2;11320:18;;;11313:30;11379:34;11359:18;;;11352:62;-1:-1:-1;;;11430:18:1;;;11423:32;11472:19;;20276:44:0;11273:224:1;20216:238:0;20351:30;20342:5;:39;;;;;;-1:-1:-1;;;20342:39:0;;;;;;;;;;20338:116;;;20398:44;;-1:-1:-1;;;20398:44:0;;11704:2:1;20398:44:0;;;11686:21:1;11743:2;11723:18;;;11716:30;11782:34;11762:18;;;11755:62;-1:-1:-1;;;11833:18:1;;;11826:32;11875:19;;20398:44:0;11676:224:1;53134:262:0;-1:-1:-1;;;;;48380:19:0;;;48353:7;48380:19;;;:10;:19;;;;;;;;;;;;;;;53332:56;;48380:19;;;;;53381:6;53332:16;:56::i;12463:399::-;-1:-1:-1;;;;;12547:21:0;;12539:65;;;;-1:-1:-1;;;12539:65:0;;16131:2:1;12539:65:0;;;16113:21:1;16170:2;16150:18;;;16143:30;16209:33;16189:18;;;16182:61;16260:18;;12539:65:0;16103:181:1;12539:65:0;12695:6;12679:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;12712:18:0;;:9;:18;;;;;;;;;;:28;;12734:6;;12712:9;:28;;12734:6;;12712:28;:::i;:::-;;;;-1:-1:-1;;12756:37:0;;4432:25:1;;;-1:-1:-1;;;;;12756:37:0;;;12773:1;;12756:37;;4420:2:1;4405:18;12756:37:0;;;;;;;12806:48;12834:1;12838:7;12847:6;12806:19;:48::i;55260:98::-;55318:7;55345:5;55349:1;55345;:5;:::i;54607:645::-;54844:12;;54781:17;;;;54879:8;;:35;;54894:5;54900:7;54906:1;54900:3;:7;:::i;:::-;54894:14;;;;;;-1:-1:-1;;;54894:14:0;;;;;;;;;;;;;;;;;;:20;;;;-1:-1:-1;;;;;54894:20:0;54879:35;;;54890:1;54879:35;-1:-1:-1;;;;;54867:47:0;;;54937:20;54940:9;54951:5;54937:2;:20;;:::i;:::-;54925:32;;54980:1;54974:3;:7;:51;;;;-1:-1:-1;55013:12:0;54985:5;54991:7;54997:1;54991:3;:7;:::i;:::-;54985:14;;;;;;-1:-1:-1;;;54985:14:0;;;;;;;;;;;;;;;;;;:24;;;:40;54974:51;54970:275;;;55065:29;55084:9;55065:18;:29::i;:::-;55042:5;55048:7;55054:1;55048:3;:7;:::i;:::-;55042:14;;;;;;-1:-1:-1;;;55042:14:0;;;;;;;;;;;;;;;;:20;;;:52;;;;;-1:-1:-1;;;;;55042:52:0;;;;;-1:-1:-1;;;;;55042:52:0;;;;;;54970:275;;;55127:5;55138:94;;;;;;;;55161:31;55179:12;55161:17;:31::i;:::-;55138:94;;;;;;55201:29;55220:9;55201:18;:29::i;:::-;-1:-1:-1;;;;;55138:94:0;;;;;;55127:106;;;;;;;-1:-1:-1;55127:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54970:275;54607:645;;;;;;;:::o;13195:591::-;-1:-1:-1;;;;;13279:21:0;;13271:67;;;;-1:-1:-1;;;13271:67:0;;14105:2:1;13271:67:0;;;14087:21:1;14144:2;14124:18;;;14117:30;14183:34;14163:18;;;14156:62;-1:-1:-1;;;14234:18:1;;;14227:31;14275:19;;13271:67:0;14077:223:1;13271:67:0;-1:-1:-1;;;;;13438:18:0;;13413:22;13438:18;;;;;;;;;;;13475:24;;;;13467:71;;;;-1:-1:-1;;;13467:71:0;;8668:2:1;13467:71:0;;;8650:21:1;8707:2;8687:18;;;8680:30;8746:34;8726:18;;;8719:62;-1:-1:-1;;;8797:18:1;;;8790:32;8839:19;;13467:71:0;8640:224:1;13467:71:0;-1:-1:-1;;;;;13574:18:0;;:9;:18;;;;;;;;;;13595:23;;;13574:44;;13640:12;:22;;13612:6;;13574:9;13640:22;;13612:6;;13640:22;:::i;:::-;;;;-1:-1:-1;;13680:37:0;;4432:25:1;;;13706:1:0;;-1:-1:-1;;;;;13680:37:0;;;;;4420:2:1;4405:18;13680:37:0;;;;;;;13730:48;13750:7;13767:1;13771:6;13730:19;:48::i;55366:103::-;55429:7;55456:5;55460:1;55456;:5;:::i;38884:195::-;38941:7;-1:-1:-1;;;;;38969:26:0;;;38961:78;;;;-1:-1:-1;;;38961:78:0;;13292:2:1;38961:78:0;;;13274:21:1;13331:2;13311:18;;;13304:30;13370:34;13350:18;;;13343:62;-1:-1:-1;;;13421:18:1;;;13414:37;13468:19;;38961:78:0;13264:229:1;14:173;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:156::-;258:20;;318:4;307:16;;297:27;;287:2;;338:1;335;328:12;353:196;412:6;465:2;453:9;444:7;440:23;436:32;433:2;;;486:6;478;471:22;433:2;514:29;533:9;514:29;:::i;554:270::-;622:6;630;683:2;671:9;662:7;658:23;654:32;651:2;;;704:6;696;689:22;651:2;732:29;751:9;732:29;:::i;:::-;722:39;;780:38;814:2;803:9;799:18;780:38;:::i;:::-;770:48;;641:183;;;;;:::o;829:338::-;906:6;914;922;975:2;963:9;954:7;950:23;946:32;943:2;;;996:6;988;981:22;943:2;1024:29;1043:9;1024:29;:::i;:::-;1014:39;;1072:38;1106:2;1095:9;1091:18;1072:38;:::i;:::-;1062:48;;1157:2;1146:9;1142:18;1129:32;1119:42;;933:234;;;;;:::o;1172:616::-;1283:6;1291;1299;1307;1315;1323;1331;1384:3;1372:9;1363:7;1359:23;1355:33;1352:2;;;1406:6;1398;1391:22;1352:2;1434:29;1453:9;1434:29;:::i;:::-;1424:39;;1482:38;1516:2;1505:9;1501:18;1482:38;:::i;:::-;1472:48;;1567:2;1556:9;1552:18;1539:32;1529:42;;1618:2;1607:9;1603:18;1590:32;1580:42;;1641:37;1673:3;1662:9;1658:19;1641:37;:::i;:::-;1631:47;;1725:3;1714:9;1710:19;1697:33;1687:43;;1777:3;1766:9;1762:19;1749:33;1739:43;;1342:446;;;;;;;;;;:::o;1793:264::-;1861:6;1869;1922:2;1910:9;1901:7;1897:23;1893:32;1890:2;;;1943:6;1935;1928:22;1890:2;1971:29;1990:9;1971:29;:::i;:::-;1961:39;2047:2;2032:18;;;;2019:32;;-1:-1:-1;;;1880:177:1:o;2062:541::-;2164:6;2172;2180;2188;2196;2204;2257:3;2245:9;2236:7;2232:23;2228:33;2225:2;;;2279:6;2271;2264:22;2225:2;2307:29;2326:9;2307:29;:::i;:::-;2297:39;;2383:2;2372:9;2368:18;2355:32;2345:42;;2434:2;2423:9;2419:18;2406:32;2396:42;;2457:36;2489:2;2478:9;2474:18;2457:36;:::i;:::-;2447:46;;2540:3;2529:9;2525:19;2512:33;2502:43;;2592:3;2581:9;2577:19;2564:33;2554:43;;2215:388;;;;;;;;:::o;2608:370::-;2675:6;2683;2736:2;2724:9;2715:7;2711:23;2707:32;2704:2;;;2757:6;2749;2742:22;2704:2;2785:29;2804:9;2785:29;:::i;:::-;2775:39;;2864:2;2853:9;2849:18;2836:32;2908:10;2901:5;2897:22;2890:5;2887:33;2877:2;;2939:6;2931;2924:22;2877:2;2967:5;2957:15;;;2694:284;;;;;:::o;2983:306::-;3041:6;3094:2;3082:9;3073:7;3069:23;3065:32;3062:2;;;3115:6;3107;3100:22;3062:2;3146:23;;-1:-1:-1;;;;;;3198:32:1;;3188:43;;3178:2;;3250:6;3242;3235:22;3294:190;3353:6;3406:2;3394:9;3385:7;3381:23;3377:32;3374:2;;;3427:6;3419;3412:22;3374:2;-1:-1:-1;3455:23:1;;3364:120;-1:-1:-1;3364:120:1:o;6383:603::-;6495:4;6524:2;6553;6542:9;6535:21;6585:6;6579:13;6628:6;6623:2;6612:9;6608:18;6601:34;6653:4;6666:140;6680:6;6677:1;6674:13;6666:140;;;6775:14;;;6771:23;;6765:30;6741:17;;;6760:2;6737:26;6730:66;6695:10;;6666:140;;;6824:6;6821:1;6818:13;6815:2;;;6894:4;6889:2;6880:6;6869:9;6865:22;6861:31;6854:45;6815:2;-1:-1:-1;6970:2:1;6949:15;-1:-1:-1;;6945:29:1;6930:45;;;;6977:2;6926:54;;6504:482;-1:-1:-1;;;6504:482:1:o;17461:128::-;17501:3;17532:1;17528:6;17525:1;17522:13;17519:2;;;17538:18;;:::i;:::-;-1:-1:-1;17574:9:1;;17509:80::o;17594:217::-;17634:1;17660;17650:2;;-1:-1:-1;;;17685:31:1;;17739:4;17736:1;17729:15;17767:4;17692:1;17757:15;17650:2;-1:-1:-1;17796:9:1;;17640:171::o;17816:125::-;17856:4;17884:1;17881;17878:8;17875:2;;;17889:18;;:::i;:::-;-1:-1:-1;17926:9:1;;17865:76::o;17946:380::-;18025:1;18021:12;;;;18068;;;18089:2;;18143:4;18135:6;18131:17;18121:27;;18089:2;18196;18188:6;18185:14;18165:18;18162:38;18159:2;;;18242:10;18237:3;18233:20;18230:1;18223:31;18277:4;18274:1;18267:15;18305:4;18302:1;18295:15;18331:127;18392:10;18387:3;18383:20;18380:1;18373:31;18423:4;18420:1;18413:15;18447:4;18444:1;18437:15
Swarm Source
ipfs://ec903c3d5691291e0ae4d262c27e283e4f0c7ac9bfbd9b9265a48a9773b23663
Loading...
Loading
OVERVIEW
BitANT is a governance token of BitBTC Protocol.10 billion BitANT have been minted at genesis, the team does not own any tokens: 80% liquidity is locked in DEX for 8 years; 15%,community airdrops; 5%,community mining. The exchange fee of the platform is mainly used to repurchase and burn BitANT.Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ZKSYNC | 100.00% | $2,705.95 | 0.007 | $18.94 |
[ 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.