Warning! Contract bytecode has been changed and doesn't match the verified one. Therefore, interaction with this smart contract may be risky.
- Contract name:
- BridgedTaikoToken
- Optimization enabled
- true
- Compiler version
- v0.8.24+commit.e11b9ed9
- Optimization runs
- 200
- EVM Version
- cancun
- Verified at
- 2024-05-27T10:10:58.847132Z
contracts/tko/BridgedTaikoToken.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;import "../tokenvault/IBridgedERC20.sol";import "./TaikoTokenBase.sol";/// @title BridgedTaikoToken/// @notice The TaikoToken on L2 to support checkpoints and voting. For testnets, we do not need to/// use this contract./// @custom:security-contact security@taiko.xyzcontract BridgedTaikoToken is TaikoTokenBase, IBridgedERC20 {/// @notice Initializes the contract./// @param _owner The owner of this contract. msg.sender will be used if this value is zero./// @param _addressManager The address manager address.function init(address _owner, address _addressManager) external initializer {__Essential_init(_owner, _addressManager);__ERC20_init("Taiko Token", "TKO");__ERC20Votes_init();__ERC20Permit_init("Taiko Token");}function mint(address _account,uint256 _amount)externaloverridewhenNotPausedonlyFromOwnerOrNamed(LibStrings.B_ERC20_VAULT)nonReentrant{_mint(_account, _amount);}function burn(uint256 _amount)externaloverridewhenNotPausedonlyFromOwnerOrNamed(LibStrings.B_ERC20_VAULT)nonReentrant{
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20VotesUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Votes.sol)pragma solidity ^0.8.0;import "./ERC20PermitUpgradeable.sol";import "../../../interfaces/IERC5805Upgradeable.sol";import "../../../utils/math/MathUpgradeable.sol";import "../../../utils/math/SafeCastUpgradeable.sol";import "../../../utils/cryptography/ECDSAUpgradeable.sol";import {Initializable} from "../../../proxy/utils/Initializable.sol";/*** @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.** _Available since v4.2._*/abstract contract ERC20VotesUpgradeable is Initializable, ERC20PermitUpgradeable, IERC5805Upgradeable {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;function __ERC20Votes_init() internal onlyInitializing {
node_modules/@openzeppelin/contracts-upgradeable/interfaces/IERC6372Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC6372.sol)pragma solidity ^0.8.0;interface IERC6372Upgradeable {/*** @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).*/function clock() external view returns (uint48);/*** @dev Description of the clock*/// solhint-disable-next-line func-name-mixedcasefunction CLOCK_MODE() external view returns (string memory);}
node_modules/@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)pragma solidity ^0.8.2;import "../beacon/IBeacon.sol";import "../../interfaces/IERC1967.sol";import "../../interfaces/draft-IERC1822.sol";import "../../utils/Address.sol";import "../../utils/StorageSlot.sol";/*** @dev This abstract contract provides getters and event emitting update functions for* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.** _Available since v4.1._*/abstract contract ERC1967Upgrade is IERC1967 {// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;/*** @dev Storage slot with the address of the current implementation.* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is* validated in the constructor.*/bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;/*** @dev Returns the current implementation address.*/function _getImplementation() internal view returns (address) {return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;}/*** @dev Stores a new address in the EIP1967 implementation slot.*/function _setImplementation(address newImplementation) private {require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
node_modules/@openzeppelin/contracts/interfaces/IERC1967.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)pragma solidity ^0.8.0;/*** @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.** _Available since v4.8.3._*/interface IERC1967 {/*** @dev Emitted when the implementation is upgraded.*/event Upgraded(address indexed implementation);/*** @dev Emitted when the admin account has changed.*/event AdminChanged(address previousAdmin, address newAdmin);/*** @dev Emitted when the beacon is changed.*/event BeaconUpgraded(address indexed beacon);}
node_modules/@openzeppelin/contracts/proxy/beacon/IBeacon.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)pragma solidity ^0.8.0;/*** @dev This is the interface that {BeaconProxy} expects of its beacon.*/interface IBeacon {/*** @dev Must return an address that can be used as a delegate call target.** {BeaconProxy} will check that this address is a contract.*/function implementation() external view returns (address);}
node_modules/@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// SPDX-License-Identifier: MIT// 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 AddressUpgradeable {/*** @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
contracts/common/AddressResolver.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";import "./IAddressManager.sol";import "./IAddressResolver.sol";/// @title AddressResolver/// @notice See the documentation in {IAddressResolver}./// @custom:security-contact security@taiko.xyzabstract contract AddressResolver is IAddressResolver, Initializable {/// @notice Address of the AddressManager.address public addressManager;uint256[49] private __gap;error RESOLVER_DENIED();error RESOLVER_INVALID_MANAGER();error RESOLVER_UNEXPECTED_CHAINID();error RESOLVER_ZERO_ADDR(uint64 chainId, bytes32 name);/// @dev Modifier that ensures the caller is the resolved address of a given/// name./// @param _name The name to check against.modifier onlyFromNamed(bytes32 _name) {if (msg.sender != resolve(_name, true)) revert RESOLVER_DENIED();_;}/// @dev Modifier that ensures the caller is a resolved address to either _name1 or _name2/// name./// @param _name1 The first name to check against./// @param _name2 The second name to check against.modifier onlyFromNamedEither(bytes32 _name1, bytes32 _name2) {if (msg.sender != resolve(_name1, true) && msg.sender != resolve(_name2, true)) {revert RESOLVER_DENIED();}_;}/// @custom:oz-upgrades-unsafe-allow constructorconstructor() {
node_modules/@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)pragma solidity ^0.8.0;import "./OwnableUpgradeable.sol";import {Initializable} from "../proxy/utils/Initializable.sol";/*** @dev Contract module which provides access control mechanism, where* there is an account (an owner) that can be granted exclusive access to* specific functions.** By default, the owner account will be the one that deploys the contract. This* can later be changed with {transferOwnership} and {acceptOwnership}.** This module is used through inheritance. It will make available all functions* from parent (Ownable).*/abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {address private _pendingOwner;event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);function __Ownable2Step_init() internal onlyInitializing {__Ownable_init_unchained();}function __Ownable2Step_init_unchained() internal onlyInitializing {}/*** @dev Returns the address of the pending owner.*/function pendingOwner() public view virtual returns (address) {return _pendingOwner;}/*** @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.* Can only be called by the current owner.*/
node_modules/@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)// This file was procedurally generated from scripts/generate/templates/SafeCast.js.pragma solidity ^0.8.0;/*** @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 SafeCastUpgradeable {/*** @dev Returns the downcasted uint248 from uint256, reverting on* overflow (when the input is greater than largest uint248).** Counterpart to Solidity's `uint248` operator.** Requirements:** - input must fit into 248 bits** _Available since v4.7._*/function toUint248(uint256 value) internal pure returns (uint248) {require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");return uint248(value);}/*** @dev Returns the downcasted uint240 from uint256, reverting on
contracts/common/IAddressManager.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @title IAddressManager/// @notice Manages a mapping of (chainId, name) pairs to Ethereum addresses./// @custom:security-contact security@taiko.xyzinterface IAddressManager {/// @notice Gets the address mapped to a specific chainId-name pair./// @dev Note that in production, this method shall be a pure function/// without any storage access./// @param _chainId The chainId for which the address needs to be fetched./// @param _name The name for which the address needs to be fetched./// @return Address associated with the chainId-name pair.function getAddress(uint64 _chainId, bytes32 _name) external view returns (address);}
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/ERC20Permit.sol)pragma solidity ^0.8.0;import "./IERC20PermitUpgradeable.sol";import "../ERC20Upgradeable.sol";import "../../../utils/cryptography/ECDSAUpgradeable.sol";import "../../../utils/cryptography/EIP712Upgradeable.sol";import "../../../utils/CountersUpgradeable.sol";import {Initializable} from "../../../proxy/utils/Initializable.sol";/*** @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].** Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by* presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't* need to send a transaction, and thus is not required to hold Ether at all.** _Available since v3.4._** @custom:storage-size 51*/abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {using CountersUpgradeable for CountersUpgradeable.Counter;mapping(address => CountersUpgradeable.Counter) private _nonces;// solhint-disable-next-line var-name-mixedcasebytes32 private constant _PERMIT_TYPEHASH =keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");/*** @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.* However, to ensure consistency with the upgradeable transpiler, we will continue* to reserve a slot.* @custom:oz-renamed-from _PERMIT_TYPEHASH*/// solhint-disable-next-line var-name-mixedcasebytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
contracts/libs/LibNetwork.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @title LibNetworklibrary LibNetwork {uint256 internal constant MAINNET = 1;uint256 internal constant ROPSTEN = 2;uint256 internal constant RINKEBY = 4;uint256 internal constant GOERLI = 5;uint256 internal constant KOVAN = 42;uint256 internal constant HOLESKY = 17_000;uint256 internal constant SEPOLIA = 11_155_111;uint64 internal constant TAIKO = 167_000;/// @dev Checks if the chain ID represents an Ethereum testnet./// @param _chainId The chain ID./// @return true if the chain ID represents an Ethereum testnet, false otherwise.function isEthereumTestnet(uint256 _chainId) internal pure returns (bool) {return _chainId == LibNetwork.ROPSTEN || _chainId == LibNetwork.RINKEBY|| _chainId == LibNetwork.GOERLI || _chainId == LibNetwork.KOVAN|| _chainId == LibNetwork.HOLESKY || _chainId == LibNetwork.SEPOLIA;}/// @dev Checks if the chain ID represents an Ethereum testnet or the Etheruem mainnet./// @param _chainId The chain ID./// @return true if the chain ID represents an Ethereum testnet or the Etheruem mainnet, false/// otherwise.function isEthereumMainnetOrTestnet(uint256 _chainId) internal pure returns (bool) {return _chainId == LibNetwork.MAINNET || isEthereumTestnet(_chainId);}/// @dev Checks if the chain ID represents the Taiko L2 mainnet./// @param _chainId The chain ID./// @return true if the chain ID represents the Taiko L2 mainnet.function isTaikoMainnet(uint256 _chainId) internal pure returns (bool) {return _chainId == TAIKO;}/// @dev Checks if the chain ID represents an internal Taiko devnet's base layer./// @param _chainId The chain ID.
node_modules/@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)pragma solidity ^0.8.0;import "../../interfaces/draft-IERC1822.sol";import "../ERC1967/ERC1967Upgrade.sol";/*** @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.** A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing* `UUPSUpgradeable` with a custom implementation of upgrades.** The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.** _Available since v4.1._*/abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignmentaddress private immutable __self = address(this);/*** @dev Check that the execution is being performed through a delegatecall call and that the execution context is* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to* fail.*/modifier onlyProxy() {require(address(this) != __self, "Function must be called through delegatecall");require(_getImplementation() == __self, "Function must be called through active proxy");_;}/*** @dev Check that the execution is not being performed through a delegate call. This allows a function to be* callable on the implementing contract but not through proxies.*/
contracts/tokenvault/IBridgedERC20.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @title IBridgedERC20/// @notice Interface for all bridged tokens./// @dev To facilitate compatibility with third-party bridged tokens, such as USDC's native/// standard, it's necessary to implement an intermediary adapter contract which should conform to/// this interface, enabling effective interaction with third-party contracts./// @custom:security-contact security@taiko.xyzinterface IBridgedERC20 {/// @notice Mints `amount` tokens and assigns them to the `account` address./// @param _account The account to receive the minted tokens./// @param _amount The amount of tokens to mint.function mint(address _account, uint256 _amount) external;/// @notice Burns tokens from msg.sender. This is only allowed if:/// - 1) tokens are migrating out to a new bridged token/// - 2) The token is burned by ERC20Vault to bridge back to the canonical chain./// @param _amount The amount of tokens to burn.function burn(uint256 _amount) external;/// @notice Gets the canonical token's address and chain ID./// @return The canonical token's address./// @return The canonical token's chain ID.function canonical() external view returns (address, uint256);}/// @title IBridgedERC20Migratable/// @custom:security-contact security@taiko.xyzinterface IBridgedERC20Migratable {/// @notice Starts or stops migration to/from a specified contract./// @param _addr The address migrating 'to' or 'from'./// @param _inbound If false then signals migrating 'from', true if migrating 'into'.function changeMigrationStatus(address _addr, bool _inbound) external;}/// @title IBridgedERC20Initializable/// @custom:security-contact security@taiko.xyzinterface IBridgedERC20Initializable {/// @notice Initializes the contract./// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
contracts/tko/TaikoTokenBase.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20VotesUpgradeable.sol";import "../common/EssentialContract.sol";import "../common/LibStrings.sol";/// @notice TaikoToken was `EssentialContract, ERC20SnapshotUpgradeable, ERC20VotesUpgradeable`./// We use this contract to take 50 more slots to remove `ERC20SnapshotUpgradeable` from the parent/// contract list./// We can simplify the code since we no longer need to maintain upgradability with Hekla.abstract contract TaikoTokenBase0 is EssentialContract {// solhint-disable var-name-mixedcaseuint256[50] private __slots_previously_used_by_ERC20SnapshotUpgradeable;}/// @title TaikoTokenBase/// @notice The base contract for both the canonical and the bridged Taiko token./// @custom:security-contact security@taiko.xyzabstract contract TaikoTokenBase is TaikoTokenBase0, ERC20VotesUpgradeable {uint256[50] private __gap;function clock() public view override returns (uint48) {return SafeCastUpgradeable.toUint48(block.timestamp);}// solhint-disable-next-line func-name-mixedcasefunction CLOCK_MODE() public pure override returns (string memory) {// See https://eips.ethereum.org/EIPS/eip-6372return "mode=timestamp";}}
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)pragma solidity ^0.8.0;import "../IERC20Upgradeable.sol";/*** @dev Interface for the optional metadata functions from the ERC20 standard.** _Available since v4.1._*/interface IERC20MetadataUpgradeable is IERC20Upgradeable {/*** @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);}
node_modules/@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)pragma solidity ^0.8.0;import "../StringsUpgradeable.sol";/*** @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.** These functions can be used to verify that a message was signed by the holder* of the private keys of a given address.*/library ECDSAUpgradeable {enum RecoverError {NoError,InvalidSignature,InvalidSignatureLength,InvalidSignatureS,InvalidSignatureV // Deprecated in v4.8}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");}}/*** @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.
node_modules/@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)pragma solidity ^0.8.0;/*** @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 CountersUpgradeable {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/4637uint256 _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;
contracts/common/IAddressResolver.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @title IAddressResolver/// @notice This contract acts as a bridge for name-to-address resolution./// It delegates the resolution to the AddressManager. By separating the logic,/// we can maintain flexibility in address management without affecting the/// resolving process./// @dev Note that the address manager should be changed using upgradability, there/// is no setAddressManager() function to guarantee atomicity across all/// contracts that are resolvers./// @custom:security-contact security@taiko.xyzinterface IAddressResolver {/// @notice Resolves a name to its address deployed on this chain./// @param _name Name whose address is to be resolved./// @param _allowZeroAddress If set to true, does not throw if the resolved/// address is `address(0)`./// @return Address associated with the given name.function resolve(bytes32 _name,bool _allowZeroAddress)externalviewreturns (address payable);/// @notice Resolves a name to its address deployed on a specified chain./// @param _chainId The chainId of interest./// @param _name Name whose address is to be resolved./// @param _allowZeroAddress If set to true, does not throw if the resolved/// address is `address(0)`./// @return Address associated with the given name on the specified/// chain.function resolve(uint64 _chainId,bytes32 _name,bool _allowZeroAddress)externalviewreturns (address payable);
node_modules/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)pragma solidity ^0.8.0;import {Initializable} from "../proxy/utils/Initializable.sol";/*** @dev Provides information about the current execution context, including the* sender of the transaction and its data. While these are generally available* via msg.sender and msg.data, they should not be accessed in such a direct* manner, since when dealing with 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 ContextUpgradeable is Initializable {function __Context_init() internal onlyInitializing {}function __Context_init_unchained() internal onlyInitializing {}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;}/*** @dev This empty reserved space is put in place to allow future versions to add new* variables without shifting down storage in the inheritance chain.* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps*/uint256[50] private __gap;}
node_modules/@openzeppelin/contracts-upgradeable/interfaces/IERC5805Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5805.sol)pragma solidity ^0.8.0;import "../governance/utils/IVotesUpgradeable.sol";import "./IERC6372Upgradeable.sol";interface IERC5805Upgradeable is IERC6372Upgradeable, IVotesUpgradeable {}
node_modules/@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (governance/utils/IVotes.sol)pragma solidity ^0.8.0;/*** @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.** _Available since v4.5._*/interface IVotesUpgradeable {/*** @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 a delegate's number of votes.*/event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);/*** @dev Returns the current amount of votes that `account` has.*/function getVotes(address account) external view returns (uint256);/*** @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is* configured to use block numbers, this will return the value at the end of the corresponding block.*/function getPastVotes(address account, uint256 timepoint) external view returns (uint256);/*** @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is* configured to use block numbers, this will return the value at the end of the corresponding block.** NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.* Votes that have not been delegated are still part of total supply, even though they would not participate in a* vote.*/function getPastTotalSupply(uint256 timepoint) external view returns (uint256);
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)pragma solidity ^0.8.0;/*** @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.** ==== 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.*/
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)pragma solidity ^0.8.0;/*** @dev Interface of the ERC20 standard as defined in the EIP.*/interface IERC20Upgradeable {/*** @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 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 `to`.** Returns a boolean value indicating whether the operation succeeded.** Emits a {Transfer} event.*/function transfer(address to, uint256 amount) external returns (bool);
node_modules/@openzeppelin/contracts/utils/StorageSlot.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.pragma solidity ^0.8.0;/*** @dev Library for reading and writing primitive types to specific storage slots.** Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.* This library helps with reading and writing to such slots without the need for inline assembly.** The functions in this library return Slot structs that contain a `value` member that can be used to read or write.** Example usage to set ERC1967 implementation slot:* ```solidity* contract ERC1967 {* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;** function _getImplementation() internal view returns (address) {* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;* }** function _setImplementation(address newImplementation) internal {* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;* }* }* ```** _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._* _Available since v4.9 for `string`, `bytes`._*/library StorageSlot {struct AddressSlot {address value;}struct BooleanSlot {bool value;}
contracts/common/LibStrings.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @title LibStrings/// @custom:security-contact security@taiko.xyzlibrary LibStrings {bytes32 internal constant B_ASSIGNMENT_HOOK = bytes32("assignment_hook");bytes32 internal constant B_AUTOMATA_DCAP_ATTESTATION = bytes32("automata_dcap_attestation");bytes32 internal constant B_BRIDGE = bytes32("bridge");bytes32 internal constant B_BRIDGE_WATCHDOG = bytes32("bridge_watchdog");bytes32 internal constant B_BRIDGED_ERC1155 = bytes32("bridged_erc1155");bytes32 internal constant B_BRIDGED_ERC20 = bytes32("bridged_erc20");bytes32 internal constant B_BRIDGED_ERC721 = bytes32("bridged_erc721");bytes32 internal constant B_CHAIN_WATCHDOG = bytes32("chain_watchdog");bytes32 internal constant B_ERC1155_VAULT = bytes32("erc1155_vault");bytes32 internal constant B_ERC20_VAULT = bytes32("erc20_vault");bytes32 internal constant B_ERC721_VAULT = bytes32("erc721_vault");bytes32 internal constant B_PROPOSER = bytes32("proposer");bytes32 internal constant B_PROPOSER_ONE = bytes32("proposer_one");bytes32 internal constant B_PROVER_ASSIGNMENT = bytes32("PROVER_ASSIGNMENT");bytes32 internal constant B_PROVER_SET = bytes32("prover_set");bytes32 internal constant B_QUOTA_MANAGER = bytes32("quota_manager");bytes32 internal constant B_SGX_WATCHDOG = bytes32("sgx_watchdog");bytes32 internal constant B_SIGNAL_SERVICE = bytes32("signal_service");bytes32 internal constant B_TAIKO = bytes32("taiko");bytes32 internal constant B_TAIKO_TOKEN = bytes32("taiko_token");bytes32 internal constant B_TIER_GUARDIAN = bytes32("tier_guardian");bytes32 internal constant B_TIER_GUARDIAN_MINORITY = bytes32("tier_guardian_minority");bytes32 internal constant B_TIER_PROVIDER = bytes32("tier_provider");bytes32 internal constant B_TIER_SGX = bytes32("tier_sgx");bytes32 internal constant B_TIER_SGX_ZKVM = bytes32("tier_sgx_zkvm");bytes32 internal constant B_WITHDRAWER = bytes32("withdrawer");bytes32 internal constant H_RETURN_LIVENESS_BOND = keccak256("RETURN_LIVENESS_BOND");bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT");bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");}
node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)pragma solidity ^0.8.2;import "../../utils/AddressUpgradeable.sol";/*** @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.** The initialization functions use a version number. Once a version number is used, it is consumed and cannot be* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in* case an upgrade adds a module that needs to be initialized.** For example:** [.hljs-theme-light.nopadding]* ```solidity* contract MyToken is ERC20Upgradeable {* function initialize() initializer public {* __ERC20_init("MyToken", "MTK");* }* }** contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {* function initializeV2() reinitializer(2) public {* __ERC20Permit_init("MyToken");* }* }* ```** TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.** CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.** [CAUTION]
node_modules/@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol)pragma solidity ^0.8.8;import "./ECDSAUpgradeable.sol";import "../../interfaces/IERC5267Upgradeable.sol";import {Initializable} from "../../proxy/utils/Initializable.sol";/*** @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.** The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,* thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding* they need in their contracts using a combination of `abi.encode` and `keccak256`.** This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA* ({_hashTypedDataV4}).** The implementation of the domain separator was designed to be as efficient as possible while still properly updating* the chain id to protect against replay attacks on an eventual fork of the chain.** NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].** NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain* separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the* separator from the immutable values, which is cheaper than accessing a cached version in cold storage.** _Available since v3.4._** @custom:storage-size 52*/abstract contract EIP712Upgradeable is Initializable, IERC5267Upgradeable {bytes32 private constant _TYPE_HASH =keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");/// @custom:oz-renamed-from _HASHED_NAMEbytes32 private _hashedName;/// @custom:oz-renamed-from _HASHED_VERSION
node_modules/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)pragma solidity ^0.8.0;import "../utils/ContextUpgradeable.sol";import {Initializable} from "../proxy/utils/Initializable.sol";/*** @dev Contract module which provides a basic access control mechanism, where* there is an account (an owner) that can be granted exclusive access to* specific functions.** By default, the owner account will be the one that deploys the contract. This* can later be changed with {transferOwnership}.** This module is used through inheritance. It will make available the modifier* `onlyOwner`, which can be applied to your functions to restrict their use to* the owner.*/abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {address private _owner;event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);/*** @dev Initializes the contract setting the deployer as the initial owner.*/function __Ownable_init() internal onlyInitializing {__Ownable_init_unchained();}function __Ownable_init_unchained() internal onlyInitializing {_transferOwnership(_msgSender());}/*** @dev Throws if called by any account other than the owner.*/modifier onlyOwner() {_checkOwner();
node_modules/@openzeppelin/contracts/interfaces/draft-IERC1822.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)pragma solidity ^0.8.0;/*** @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified* proxy whose upgrades are fully controlled by the current implementation.*/interface IERC1822Proxiable {/*** @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation* address.** IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this* function revert if invoked through a proxy.*/function proxiableUUID() external view returns (bytes32);}
node_modules/@openzeppelin/contracts/utils/Address.sol
// SPDX-License-Identifier: MIT// 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
node_modules/@openzeppelin/contracts-upgradeable/interfaces/IERC5267Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)pragma solidity ^0.8.0;interface IERC5267Upgradeable {/*** @dev MAY be emitted to signal that the domain could have changed.*/event EIP712DomainChanged();/*** @dev returns the fields and values that describe the domain separator used by this contract for EIP-712* signature.*/function eip712Domain()externalviewreturns (bytes1 fields,string memory name,string memory version,uint256 chainId,address verifyingContract,bytes32 salt,uint256[] memory extensions);}
node_modules/@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)pragma solidity ^0.8.0;/*** @dev Standard math utilities missing in the Solidity language.*/library MathUpgradeable {enum Rounding {Down, // Toward negative infinityUp, // Toward infinityZero // Toward zero}/*** @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.*
node_modules/@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)pragma solidity ^0.8.0;/*** @dev Standard signed math utilities missing in the Solidity language.*/library SignedMathUpgradeable {/*** @dev Returns the largest of two signed numbers.*/function max(int256 a, int256 b) internal pure returns (int256) {return a > b ? a : b;}/*** @dev Returns the smallest of two signed numbers.*/function min(int256 a, int256 b) internal pure returns (int256) {return a < b ? a : b;}/*** @dev Returns the average of two signed numbers without overflow.* The result is rounded towards zero.*/function average(int256 a, int256 b) internal pure returns (int256) {// Formula from the book "Hacker's Delight"int256 x = (a & b) + ((a ^ b) >> 1);return x + (int256(uint256(x) >> 255) & (a ^ b));}/*** @dev Returns the absolute unsigned value of a signed value.*/function abs(int256 n) internal pure returns (uint256) {unchecked {// must be unchecked in order to support `n = type(int256).min`return uint256(n >= 0 ? n : -n);}
node_modules/@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)pragma solidity ^0.8.0;import "./IERC20Upgradeable.sol";import "./extensions/IERC20MetadataUpgradeable.sol";import "../../utils/ContextUpgradeable.sol";import {Initializable} from "../../proxy/utils/Initializable.sol";/*** @dev Implementation of the {IERC20} interface.** This implementation is agnostic to the way tokens are created. This means* that a supply mechanism has to be added in a derived contract using {_mint}.* For a generic mechanism see {ERC20PresetMinterPauser}.** TIP: For a detailed writeup see our guide* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How* to implement supply mechanisms].** The default value of {decimals} is 18. To change this, you should override* this function so it returns a different value.** We have followed general OpenZeppelin Contracts guidelines: functions revert* instead returning `false` on failure. This behavior is nonetheless* conventional and does not conflict with the expectations of ERC20* applications.** Additionally, an {Approval} event is emitted on calls to {transferFrom}.* This allows applications to reconstruct the allowance for all accounts just* by listening to said events. Other implementations of the EIP may not emit* these events, as it isn't required by the specification.** Finally, the non-standard {decreaseAllowance} and {increaseAllowance}* functions have been added to mitigate the well-known issues around setting* allowances. See {IERC20-approve}.*/contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {mapping(address => uint256) private _balances;
node_modules/@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)pragma solidity ^0.8.0;import "./math/MathUpgradeable.sol";import "./math/SignedMathUpgradeable.sol";/*** @dev String operations.*/library StringsUpgradeable {bytes16 private constant _SYMBOLS = "0123456789abcdef";uint8 private constant _ADDRESS_LENGTH = 20;/*** @dev Converts a `uint256` to its ASCII `string` decimal representation.*/function toString(uint256 value) internal pure returns (string memory) {unchecked {uint256 length = MathUpgradeable.log10(value) + 1;string memory buffer = new string(length);uint256 ptr;/// @solidity memory-safe-assemblyassembly {ptr := add(buffer, add(32, length))}while (true) {ptr--;/// @solidity memory-safe-assemblyassembly {mstore8(ptr, byte(mod(value, 10), _SYMBOLS))}value /= 10;if (value == 0) break;}return buffer;}}/**
contracts/common/EssentialContract.sol
// SPDX-License-Identifier: MITpragma solidity 0.8.24;import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";import "./AddressResolver.sol";import "../libs/LibNetwork.sol";/// @title EssentialContract/// @custom:security-contact security@taiko.xyzabstract contract EssentialContract is UUPSUpgradeable, Ownable2StepUpgradeable, AddressResolver {uint8 private constant _FALSE = 1;uint8 private constant _TRUE = 2;/// @dev The slot in transient storage of the reentry lock./// This is the result of keccak256("ownerUUPS.reentry_slot") plus 1. The addition aims to/// prevent hash collisions with slots defined in EIP-1967, where slots are derived by/// keccak256("something") - 1, and with slots in SignalService, calculated directly with/// keccak256("something").bytes32 private constant _REENTRY_SLOT =0xa5054f728453d3dbe953bdc43e4d0cb97e662ea32d7958190f3dc2da31d9721b;/// @dev Slot 1.uint8 private __reentry;uint8 private __paused;uint64 public lastUnpausedAt;uint256[49] private __gap;/// @notice Emitted when the contract is paused./// @param account The account that paused the contract.event Paused(address account);/// @notice Emitted when the contract is unpaused./// @param account The account that unpaused the contract.event Unpaused(address account);error INVALID_PAUSE_STATUS();error FUNC_NOT_IMPLEMENTED();error REENTRANT_CALL();
Compiler Settings
{"viaIR":false,"remappings":["@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/","@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/","solady/=node_modules/solady/","forge-std/=node_modules/forge-std/","ds-test/=node_modules/ds-test/src/","p256-verifier/=node_modules/p256-verifier/"],"outputSelection":{"*":{"*":["*"],"":["*"]}},"optimizer":{"runs":200,"enabled":true},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"libraries":{},"evmVersion":"cancun"}
Contract ABI
[{"type":"error","name":"FUNC_NOT_IMPLEMENTED","inputs":[]},{"type":"error","name":"INVALID_PAUSE_STATUS","inputs":[]},{"type":"error","name":"REENTRANT_CALL","inputs":[]},{"type":"error","name":"RESOLVER_DENIED","inputs":[]},{"type":"error","name":"RESOLVER_INVALID_MANAGER","inputs":[]},{"type":"error","name":"RESOLVER_UNEXPECTED_CHAINID","inputs":[]},{"type":"error","name":"RESOLVER_ZERO_ADDR","inputs":[{"type":"uint64","name":"chainId","internalType":"uint64"},{"type":"bytes32","name":"name","internalType":"bytes32"}]},{"type":"error","name":"ZERO_ADDRESS","inputs":[]},{"type":"error","name":"ZERO_VALUE","inputs":[]},{"type":"event","name":"AdminChanged","inputs":[{"type":"address","name":"previousAdmin","internalType":"address","indexed":false},{"type":"address","name":"newAdmin","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Approval","inputs":[{"type":"address","name":"owner","internalType":"address","indexed":true},{"type":"address","name":"spender","internalType":"address","indexed":true},{"type":"uint256","name":"value","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"BeaconUpgraded","inputs":[{"type":"address","name":"beacon","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"DelegateChanged","inputs":[{"type":"address","name":"delegator","internalType":"address","indexed":true},{"type":"address","name":"fromDelegate","internalType":"address","indexed":true},{"type":"address","name":"toDelegate","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"DelegateVotesChanged","inputs":[{"type":"address","name":"delegate","internalType":"address","indexed":true},{"type":"uint256","name":"previousBalance","internalType":"uint256","indexed":false},{"type":"uint256","name":"newBalance","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"EIP712DomainChanged","inputs":[],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"type":"uint8","name":"version","internalType":"uint8","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferStarted","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"Paused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Transfer","inputs":[{"type":"address","name":"from","internalType":"address","indexed":true},{"type":"address","name":"to","internalType":"address","indexed":true},{"type":"uint256","name":"value","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Unpaused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Upgraded","inputs":[{"type":"address","name":"implementation","internalType":"address","indexed":true}],"anonymous":false},{"type":"function","stateMutability":"pure","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"CLOCK_MODE","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"DOMAIN_SEPARATOR","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"acceptOwnership","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"addressManager","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"allowance","inputs":[{"type":"address","name":"owner","internalType":"address"},{"type":"address","name":"spender","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"approve","inputs":[{"type":"address","name":"spender","internalType":"address"},{"type":"uint256","name":"amount","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"balanceOf","inputs":[{"type":"address","name":"account","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"burn","inputs":[{"type":"uint256","name":"_amount","internalType":"uint256"}]},{"type":"function","stateMutability":"pure","outputs":[{"type":"address","name":"","internalType":"address"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"canonical","inputs":[]},{"type":"function","stateMutability":"pure","outputs":[],"name":"changeMigrationStatus","inputs":[{"type":"address","name":"","internalType":"address"},{"type":"bool","name":"","internalType":"bool"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"tuple","name":"","internalType":"struct ERC20VotesUpgradeable.Checkpoint","components":[{"type":"uint32","name":"fromBlock","internalType":"uint32"},{"type":"uint224","name":"votes","internalType":"uint224"}]}],"name":"checkpoints","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint32","name":"pos","internalType":"uint32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint48","name":"","internalType":"uint48"}],"name":"clock","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint8","name":"","internalType":"uint8"}],"name":"decimals","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"decreaseAllowance","inputs":[{"type":"address","name":"spender","internalType":"address"},{"type":"uint256","name":"subtractedValue","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"delegate","inputs":[{"type":"address","name":"delegatee","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"delegateBySig","inputs":[{"type":"address","name":"delegatee","internalType":"address"},{"type":"uint256","name":"nonce","internalType":"uint256"},{"type":"uint256","name":"expiry","internalType":"uint256"},{"type":"uint8","name":"v","internalType":"uint8"},{"type":"bytes32","name":"r","internalType":"bytes32"},{"type":"bytes32","name":"s","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"delegates","inputs":[{"type":"address","name":"account","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes1","name":"fields","internalType":"bytes1"},{"type":"string","name":"name","internalType":"string"},{"type":"string","name":"version","internalType":"string"},{"type":"uint256","name":"chainId","internalType":"uint256"},{"type":"address","name":"verifyingContract","internalType":"address"},{"type":"bytes32","name":"salt","internalType":"bytes32"},{"type":"uint256[]","name":"extensions","internalType":"uint256[]"}],"name":"eip712Domain","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getPastTotalSupply","inputs":[{"type":"uint256","name":"timepoint","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getPastVotes","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256","name":"timepoint","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getVotes","inputs":[{"type":"address","name":"account","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"impl","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"inNonReentrant","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"increaseAllowance","inputs":[{"type":"address","name":"spender","internalType":"address"},{"type":"uint256","name":"addedValue","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"init","inputs":[{"type":"address","name":"_owner","internalType":"address"},{"type":"address","name":"_addressManager","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint64","name":"","internalType":"uint64"}],"name":"lastUnpausedAt","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"mint","inputs":[{"type":"address","name":"_account","internalType":"address"},{"type":"uint256","name":"_amount","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"name","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"nonces","inputs":[{"type":"address","name":"owner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint32","name":"","internalType":"uint32"}],"name":"numCheckpoints","inputs":[{"type":"address","name":"account","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"pause","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"paused","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"pendingOwner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"permit","inputs":[{"type":"address","name":"owner","internalType":"address"},{"type":"address","name":"spender","internalType":"address"},{"type":"uint256","name":"value","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"},{"type":"uint8","name":"v","internalType":"uint8"},{"type":"bytes32","name":"r","internalType":"bytes32"},{"type":"bytes32","name":"s","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"proxiableUUID","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address payable"}],"name":"resolve","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"bytes32","name":"_name","internalType":"bytes32"},{"type":"bool","name":"_allowZeroAddress","internalType":"bool"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address payable"}],"name":"resolve","inputs":[{"type":"bytes32","name":"_name","internalType":"bytes32"},{"type":"bool","name":"_allowZeroAddress","internalType":"bool"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"symbol","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"totalSupply","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"transfer","inputs":[{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"amount","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"transferFrom","inputs":[{"type":"address","name":"from","internalType":"address"},{"type":"address","name":"to","internalType":"address"},{"type":"uint256","name":"amount","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"unpause","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"upgradeTo","inputs":[{"type":"address","name":"newImplementation","internalType":"address"}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"upgradeToAndCall","inputs":[{"type":"address","name":"newImplementation","internalType":"address"},{"type":"bytes","name":"data","internalType":"bytes"}]}]
Contract Creation Code
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
Deployed ByteCode
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